Add more tests, stop logging

Author: abgruszecki

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

@@ -1017,13 +1017,19 @@ class TypeComparer(initctx: Context) extends ConstraintHandling[AbsentContext] {
     else if (tp1 eq tp2) true
     else {
       val saved = constraint
+      var savedGadt: GadtConstraint = null
+      if (ctx.mode.is(Mode.GADTflexible)) savedGadt = ctx.gadt.fresh
       val savedSuccessCount = successCount
       try {
         recCount = recCount + 1
         if (recCount >= Config.LogPendingSubTypesThreshold) monitored = true
         val result = if (monitored) monitoredIsSubType else firstTry
         recCount = recCount - 1
-        if (!result) state.resetConstraintTo(saved)
+        if (!result) {
+          state.resetConstraintTo(saved)
+          if (savedGadt ne null)
+            ctx.gadt.restore(savedGadt)
+        }
         else if (recCount == 0 && needsGc) {
           state.gc()
           needsGc = false
@@ -2093,18 +2099,18 @@ class TypeComparer(initctx: Context) extends ConstraintHandling[AbsentContext] {
   }
 
   def notIntersection(tp: Type, pt: Type): Boolean =
-  trace(i"notIntersection($tp, $pt)")
+//  trace.force(i"notIntersection($tp, $pt)")
   {
+    import config.Printers.debug
     import typer.Inferencing._
 
     def incompatibleClasses: Boolean = {
       import Flags._
-      val tpClassSym = tp.classSymbol
-      val ptClassSym = pt.classSymbol
-      println(i"tpClassSym=$tpClassSym, fin=${tpClassSym.is(Final)}")
-      println(i"ptClassSym=$ptClassSym, fin=${ptClassSym.is(Final)}")
+      val tpClassSym = tp.widenSingleton.classSymbol
+      val ptClassSym = pt.widenSingleton.classSymbol
+      debug.println(i"tpClassSym=$tpClassSym, fin=${tpClassSym.is(Final)}")
+      debug.println(i"pt=$pt  {${pt.getClass}},  ptClassSym=$ptClassSym, fin=${ptClassSym.is(Final)}")
       tpClassSym.exists && ptClassSym.exists && {
-        println("here")
         if (tpClassSym.is(Final)) !tpClassSym.derivesFrom(ptClassSym)
         else if (ptClassSym.is(Final)) !ptClassSym.derivesFrom(tpClassSym)
         else if (!tpClassSym.is(Flags.Trait) && !ptClassSym.is(Flags.Trait))
@@ -2114,7 +2120,7 @@ class TypeComparer(initctx: Context) extends ConstraintHandling[AbsentContext] {
     }
 
     def loop(tp: Type): Boolean =
-    trace.force(i"loop($tp) // ${tp.toString}")
+//    trace.force(i"loop($tp) // ${tp.toString}")
     {
       if (constrainPatternType(pt, tp)) true
       else if (incompatibleClasses) {
@@ -2130,7 +2136,7 @@ class TypeComparer(initctx: Context) extends ConstraintHandling[AbsentContext] {
         case tp @ AppliedType(tycon: TypeRef, _) if tycon.symbol.isClass =>
           val ptClassSym = pt.classSymbol
           def firstParentSharedWithPt(tp: Type, tpClassSym: ClassSymbol): Symbol =
-            trace.force(i"f($tp)")
+//            trace.force(i"f($tp)")
             {
             var parents = tpClassSym.info.parents
 //            println(i"parents of $tpClassSym = $parents%, %")

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -3082,7 +3082,7 @@ class Typer extends Namer
       case _: RefTree | _: Literal
         if !isVarPattern(tree) &&
            !(pt <:< tree.tpe) &&
-           !(tree.tpe <:< pt)(ctx.addMode(Mode.GADTflexible)) =>
+           !ctx.addMode(Mode.GADTflexible).typeComparer.notIntersection(pt, tree.tpe) =>
         val cmp =
           untpd.Apply(
             untpd.Select(untpd.TypedSplice(tree), nme.EQ),

tests/neg/nontrivial-intersection-gadt.scala

@@ -5,18 +5,18 @@ object Test {
   final class Fin
 
   def foo1[T](x: Unit | Const[T]): T = x match {
-    case _: IntExpr => 0
+    case _: IntExpr => 0 // error
   }
 
   def bar1[T](x: Const[T]): T = x match {
-    case _: (Unit | IntExpr) => 0
+    case _: (Unit | IntExpr) => 0 // error
   }
 
   def foo2[T](x: Fin | Const[T]): T = x match {
-    case _: IntExpr => 0
+    case _: IntExpr => 0 // error
   }
 
   def bar2[T](x: Const[T]): T = x match {
-    case _: (Fin | IntExpr) => 0
+    case _: (Fin | IntExpr) => 0 // error
   }
 }

tests/neg/unsound-covariant-gadt.scala

@@ -0,0 +1,10 @@
+object Test {
+  sealed trait Expr[+T]
+  case class IntVal[+T <: Int]() extends Expr[T]
+  case object ActualInt extends Expr[Int]
+  def eval[T](e: Expr[T]): T = e match {
+    case IntVal() => 0 // error
+    case ActualInt => 0
+  }
+}
+

tests/neg/unsound-union-gadt.scala

@@ -0,0 +1,13 @@
+object Test {
+  enum Expr[+T] {
+    case StrLit() extends Expr[String]
+    case IntLit() extends Expr[Int]
+  }
+  import Expr._
+
+  def foo[T](e: Expr[T]) = e match {
+    case _: (StrLit | IntLit) =>
+      val str: T = "" // error
+      val int: T = 42 // error
+  }
+}