Fix #2201: Less aggressive type application reduction for better inference

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

@@ -391,9 +391,12 @@ class TypeApplications(val self: Type) extends AnyVal {
           if (!args.exists(_.isInstanceOf[TypeBounds])) {
             val followAlias = Config.simplifyApplications && {
               dealiased.resType match {
-                case AppliedType(tyconBody, _) =>
-                  sameLength(dealiased.typeParams, tyconBody.typeParams)
-                    // Reducing is safe for type inference, as kind arity of type constructor does not change
+                case AppliedType(tyconBody, dealiasedArgs) =>
+                  // Reduction should not affect type inference when it's
+                  // just eta-reduction (ignoring variance annotations).
+                  // See i2201*.scala for examples where more aggressive
+                  // reduction would break type inference.
+                  dealiased.paramRefs == dealiasedArgs
                 case _ => false
               }
             }

tests/pos/i2201a.scala

@@ -0,0 +1,8 @@
+class Foo[T]
+
+class Fix[F[_]](unfix: F[Fix[F]])
+object DocTree {
+  type Const[T] = Foo[Int]
+  type FixConst = Fix[Const]
+  def docTree(s: Const[FixConst]): FixConst = new Fix(s)
+}

tests/pos/i2201b.scala

@@ -0,0 +1,14 @@
+trait X
+trait Y
+
+object Test {
+  type One[A <: X, B <: Y]
+
+  type Two[TA <: Y, TB <: X] = One[TB, TA]
+
+  def foo[M[_ <: Y, _ <: X]](x: M[_ <: Y, _ <: X]) = x
+
+  val a: Two[Y, X] = ???
+
+  foo(a)
+}

tests/pos/i2201c.scala

@@ -0,0 +1,11 @@
+object Test {
+  implicit val theAnswer: Int = 42
+
+  type Swap[A, B] = (B, A)
+
+  def foo[M[_, _], T, S](x: M[T, S])(implicit ev: T) = ev
+
+  val a: Swap[Int, String] = ("hi", 1)
+
+  foo(a)
+}