add GADT test

Author: liufengyun

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

@@ -266,19 +266,12 @@ class SpaceEngine(implicit ctx: Context) extends SpaceLogic {
       Empty
   }
 
-  /** Is `tp1` a subtype of `tp2`?
-   *
-   *  Ignore type parameters in comparison due to erasure, i.e., Some[Int] <: Some[T]
-   */
-  def isSubType(tp1: Type, tp2: Type): Boolean = (tp1, tp2) match {
-    case (tp1: RefinedType, tp2: RefinedType) => isSubType(tp1.parent, tp2.parent)
-    case (tp1: RefinedType, _) => isSubType(tp1.parent, tp2)
-    case (_, tp2: RefinedType) => isSubType(tp1, tp2.parent)
-    case (_, _) => tp1 <:< tp2
-  }
+  /** Is `tp1` a subtype of `tp2`?  */
+  def isSubType(tp1: Type, tp2: Type): Boolean = tp1 <:< tp2
 
   def isEqualType(tp1: Type, tp2: Type): Boolean = tp1 =:= tp2
 
+  /** Parameter types of the case class type `tp`  */
   def signature(tp: Type): List[Type] = {
     val ktor = tp.classSymbol.primaryConstructor.info
 
@@ -325,10 +318,14 @@ class SpaceEngine(implicit ctx: Context) extends SpaceLogic {
           else if (sym.info.typeParams.length > 0 || tp.isInstanceOf[TypeRef])
             refine(tp, sym.asClass.classInfo.symbolicTypeRef)
           else
-            sym.info
-        } filter(_ <:< tp) // child may not always be subtype of parent: SI-4020
-
-        parts.map(tp => Typ(tp, true))
+            sym.typeRef
+        } filter { tpe =>
+          // Child class may not always be subtype of parent:
+          // GADT & path-dependent types
+          isSubType(tpe, tp)
+        }
+
+        parts.map(Typ(_, true))
     }
   }
 

tests/patmat/gadt.check

@@ -0,0 +1,13 @@
+./tests/patmat/gadt.scala:13: warning: match may not be exhaustive.
+It would fail on the following input: IntLit(_)
+  def foo1b(x: Expr[Int]) = x match {
+                              ^
+./tests/patmat/gadt.scala:22: warning: match may not be exhaustive.
+It would fail on the following input: Or(_, _)
+  def foo2b(x: Expr[Boolean]) = x match {
+                                  ^
+./tests/patmat/gadt.scala:45: warning: match may not be exhaustive.
+It would fail on the following input: BooleanLit(_), IntLit(_)
+  def foo4b(x: Expr) = x match {
+                         ^
+three warnings found

tests/patmat/gadt.scala

@@ -0,0 +1,49 @@
+object Test {
+  sealed trait Expr[T]
+  case class IntLit(i: Int) extends Expr[Int]
+  case class BooleanLit(b: Boolean) extends Expr[Boolean]
+  case class Sum(l: Expr[Int], r: Expr[Int]) extends Expr[Int]
+  case class Or(l: Expr[Boolean], r: Expr[Boolean]) extends Expr[Boolean]
+
+  def foo1a(x: Expr[Int]) = x match {
+    case _: IntLit => true
+    case _: Sum => true
+  }
+
+  def foo1b(x: Expr[Int]) = x match {
+    case _: Sum => true
+  }
+
+  def foo2a(x: Expr[Boolean]) = x match {
+    case _: BooleanLit => true
+    case _: Or => true
+  }
+
+  def foo2b(x: Expr[Boolean]) = x match {
+    case _: BooleanLit => true
+  }
+
+  def foo3a(x: Expr[Boolean]) = x match {
+    case _: BooleanLit => true
+    case _: Or => true
+    // case _: Sum => true
+  }
+
+  def foo3b(x: Expr[Int]) = x match {
+    case _: IntLit => true
+    case _: Sum => true
+    // case _: Or => true
+  }
+
+  def foo4a(x: Expr) = x match {
+    case _: IntLit => true
+    case _: Sum => true
+    case _: BooleanLit => true
+    case _: Or => true
+  }
+
+  def foo4b(x: Expr) = x match {
+    case _: Sum => true
+    case _: Or => true
+  }
+}