remove limitation errors in structural gadt neg tests

These limitation is solved by path-dependent GADT now.

Author: Linyxus

tests/neg/structural-gadt.scala

@@ -18,11 +18,11 @@ object Test {
       val i: Int = ??? : A // limitation // error
 
     case _: IntExpr =>
-      val a: A = 0 // limitation // error
+      val a: A = 0
       val i: Int = ??? : A // limitation // error
 
     case _: Expr { type T = Int } =>
-      val a: A = 0 // limitation // error
+      val a: A = 0
       val i: Int = ??? : A // limitation // error
   }
 
@@ -36,11 +36,11 @@ object Test {
       val i: Int = ??? : A // error
 
     case _: IntExpr =>
-      val a: A = 0 // limitation // error
+      val a: A = 0
       val i: Int = ??? : A // error
 
     case _: Expr { type T = Int } =>
-      val a: A = 0 // limitation // error
+      val a: A = 0
       val i: Int = ??? : A // error
   }
 

tests/neg/structural-recursive-both1-gadt.scala

@@ -28,23 +28,23 @@ object Test {
   def foo[A](e: IndirectExprExact[A]) = e match {
     case _: AltIndirectIntLit =>
       val a: A = 0 // error
-      val i: Int = ??? : A // limitation // error
+      val i: Int = ??? : A
 
     case _: AltIndirectExprSub[Int] =>
       val a: A = 0 // error
-      val i: Int = ??? : A // limitation // error
+      val i: Int = ??? : A
 
     case _: AltIndirectExprSub2[Int] =>
       val a: A = 0 // error
-      val i: Int = ??? : A // limitation // error
+      val i: Int = ??? : A
 
     case _: AltIndirectIntExpr =>
-      val a: A = 0 // limitation // error
-      val i: Int = ??? : A // limitation // error
+      val a: A = 0
+      val i: Int = ??? : A
 
     case _: AltIndirectExprExact[Int] =>
-      val a: A = 0 // limitation // error
-      val i: Int = ??? : A // limitation // error
+      val a: A = 0
+      val i: Int = ??? : A
   }
 
   def bar[A](e: IndirectExprSub[A]) = e match {
@@ -83,11 +83,11 @@ object Test {
       val i: Int = ??? : A // error
 
     case _: AltIndirectIntExpr =>
-      val a: A = 0 // limitation // error
+      val a: A = 0
       val i: Int = ??? : A // error
 
     case _: AltIndirectExprExact[Int] =>
-      val a: A = 0 // limitation // error
+      val a: A = 0
       val i: Int = ??? : A // error
   }
 }

tests/neg/structural-recursive-both2-gadt.scala

@@ -28,23 +28,23 @@ object Test {
   def foo[A](e: AltIndirectExprExact[A]) = e match {
     case _: IndirectIntLit =>
       val a: A = 0 // error
-      val i: Int = ??? : A // limitation // error
+      val i: Int = ??? : A
 
     case _: IndirectExprSub[Int] =>
       val a: A = 0 // error
-      val i: Int = ??? : A // limitation // error
+      val i: Int = ??? : A
 
     case _: IndirectExprSub2[Int] =>
       val a: A = 0 // error
-      val i: Int = ??? : A // limitation // error
+      val i: Int = ??? : A
 
     case _: IndirectIntExpr =>
-      val a: A = 0 // limitation // error
-      val i: Int = ??? : A // limitation // error
+      val a: A = 0
+      val i: Int = ??? : A
 
     case _: IndirectExprExact[Int] =>
-      val a: A = 0 // limitation // error
-      val i: Int = ??? : A // limitation // error
+      val a: A = 0
+      val i: Int = ??? : A
   }
 
   def bar[A](e: AltIndirectExprSub[A]) = e match {
@@ -83,11 +83,11 @@ object Test {
       val i: Int = ??? : A // error
 
     case _: IndirectIntExpr =>
-      val a: A = 0 // limitation // error
+      val a: A = 0
       val i: Int = ??? : A // error
 
     case _: IndirectExprExact[Int] =>
-      val a: A = 0 // limitation // error
+      val a: A = 0
       val i: Int = ??? : A // error
   }
 }

tests/neg/structural-recursive-pattern-gadt.scala

@@ -39,11 +39,11 @@ object Test {
       val i: Int = ??? : A // limitation // error
 
     case _: IndirectIntExpr =>
-      val a: A = 0 // limitation // error
-      val i: Int = ??? : A // limitation // error
+      val a: A = 0
+      val i: Int = ??? : A
 
     case _: IndirectExprExact[Int] =>
-      val a: A = 0 // limitation // error
+      val a: A = 0
       val i: Int = ??? : A // limitation // error
   }
 
@@ -61,11 +61,11 @@ object Test {
       val i: Int = ??? : A // error
 
     case _: IndirectIntExpr =>
-      val a: A = 0 // limitation // error
+      val a: A = 0
       val i: Int = ??? : A // error
 
     case _: IndirectExprExact[Int] =>
-      val a: A = 0 // limitation // error
+      val a: A = 0
       val i: Int = ??? : A // error
   }
 }

tests/neg/structural-recursive-scrutinee-gadt.scala

@@ -28,19 +28,19 @@ object Test {
   def foo[A](e: IndirectExprExact[A]) = e match {
     case _: IntLit =>
       val a: A = 0 // error
-      val i: Int = ??? : A // limitation // error
+      val i: Int = ??? : A
 
     case _: ExprSub[Int] =>
       val a: A = 0 // error
-      val i: Int = ??? : A // limitation // error
+      val i: Int = ??? : A
 
     case _: IntExpr =>
-      val a: A = 0 // limitation // error
-      val i: Int = ??? : A // limitation // error
+      val a: A = 0
+      val i: Int = ??? : A
 
     case _: ExprExact[Int] =>
-      val a: A = 0 // limitation // error
-      val i: Int = ??? : A // limitation // error
+      val a: A = 0
+      val i: Int = ??? : A
   }
 
   def bar[A](e: IndirectExprSub[A]) = e match {
@@ -71,11 +71,11 @@ object Test {
       val i: Int = ??? : A // error
 
     case _: IntExpr =>
-      val a: A = 0 // limitation // error
+      val a: A = 0
       val i: Int = ??? : A // error
 
     case _: ExprExact[Int] =>
-      val a: A = 0 // limitation // error
+      val a: A = 0
       val i: Int = ??? : A // error
   }
 }