Refix constraining two intersections

In trying to fix i18453 I changed how a method was eta-expanded, making
it infer differently.  That difference in type inference affected a lot
of code.  So I went back to the problem and tried to fix the
over-constraining that was occurring previously.

Author: dwijnand

compiler/src/dotty/tools/dotc/core/TypeComparer.scala

@@ -383,7 +383,20 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
         }
         compareSuper
       case AndType(tp21, tp22) =>
-        recur(tp1, tp21) && recur(tp1, tp22)
+        tp1 match
+          case AndType(tp11, tp12) =>
+            // In  A1 & B2  <:<  B1 & A2
+            // Avoid over-constraining by attempting to satisfy the subtype
+            // with either combination of the intersection parts
+            // (1s and 2s, or As and Bs).
+            // We have to make sure to rollback failed part attempts.
+            either(
+              rollbackConstraintsUnless(recur(tp11, tp21) && recur(tp12, tp22)),
+              rollbackConstraintsUnless(recur(tp11, tp22) && recur(tp12, tp21)),
+            ) ||
+            recur(tp1, tp21) && recur(tp1, tp22)
+          case _ =>
+            recur(tp1, tp21) && recur(tp1, tp22)
       case OrType(tp21, tp22) =>
         if (tp21.stripTypeVar eq tp22.stripTypeVar) recur(tp1, tp21)
         else secondTry
@@ -1010,7 +1023,7 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
         if (tp2a ne tp2) // Follow the alias; this might avoid truncating the search space in the either below
           return recur(tp1, tp2a)
 
-        // Rewrite (T111 | T112) & T12 <: T2 to (T111 & T12) <: T2 and (T112 | T12) <: T2
+        // Rewrite (T111 | T112) & T12 <: T2 to (T111 & T12) <: T2 and (T112 & T12) <: T2
         // and analogously for T11 & (T121 | T122) & T12 <: T2
         // `&' types to the left of <: are problematic, because
         // we have to choose one constraint set or another, which might cut off
@@ -1982,6 +1995,13 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
     else op2
   end necessaryEither
 
+  inline def rollbackConstraintsUnless(inline op: Boolean): Boolean =
+    val saved = constraint
+    var result = false
+    try result = ctx.gadtState.rollbackGadtUnless(op)
+    finally if !result then constraint = saved
+    result
+
   /** Decompose into conjunction of types each of which has only a single refinement */
   def decomposeRefinements(tp: Type, refines: List[(Name, Type)]): Type = tp match
     case RefinedType(parent, rname, rinfo) =>

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -4194,7 +4194,11 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
           val funExpected = functionExpected
           val arity =
             if funExpected then
-              defn.functionArity(ptNorm)
+              if !isFullyDefined(pt, ForceDegree.none) && isFullyDefined(wtp, ForceDegree.none) then
+                // if method type is fully defined, but expected type is not,
+                // prioritize method parameter types as parameter types of the eta-expanded closure
+                0
+              else defn.functionArity(ptNorm)
             else
               val nparams = wtp.paramInfos.length
               if nparams > 1

tests/neg/i5976.scala

@@ -1,6 +1,6 @@
 object Test {
   def f(i: => Int) = i + i
-  val res = List(42).map(f)
+  val res = List(42).map(f) // error
 
   val g: (=> Int) => Int = f
   val h: Int => Int = g // error

tests/pos/i19001.case1.scala

@@ -0,0 +1,19 @@
+import java.util.concurrent.CompletionStage
+import scala.concurrent.Future
+
+trait ActorRef[-T]:
+   def ask[Res](replyTo: ActorRef[Res] => T): Future[Res] = ???
+
+implicit final class FutureOps[T](private val f: Future[T]) extends AnyVal:
+  def asJava: CompletionStage[T] = ???
+
+class AskPattern[Req, Res]:
+  val actor: ActorRef[Req] = ???
+  val messageFactory: ActorRef[Res] => Req = ???
+
+  def failing(): CompletionStage[Res] = actor.ask(messageFactory.apply).asJava
+  def workaround1(): CompletionStage[Res] = actor.ask[Res](messageFactory.apply).asJava
+  def workaround2(): CompletionStage[Res] = actor.ask(messageFactory).asJava
+
+  val jMessageFactory: java.util.function.Function[ActorRef[Res], Req] = ???
+  def originalFailingCase(): CompletionStage[Res] = actor.ask(jMessageFactory.apply).asJava

tests/pos/i19001.case2.scala

@@ -0,0 +1,16 @@
+import scala.util.{Try, Success, Failure}
+
+trait ActorRef[-T]
+trait ActorContext[T]:
+  def ask[Req, Res](target: ActorRef[Req], createRequest: ActorRef[Res] => Req)(mapResponse: Try[Res] => T): Unit
+
+@main def Test =
+  val context: ActorContext[Int] = ???
+  val askMeRef: ActorRef[Request] = ???
+
+  case class Request(replyTo: ActorRef[Int])
+
+  context.ask(askMeRef, Request.apply) {
+    case Success(res) => res // error: expected Int, got Any
+    case Failure(ex)  => throw ex
+  }

tests/pos/i19001.case3.scala

@@ -0,0 +1,12 @@
+trait IO[A]:
+  def map[B](f: A => B): IO[B] = ???
+
+trait RenderResult[T]:
+  def value: T
+
+def IOasync[T](f: (Either[Throwable, T] => Unit) => Unit): IO[T] = ???
+
+def render[T]: IO[T] = {
+  def register(cb: Either[Throwable, RenderResult[T]] => Unit): Unit = ???
+  IOasync(register).map(_.value) // map should take RenderResult[T], but uses Any
+}

tests/pos/i19009.case1.scala

@@ -0,0 +1,18 @@
+trait Player[+P]
+trait RatingPeriod[P]:
+  def games: Map[P, Vector[ScoreVsPlayer[P]]]
+
+trait ScoreVsPlayer[+P]
+
+def updated[P](playerID: P, matchResults: IndexedSeq[ScoreVsPlayer[P]], lookup: P => Option[Player[P]]): Player[P] = ???
+
+trait Leaderboard[P]:
+  def  playersByIdInNoParticularOrder: Map[P, Player[P]]
+
+  def after[P2 >: P](ratingPeriod: RatingPeriod[? <: P]): Leaderboard[P2] =
+    val competingPlayers = ratingPeriod.games.iterator.map { (id, matchResults) =>
+      updated(id, matchResults, playersByIdInNoParticularOrder.get) // error
+      // workaround:
+      updated[P](id, matchResults, playersByIdInNoParticularOrder.get)
+    }
+    ???

tests/pos/i19009.case2.scala

@@ -0,0 +1,10 @@
+object NodeOrdering:
+  def postOrderNumbering[NodeType](cfgEntry: NodeType, expand: NodeType => Iterator[NodeType]): Map[NodeType, Int]  = ???
+
+trait CfgNode
+trait Method extends CfgNode
+
+def postOrder =
+  def method: Method = ???
+  def expand(x: CfgNode): Iterator[CfgNode] = ???
+  NodeOrdering.postOrderNumbering(method, expand)

tests/pos/i19009.case3.scala

@@ -0,0 +1,31 @@
+trait Bound[+E]
+
+trait SegmentT[E, +S]
+object SegmentT:
+  trait WithPrev[E, +S] extends SegmentT[E, S]
+
+trait SegmentSeqT[E, +S]:
+  def getSegmentForBound(bound: Bound[E]): SegmentT[E, S] with S
+
+abstract class AbstractSegmentSeq[E, +S] extends SegmentSeqT[E, S]
+
+trait MappedSegmentBase[E, S]
+
+type MappedSegment[E, S] = AbstractMappedSegmentSeq.MappedSegment[E, S]
+
+object AbstractMappedSegmentSeq:
+  type MappedSegment[E, S] = SegmentT[E, MappedSegmentBase[E, S]] with MappedSegmentBase[E, S]
+
+abstract class AbstractMappedSegmentSeq[E, S]
+    extends AbstractSegmentSeq[E, MappedSegmentBase[E, S]]:
+  def originalSeq: SegmentSeqT[E, S]
+
+  final override def getSegmentForBound(bound: Bound[E]): MappedSegment[E, S] =
+    searchFrontMapper(frontMapperGeneral, originalSeq.getSegmentForBound(bound))
+
+  protected final def frontMapperGeneral(original: SegmentT[E, S]): MappedSegment[E, S] = ???
+
+  protected def searchFrontMapper[Seg >: SegmentT.WithPrev[E, S] <: SegmentT[E, S], R](
+      mapper: Seg => R,
+      original: Seg
+  ): R = ???