handle abstract types in child's parent list

Author: liufengyun

compiler/src/dotty/tools/dotc/transform/patmat/Space.scala

@@ -602,10 +602,19 @@ class SpaceEngine(implicit ctx: Context) extends SpaceLogic {
     // map `ThisType` of `tp1` to a type variable
     // precondition: `tp1` should have the shape `path.Child`, thus `ThisType` is always covariant
     val thisTypeMap = new TypeMap {
-      def apply(t: Type): Type = t match {
+      def apply(t: Type): Type = t.dealias match {
         case tp @ ThisType(tref) if !tref.symbol.isStaticOwner  =>
           if (tref.symbol.is(Module)) mapOver(tref)
           else newTypeVar(TypeBounds.upper(tp.underlying))
+        case tp: TypeRef if tp.underlying.isInstanceOf[TypeBounds] =>
+          // See tests/patmat/3645b.scala
+          val exposed =
+            if (variance == 0) newTypeVar(tp.underlying.bounds)
+            else if (variance == 1) mapOver(tp.underlying.hiBound)
+            else mapOver(tp.underlying.loBound)
+
+          debug.println(s"$tp exposed to =====> $exposed")
+          exposed
         case _ =>
           mapOver(t)
       }
@@ -644,13 +653,19 @@ class SpaceEngine(implicit ctx: Context) extends SpaceLogic {
     val tvars = tp1.typeParams.map { tparam => newTypeVar(tparam.paramInfo.bounds) }
     val protoTp1 = thisTypeMap(tp1.appliedTo(tvars))
 
+    // tests/patmat/3645b.scala
+    def parentQualify = tp1.widen.classSymbol.info.parents.exists { parent =>
+      (parent.argInfos.nonEmpty || parent.abstractTypeMembers.nonEmpty) &&
+        instantiate(parent, tp2)(ctx.fresh.setNewTyperState()).exists
+    }
+
     if (protoTp1 <:< tp2) {
       if (isFullyDefined(protoTp1, force)) protoTp1
       else instUndetMap(protoTp1)
     }
     else {
       val protoTp2 = typeParamMap(tp2)
-      if (protoTp1 <:< protoTp2) {
+      if (protoTp1 <:< protoTp2 || parentQualify) {
         if (isFullyDefined(AndType(protoTp1, protoTp2), force)) protoTp1
         else instUndetMap(protoTp1)
       }

tests/patmat/3645b.check

@@ -0,0 +1 @@
+21: Pattern Match Exhaustivity: K3, K2

tests/patmat/3645b.scala

@@ -0,0 +1,29 @@
+object App {
+  def main(args: Array[String]): Unit = {
+    trait FooT {
+      type T
+      def subst[F[_]](fa: F[T]): F[Int]
+    }
+    val Foo: FooT = new FooT {
+      type T = Int
+
+      def subst[F[_]](fa: F[T]): F[Int] = fa
+    }
+    type Foo = Foo.T
+    type Bar = Foo
+
+    sealed abstract class K[A]
+    final case object K1 extends K[Int]
+    final case object K2 extends K[Foo]
+    final case object K3 extends K[Bar]
+
+    val foo: K[Int] = Foo.subst[K](K2)
+    def get(k: K[Int]): Unit = k match {
+      case K1 => ()
+      // case K2 => ()
+      // case K3 => ()
+    }
+
+    get(foo)
+  }
+}