address review

Author: liufengyun

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

@@ -710,29 +710,26 @@ class SpaceEngine(implicit ctx: Context) extends SpaceLogic {
 
   /** Whether the counterexample is satisfiable. The space is flattened and non-empty. */
   def satisfiable(sp: Space): Boolean = {
+    def impossible: Nothing = throw new AssertionError("`satisfiable` only accepts flattened space.")
+
     def genConstraint(space: Space): List[(Type, Type)] = space match {
       case Prod(tp, unappTp, unappSym, ss, _) =>
         val tps = signature(unappTp, unappSym, ss.length)
         ss.zip(tps).flatMap {
           case (sp : Prod, tp) => sp.tp -> tp :: genConstraint(sp)
           case (Typ(tp1, _), tp2) => tp1 -> tp2 :: Nil
-          case _ => ???  // impossible
+          case _ => impossible
         }
       case Typ(_, _) => Nil
-      case _ => ??? // impossible
+      case _ => impossible
     }
 
     def checkConstraint(constrs: List[(Type, Type)])(implicit ctx: Context): Boolean = {
       val tvarMap = collection.mutable.Map.empty[Symbol, TypeVar]
       val typeParamMap = new TypeMap() {
         override def apply(tp: Type): Type = tp match {
           case tref: TypeRef if tref.symbol.is(TypeParam) =>
-            if (tvarMap.contains(tref.symbol)) tvarMap(tref.symbol)
-            else {
-              val tvar = newTypeVar(tref.underlying.bounds)
-              tvarMap(tref.symbol) = tvar
-              tvar
-            }
+            tvarMap.getOrElseUpdate(tref.symbol, newTypeVar(tref.underlying.bounds))
           case tp => mapOver(tp)
         }
       }
@@ -810,10 +807,11 @@ class SpaceEngine(implicit ctx: Context) extends SpaceLogic {
     res
   }
 
-  def checkGADT(tp: Type): Boolean = {
+  /** Whehter counter-examples should be further checked? True for GADTs. */
+  def shouldCheckExamples(tp: Type): Boolean = {
     new TypeAccumulator[Boolean] {
       override def apply(b: Boolean, tp: Type): Boolean = tp match {
-        case tref: TypeRef if tref.symbol.is(TypeParam) && variance == 0 => true
+        case tref: TypeRef if tref.symbol.is(TypeParam) && variance != 1 => true
         case tp => b || foldOver(b, tp)
       }
     }.apply(false, tp)
@@ -830,7 +828,7 @@ class SpaceEngine(implicit ctx: Context) extends SpaceLogic {
       space
     }).reduce((a, b) => Or(List(a, b)))
 
-    val checkGADTSAT = checkGADT(selTyp)
+    val checkGADTSAT = shouldCheckExamples(selTyp)
 
     val uncovered =
       flatten(simplify(minus(Typ(selTyp, true), patternSpace), aggressive = true))