clean up

Author: liufengyun

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

@@ -427,20 +427,6 @@ class SpaceEngine(implicit ctx: Context) extends SpaceLogic {
     }
   }
 
-  /* Erase a type binding according to erasure semantics in pattern matching */
-  def erase(tp: Type): Type = {
-    tp match {
-      case tp @ AppliedType(tycon, args) => erase(tp.superType)
-        if (tycon.isRef(defn.ArrayClass)) tp.derivedAppliedType(tycon, args.map(erase))
-        else tp.derivedAppliedType(tycon, args.map(t => WildcardType(TypeBounds.empty)))
-      case OrType(tp1, tp2) =>
-        OrType(erase(tp1), erase(tp2))
-      case AndType(tp1, tp2) =>
-        AndType(erase(tp1), erase(tp2))
-      case _ => tp
-    }
-  }
-
   /** Is `tp1` a subtype of `tp2`?  */
   def isSubType(tp1: Type, tp2: Type): Boolean = {
     val res = tp1 <:< tp2
@@ -544,14 +530,7 @@ class SpaceEngine(implicit ctx: Context) extends SpaceLogic {
 
     val childTp  = if (child.isTerm) child.termRef else child.typeRef
 
-    var resTp = instantiate(childTp, parent)(ctx.fresh.setNewTyperState)
-
-    // try expose references to type parameters in the parent type
-    //
-    //   tests/patmat/t9657.scala
-    //   tests/patmat/gadt.scala LOC#50
-    //
-    // if (!resTp.exists) resTp = instantiate(childTp, expose(parent))(ctx.fresh.setNewTyperState)
+    var resTp = instantiate(childTp, expose(parent))(ctx.fresh.setNewTyperState)
 
     if (!resTp.exists)  {
       debug.println(s"[refine] unqualified child ousted: ${childTp.show} !< ${parent.show}")
@@ -586,9 +565,7 @@ class SpaceEngine(implicit ctx: Context) extends SpaceLogic {
     val tvars = tp1.typeParams.map { tparam => newTypeVar(tparam.paramInfo.bounds) }
     val protoTp1 = thisTypeMap(tp1.appliedTo(tvars))
 
-    // try expose references to type parameters in the parent type
-    //   tests/patmat/t9657.scala
-    //   tests/patmat/gadt.scala LOC#50
+    // replace type parameter references with fresh type vars or bounds
     val typeParamMap = new TypeMap {
       def apply(t: Type): Type = t match {
         case tp: TypeRef if tp.underlying.isInstanceOf[TypeBounds] =>
@@ -599,7 +576,7 @@ class SpaceEngine(implicit ctx: Context) extends SpaceLogic {
           newTypeVar(bound)
         case tp: RefinedType if tp.refinedInfo.isInstanceOf[TypeBounds] =>
           // Ideally, we would expect type inference can do the job
-          // tp.derivedRefinedType(tp.parent, tp.refinedName, TypeAlias(newTypeVar(tp.refinedInfo.bounds)))
+          //   tests/patmat/t9657.scala
           expose(tp)
         case _ =>
           mapOver(t)
@@ -753,51 +730,50 @@ class SpaceEngine(implicit ctx: Context) extends SpaceLogic {
   }
 
 
-  /** Expose type to eliminate reference to type parameters
+  /** Eliminate reference to type parameters in refinements
    *
    *  A <: X :> Y  B <: U :> V   M { type T <: A :> B }  ~~>  M { type T <: X :> V }
    */
-  def expose(tp: Type, up: Boolean = true): Type = {
-    tp match {
-      case tp: AppliedType =>
-        tp.derivedAppliedType(expose(tp.tycon, up), tp.args.map(expose(_, up)))
+  def expose(tp: Type, refineCtx: Boolean = false, up: Boolean = true): Type = tp match {
+    case tp: AppliedType =>
+      tp.derivedAppliedType(expose(tp.tycon, refineCtx, up), tp.args.map(expose(_, refineCtx, up)))
 
-      case tp: TypeAlias =>
-        val hi = expose(tp.alias, true)
-        val lo = expose(tp.alias, false)
+    case tp: TypeAlias =>
+      val hi = expose(tp.alias, refineCtx, up)
+      val lo = expose(tp.alias, refineCtx, up)
 
-        if (hi =:= lo)
-          tp.derivedTypeAlias(hi)
-        else
-          tp.derivedTypeBounds(lo, hi)
-
-      case tp @ TypeBounds(lo, hi) =>
-        tp.derivedTypeBounds(expose(lo, false), expose(hi, true))
-
-      case tp: RefinedType =>
-        tp.derivedRefinedType(
-           expose(tp.parent),
-           tp.refinedName,
-           expose(tp.refinedInfo)
-         )
-      case tp: TypeProxy =>
-        tp.underlying match {
-          case TypeBounds(lo, hi) =>
-            expose(if (up) hi else lo, up)
-          case _ =>
-            tp
-        }
+      if (hi =:= lo)
+        tp.derivedTypeAlias(hi)
+      else
+        tp.derivedTypeBounds(lo, hi)
 
-      case OrType(tp1, tp2) =>
-        OrType(expose(tp1, up), expose(tp2, up))
+    case tp @ TypeBounds(lo, hi) =>
+      tp.derivedTypeBounds(expose(lo, refineCtx, false), expose(hi, refineCtx, true))
 
-      case AndType(tp1, tp2) =>
-        AndType(expose(tp1, up), expose(tp2, up))
+    case tp: RefinedType =>
+      tp.derivedRefinedType(
+        expose(tp.parent),
+        tp.refinedName,
+        expose(tp.refinedInfo, true, up)
+      )
+    case tp: TypeProxy if refineCtx =>
+      tp.underlying match {
+        case TypeBounds(lo, hi) =>
+          expose(if (up) hi else lo, refineCtx, up)
+        case _ =>
+          tp
+      }
 
-      case _ => tp
-    }
+    case OrType(tp1, tp2) =>
+      OrType(expose(tp1, refineCtx, up), expose(tp2, refineCtx, up))
+
+    case AndType(tp1, tp2) =>
+      AndType(expose(tp1, refineCtx, up), expose(tp2, refineCtx, up))
+
+    case _ => tp
   }
 
+
   def checkExhaustivity(_match: Match): Unit = {
     val Match(sel, cases) = _match
     val selTyp = sel.tpe.widen.dealias