Don't dealias when matching type constructors

Not only can this prevent some constraints from being inferred, it can
lead to the wrong constraints being inferred due to partial unification,
see comment.

This change broke one test, in i6565.scala we had:

  type Lifted[A] = Err | A
  extension [O, U](o: Lifted[O]) def map(f: O => U): Lifted[U] = ???

  val error: Err = Err()

  lazy val ok: Lifted[String] = {
    point("a").map(_ => if true then "foo" else error)
      // now fails because error does not have type String
  }

Because `isMatchingApply` can now deal with aliased types, when typing
the lambda we get the constraint `U <: String` from
`Lifted[U] <: Lifted[String]`, so `Err` is no longer a subtype of the
expected result type of the lambda. This can be fixed in a number of
ways: I changed the test to use `flatMap` instead of `map`, but one
could also remove the expected type, or replace it by
`Lifted[Lifted[String]` or `Err | String`.

I think the new behavior is arguably better since using type aliases now
gives you more control on how type inference proceeds, even if it means
that some things that used to typecheck don't anymore.

This change is also necessary to get shapeless to compile after the
following commit which makes partial unification work in more
situation.

Author: smarter

Diff for: compiler/src/dotty/tools/dotc/core/TypeComparer.scala

@@ -860,13 +860,35 @@ class TypeComparer(using val comparerCtx: Context) extends ConstraintHandling wi
        */
       def isMatchingApply(tp1: Type): Boolean = tp1 match {
         case AppliedType(tycon1, args1) =>
-          def loop(tycon1: Type, args1: List[Type]): Boolean = tycon1.dealiasKeepRefiningAnnots match {
+          // We intentionally do not dealias `tycon1` or `tycon2` here.
+          // `TypeApplications#appliedTo` already takes care of dealiasing type
+          // constructors when this can be done without affecting type
+          // inference, doing it here would not only prevent code from compiling
+          // but could also result in the wrong thing being inferred later, for example
+          // in `tests/run/hk-alias-unification.scala` we end up checking:
+          //
+          //   Foo[?F, ?T] <:< Foo[[X] =>> (X, String), Int]
+          //
+          // Naturally, we'd like to infer:
+          //
+          //   ?F := [X] => (X, String)
+          //
+          // but if we dealias `Foo` then we'll end up trying to check:
+          //
+          //   ErasedFoo[?F[?T]] <:< ErasedFoo[(Int, String)]
+          //
+          // Because of partial unification, this will succeed, but will produce the constraint:
+          //
+          //   ?F := [X] =>> (Int, X)
+          //
+          // Which is not what we wanted!
+          def loop(tycon1: Type, args1: List[Type]): Boolean = tycon1 match {
             case tycon1: TypeParamRef =>
               (tycon1 == tycon2 ||
                canConstrain(tycon1) && isSubType(tycon1, tycon2)) &&
               isSubArgs(args1, args2, tp1, tparams)
             case tycon1: TypeRef =>
-              tycon2.dealiasKeepRefiningAnnots match {
+              tycon2 match {
                 case tycon2: TypeRef =>
                   val tycon1sym = tycon1.symbol
                   val tycon2sym = tycon2.symbol

Diff for: tests/pos/i6565.scala

@@ -8,10 +8,10 @@ extension [O, U](o: Lifted[O]) def flatMap(f: O => Lifted[U]): Lifted[U] = ???
 
 val error: Err = Err()
 
-lazy val ok: Lifted[String] = { // ok despite map returning a union
-  point("a").map(_ => if true then "foo" else error) // ok
+lazy val ok: Lifted[String] = {
+  point("a").flatMap(_ => if true then "foo" else error)
 }
 
 lazy val nowAlsoOK: Lifted[String] = {
-  point("a").flatMap(_ => point("b").map(_ => if true then "foo" else error))
+  point("a").flatMap(_ => point("b").flatMap(_ => if true then "foo" else error))
 }

Diff for: tests/run/hk-alias-unification.scala

@@ -0,0 +1,23 @@
+trait Bla[T]
+object Bla {
+  implicit def blaInt: Bla[Int] = new Bla[Int] {}
+  implicit def blaString: Bla[String] = new Bla[String] {
+    assert(false, "I should not be summoned!")
+  }
+}
+
+trait ErasedFoo[FT]
+object Test {
+  type Foo[F[_], T] = ErasedFoo[F[T]]
+  type Foo2[F[_], T] = Foo[F, T]
+
+  def mkFoo[F[_], T](implicit gen: Bla[T]): Foo[F, T] = new Foo[F, T] {}
+  def mkFoo2[F[_], T](implicit gen: Bla[T]): Foo2[F, T] = new Foo2[F, T] {}
+
+  def main(args: Array[String]): Unit = {
+    val a: Foo[[X] =>> (X, String), Int] = mkFoo
+    val b: Foo2[[X] =>> (X, String), Int] = mkFoo
+    val c: Foo[[X] =>> (X, String), Int] = mkFoo2
+  }
+}
+