Fixx issue with GADTs using HKTs

Author: Aleksander Boruch-Gruszecki

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

@@ -740,9 +740,28 @@ class TypeComparer(initctx: Context) extends ConstraintHandling {
               isSubArgs(args1, args2, tp1, tparams)
             case tycon1: TypeRef =>
               tycon2.dealiasKeepRefiningAnnots match {
-                case tycon2: TypeRef if tycon1.symbol == tycon2.symbol =>
+                case tycon2: TypeRef =>
+                  val tycon1sym = tycon1.symbol
+                  val tycon2sym = tycon2.symbol
+
+                  var touchedGADTs = false
+                  def gadtBoundsContain(sym: Symbol, tp: Type): Boolean = {
+                    touchedGADTs = true
+                    val b = gadtBounds(sym)
+                    b != null && inFrozenConstraint {
+                      (b.lo =:= tp) && (b.hi =:= tp)
+                    }
+                  }
+
+                  val res = (
+                    tycon1sym == tycon2sym ||
+                    gadtBoundsContain(tycon1sym, tycon2) ||
+                    gadtBoundsContain(tycon2sym, tycon1)
+                  ) &&
                   isSubType(tycon1.prefix, tycon2.prefix) &&
                   isSubArgs(args1, args2, tp1, tparams)
+                  if (res && touchedGADTs) GADTused = true
+                  res
                 case _ =>
                   false
               }

tests/gadt/EQK.scala

@@ -0,0 +1,33 @@
+object EQK {
+  sealed trait EQ[A, B]
+  final case class Refl[A]() extends EQ[A, A]
+
+  sealed trait EQK[F[_], G[_]]
+  final case class ReflK[F[_]]() extends EQK[F, F]
+
+  def m0[F[_], G[_], A](fa: F[A], eqk: EQK[F, G]): G[A] =
+    eqk match { case ReflK() => fa }
+
+  def m1[F[_], G[_], A](fa: F[A], eq: EQ[A, Int], eqk: EQK[F, G]): G[Int] =
+    eqk match {
+      case ReflK() => eq match {
+        case Refl() =>
+          val r1: F[Int] = fa
+          val r2: G[A] = fa
+          val r3: F[Int] = r2
+          fa : G[Int]
+      }
+    }
+
+  def m2[F[_], G[_], A](fa: F[A], a: A, eq: EQ[F[A], G[Int]], eqk: EQK[F, G]): Int =
+    eqk match {
+      case ReflK() => eq match {
+        case Refl() =>
+          val r1: F[Int] = fa
+          val r2: G[A] = fa
+          val r3: F[Int] = r2
+          a
+      }
+    }
+
+}