handle higher-kinded types in child/parentTypeMap

Author: liufengyun

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

@@ -580,50 +580,68 @@ class SpaceEngine(implicit ctx: Context) extends SpaceLogic {
    *
    */
   def instantiate(tp1: Type, tp2: Type)(implicit ctx: Context): Type = {
-    // map `ThisType` of `tp1` to a type variable
-    // precondition: `tp1` should have the shape `path.Child`, thus `ThisType` is always covariant
-    def childTypeMap(implicit ctx: Context) = new TypeMap {
-      def apply(t: Type): Type = t.dealias match {
-        case tp @ ThisType(tref) if !tref.symbol.isStaticOwner  =>
-          if (tref.symbol.is(Module)) this(tref)
-          else newTypeVar(TypeBounds.upper(tp.underlying))
+    // expose abstract type references to their bounds or tvars according to variance
+    abstract class AbstractTypeMap(maximize: Boolean)(implicit ctx: Context) extends TypeMap {
+      def expose(tp: TypeRef): Type = {
+        val lo = this(tp.info.loBound)
+        val hi = this(tp.info.hiBound)
+        val exposed =
+          if (variance == 0)
+            newTypeVar(TypeBounds(lo, hi))
+          else if (variance == 1)
+            if (maximize) hi else lo
+          else
+            if (maximize) lo else hi
+
+        debug.println(s"$tp exposed to =====> $exposed")
+        exposed
+      }
 
+      override def mapOver(tp: Type): Type = tp match {
         case tp: TypeRef if tp.underlying.isInstanceOf[TypeBounds] =>
-          // Note that the logic for contra- and co-variance is reverse of `parentTypeMap`
-          // This is because we are checking the possibility of `tp1 <:< tp2`, thus we should
-          // minimize `tp1` while maximize `tp2`.    See tests/patmat/3645b.scala
-          val lo = tp.underlying.loBound
-          val hi = tp.underlying.hiBound
+          // See tests/patmat/gadt.scala  tests/patmat/exhausting.scala  tests/patmat/t9657.scala
+          expose(tp)
+
+        case AppliedType(tycon: TypeRef, args) if tycon.underlying.isInstanceOf[TypeBounds] =>
+          val args2 = args.map(this)
+          val lo = this(tycon.info.loBound).applyIfParameterized(args2)
+          val hi = this(tycon.info.hiBound).applyIfParameterized(args2)
           val exposed =
-            if (variance == 0) newTypeVar(TypeBounds(this(lo), this(hi)))
-            else if (variance == 1) this(lo)
-            else this(hi)
+            if (variance == 0)
+              newTypeVar(TypeBounds(lo, hi))
+            else if (variance == 1)
+              if (maximize) hi else lo
+            else
+              if (maximize) lo else hi
+
           debug.println(s"$tp exposed to =====> $exposed")
           exposed
-        case tp =>
-          mapOver(tp)
+
+        case _ =>
+          super.mapOver(tp)
       }
     }
 
-    // replace type parameter references with bounds
-    def parentTypeMap(implicit ctx: Context) = new TypeMap {
+    // We are checking the possibility of `tp1 <:< tp2`, thus we should
+    // minimize `tp1` while maximize `tp2`.    See tests/patmat/3645b.scala
+    def childTypeMap(implicit ctx: Context) = new AbstractTypeMap(maximize = false) {
       def apply(t: Type): Type = t.dealias match {
-        case tp: TypeRef if tp.underlying.isInstanceOf[TypeBounds] =>
-          // See tests/patmat/gadt.scala  tests/patmat/exhausting.scala  tests/patmat/t9657.scala
-          val lo = tp.underlying.loBound
-          val hi = tp.underlying.hiBound
-          val exposed =
-            if (variance == 0) newTypeVar(TypeBounds(this(lo), this(hi)))
-            else if (variance == 1) this(hi)
-            else this(lo)
+        // map `ThisType` of `tp1` to a type variable
+        // precondition: `tp1` should have the shape `path.Child`, thus `ThisType` is always covariant
+        case tp @ ThisType(tref) if !tref.symbol.isStaticOwner  =>
+          if (tref.symbol.is(Module)) this(tref)
+          else newTypeVar(TypeBounds.upper(tp.underlying))
 
-          debug.println(s"$tp exposed to =====> $exposed")
-          exposed
         case tp =>
           mapOver(tp)
       }
     }
 
+    // replace type parameter references with bounds
+    def parentTypeMap(implicit ctx: Context) = new AbstractTypeMap(maximize = true) {
+      def apply(tp: Type): Type = mapOver(tp.dealias)
+    }
+
     // replace uninstantiated type vars with WildcardType, check tests/patmat/3333.scala
     def instUndetMap(implicit ctx: Context) = new TypeMap {
       def apply(t: Type): Type = t match {

tests/patmat/i3645g.check

@@ -0,0 +1 @@
+29: Pattern Match Exhaustivity: K1

tests/patmat/i3645g.scala

@@ -0,0 +1,35 @@
+object App {
+  def main(args: Array[String]): Unit = {
+    trait ModuleSig {
+      type F[_]
+      type U
+
+      trait FooSig {
+        type Type = F[U]
+        def subst[F[_]](fa: F[Int]): F[Type]
+      }
+
+      val Foo: FooSig
+    }
+    val Module: ModuleSig = new ModuleSig {
+      type F[A] = Int
+
+      val Foo: FooSig = new FooSig {
+        // type Type = Int
+        def subst[F[_]](fa: F[Int]): F[Type] = fa
+      }
+    }
+    type Foo = Module.Foo.Type
+
+    sealed abstract class K[F]
+    final case object K1 extends K[Int]
+    final case object K2 extends K[Foo]
+
+    val kv: K[Foo] = Module.Foo.subst[K](K1)
+    def test(k: K[Foo]): Unit = k match {
+      case K2 => ()
+    }
+
+    test(kv)
+  }
+}