Match Types: implement cantPossiblyMatch

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

@@ -1898,11 +1898,8 @@ class TypeComparer(initctx: Context) extends ConstraintHandling[AbsentContext] {
      *  It should hold that `tp` and `decompose(tp).reduce(_ or _)`
      *  denote the same set of values.
      */
-    def decompose(sym: Symbol, tp: Type): List[Type] = {
-      import dotty.tools.dotc.transform.patmat.SpaceEngine
-      val se = new SpaceEngine
-      sym.children.map(x => se.refine(tp, x)).filter(_.exists)
-    }
+    def decompose(sym: Symbol, tp: Type): List[Type] =
+      sym.children.map(x => ctx.typer.refineUsingParent(tp, x)).filter(_.exists)
 
     (tp1.dealias, tp2.dealias) match {
       case (tp1: ConstantType, tp2: ConstantType) =>

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

@@ -466,10 +466,8 @@ class SpaceEngine(implicit ctx: Context) extends SpaceLogic {
         children.map(sym => Typ(sym.termRef, true))
       case tp =>
         val parts = children.map { sym =>
-          if (sym.is(ModuleClass))
-            refine(tp, sym.sourceModule)
-          else
-            refine(tp, sym)
+          val sym1 = if (sym.is(ModuleClass)) sym.sourceModule else sym
+          ctx.typer.refineUsingParent(tp, sym1)
         } filter(_.exists)
 
         debug.println(s"${tp.show} decomposes to [${parts.map(_.show).mkString(", ")}]")
@@ -478,156 +476,6 @@ class SpaceEngine(implicit ctx: Context) extends SpaceLogic {
     }
   }
 
-  /** Refine child based on parent
-   *
-   *  In child class definition, we have:
-   *
-   *      class Child[Ts] extends path.Parent[Us] with Es
-   *      object Child extends path.Parent[Us] with Es
-   *      val child = new path.Parent[Us] with Es           // enum values
-   *
-   *  Given a parent type `parent` and a child symbol `child`, we infer the prefix
-   *  and type parameters for the child:
-   *
-   *      prefix.child[Vs] <:< parent
-   *
-   *  where `Vs` are fresh type variables and `prefix` is the symbol prefix with all
-   *  non-module and non-package `ThisType` replaced by fresh type variables.
-   *
-   *  If the subtyping is true, the instantiated type `p.child[Vs]` is
-   *  returned. Otherwise, `NoType` is returned.
-   *
-   */
-  def refine(parent: Type, child: Symbol): Type = {
-    if (child.isTerm && child.is(Case, butNot = Module)) return child.termRef // enum vals always match
-
-    // <local child> is a place holder from Scalac, it is hopeless to instantiate it.
-    //
-    // Quote from scalac (from nsc/symtab/classfile/Pickler.scala):
-    //
-    //     ...When a sealed class/trait has local subclasses, a single
-    //     <local child> class symbol is added as pickled child
-    //     (instead of a reference to the anonymous class; that was done
-    //     initially, but seems not to work, ...).
-    //
-    if (child.name == tpnme.LOCAL_CHILD) return child.typeRef
-
-    val childTp = if (child.isTerm) child.termRef else child.typeRef
-
-    instantiate(childTp, parent)(ctx.fresh.setNewTyperState()).dealias
-  }
-
-  /** expose abstract type references to their bounds or tvars according to variance */
-  private class AbstractTypeMap(maximize: Boolean)(implicit ctx: Context) extends TypeMap {
-    def expose(lo: Type, hi: Type): Type =
-      if (variance == 0)
-        newTypeVar(TypeBounds(lo, hi))
-      else if (variance == 1)
-        if (maximize) hi else lo
-      else
-        if (maximize) lo else hi
-
-    def apply(tp: Type): Type = tp match {
-      case tp: TypeRef if isBounds(tp.underlying) =>
-        val lo = this(tp.info.loBound)
-        val hi = this(tp.info.hiBound)
-        // See tests/patmat/gadt.scala  tests/patmat/exhausting.scala  tests/patmat/t9657.scala
-        val exposed = expose(lo, hi)
-        debug.println(s"$tp exposed to =====> $exposed")
-        exposed
-
-      case AppliedType(tycon: TypeRef, args) if isBounds(tycon.underlying) =>
-        val args2 = args.map(this)
-        val lo = this(tycon.info.loBound).applyIfParameterized(args2)
-        val hi = this(tycon.info.hiBound).applyIfParameterized(args2)
-        val exposed = expose(lo, hi)
-        debug.println(s"$tp exposed to =====> $exposed")
-        exposed
-
-      case _ =>
-        mapOver(tp)
-    }
-  }
-
-  private def minTypeMap(implicit ctx: Context) = new AbstractTypeMap(maximize = false)
-  private def maxTypeMap(implicit ctx: Context) = new AbstractTypeMap(maximize = true)
-
-  /** Instantiate type `tp1` to be a subtype of `tp2`
-   *
-   *  Return the instantiated type if type parameters and this type
-   *  in `tp1` can be instantiated such that `tp1 <:< tp2`.
-   *
-   *  Otherwise, return NoType.
-   *
-   */
-  def instantiate(tp1: NamedType, tp2: Type)(implicit ctx: Context): Type = {
-    // Fix subtype checking for child instantiation,
-    // such that `Foo(Test.this.foo) <:< Foo(Foo.this)`
-    // See tests/patmat/i3938.scala
-    class RemoveThisMap extends TypeMap {
-      var prefixTVar: Type = null
-      def apply(tp: Type): Type = tp match {
-        case ThisType(tref: TypeRef) if !tref.symbol.isStaticOwner =>
-          if (tref.symbol.is(Module))
-            TermRef(this(tref.prefix), tref.symbol.sourceModule)
-          else if (prefixTVar != null)
-            this(tref)
-          else {
-            prefixTVar = WildcardType  // prevent recursive call from assigning it
-            prefixTVar = newTypeVar(TypeBounds.upper(this(tref)))
-            prefixTVar
-          }
-        case tp => mapOver(tp)
-      }
-    }
-
-    // replace uninstantiated type vars with WildcardType, check tests/patmat/3333.scala
-    def instUndetMap(implicit ctx: Context) = new TypeMap {
-      def apply(t: Type): Type = t match {
-        case tvar: TypeVar if !tvar.isInstantiated => WildcardType(tvar.origin.underlying.bounds)
-        case _ => mapOver(t)
-      }
-    }
-
-    val removeThisType = new RemoveThisMap
-    val tvars = tp1.typeParams.map { tparam => newTypeVar(tparam.paramInfo.bounds) }
-    val protoTp1 = removeThisType.apply(tp1).appliedTo(tvars)
-
-    val force = new ForceDegree.Value(
-      tvar =>
-        !(ctx.typerState.constraint.entry(tvar.origin) `eq` tvar.origin.underlying) ||
-        (tvar `eq` removeThisType.prefixTVar),
-      minimizeAll = false,
-      allowBottom = false
-    )
-
-    // If parent contains a reference to an abstract type, then we should
-    // refine subtype checking to eliminate abstract types according to
-    // variance. As this logic is only needed in exhaustivity check,
-    // we manually patch subtyping check instead of changing TypeComparer.
-    // See tests/patmat/i3645b.scala
-    def parentQualify = tp1.widen.classSymbol.info.parents.exists { parent =>
-      implicit val ictx = ctx.fresh.setNewTyperState()
-      parent.argInfos.nonEmpty && minTypeMap.apply(parent) <:< maxTypeMap.apply(tp2)
-    }
-
-    if (protoTp1 <:< tp2) {
-      if (isFullyDefined(protoTp1, force)) protoTp1
-      else instUndetMap.apply(protoTp1)
-    }
-    else {
-      val protoTp2 = maxTypeMap.apply(tp2)
-      if (protoTp1 <:< protoTp2 || parentQualify) {
-        if (isFullyDefined(AndType(protoTp1, protoTp2), force)) protoTp1
-        else instUndetMap.apply(protoTp1)
-      }
-      else {
-        debug.println(s"$protoTp1 <:< $protoTp2 = false")
-        NoType
-      }
-    }
-  }
-
   /** Abstract sealed types, or-types, Boolean and Java enums can be decomposed */
   def canDecompose(tp: Type): Boolean = {
     val dealiasedTp = tp.dealias

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

@@ -2929,4 +2929,152 @@ class Typer extends Namer
         !tree.tpe.isRef(defn.UnitClass) && !isSelfOrSuperConstrCall(tree))
       ctx.warning(PureExpressionInStatementPosition(original, exprOwner), original.sourcePos)
   }
+
+  /** Refine child based on parent
+   *
+   *  In child class definition, we have:
+   *
+   *      class Child[Ts] extends path.Parent[Us] with Es
+   *      object Child extends path.Parent[Us] with Es
+   *      val child = new path.Parent[Us] with Es           // enum values
+   *
+   *  Given a parent type `parent` and a child symbol `child`, we infer the prefix
+   *  and type parameters for the child:
+   *
+   *      prefix.child[Vs] <:< parent
+   *
+   *  where `Vs` are fresh type variables and `prefix` is the symbol prefix with all
+   *  non-module and non-package `ThisType` replaced by fresh type variables.
+   *
+   *  If the subtyping is true, the instantiated type `p.child[Vs]` is
+   *  returned. Otherwise, `NoType` is returned.
+   */
+  def refineUsingParent(parent: Type, child: Symbol)(implicit ctx: Context): Type = {
+    if (child.isTerm && child.is(Case, butNot = Module)) return child.termRef // enum vals always match
+
+    // <local child> is a place holder from Scalac, it is hopeless to instantiate it.
+    //
+    // Quote from scalac (from nsc/symtab/classfile/Pickler.scala):
+    //
+    //     ...When a sealed class/trait has local subclasses, a single
+    //     <local child> class symbol is added as pickled child
+    //     (instead of a reference to the anonymous class; that was done
+    //     initially, but seems not to work, ...).
+    //
+    if (child.name == tpnme.LOCAL_CHILD) return child.typeRef
+
+    val childTp = if (child.isTerm) child.termRef else child.typeRef
+
+    instantiate(childTp, parent)(ctx.fresh.setNewTyperState()).dealias
+  }
+
+  /** Instantiate type `tp1` to be a subtype of `tp2`
+   *
+   *  Return the instantiated type if type parameters and this type
+   *  in `tp1` can be instantiated such that `tp1 <:< tp2`.
+   *
+   *  Otherwise, return NoType.
+   */
+  private def instantiate(tp1: NamedType, tp2: Type)(implicit ctx: Context): Type = {
+    /** expose abstract type references to their bounds or tvars according to variance */
+    class AbstractTypeMap(maximize: Boolean)(implicit ctx: Context) extends TypeMap {
+      def expose(lo: Type, hi: Type): Type =
+        if (variance == 0)
+          newTypeVar(TypeBounds(lo, hi))
+        else if (variance == 1)
+          if (maximize) hi else lo
+        else
+          if (maximize) lo else hi
+
+      def apply(tp: Type): Type = tp match {
+        case tp: TypeRef if isBounds(tp.underlying) =>
+          val lo = this(tp.info.loBound)
+          val hi = this(tp.info.hiBound)
+          // See tests/patmat/gadt.scala  tests/patmat/exhausting.scala  tests/patmat/t9657.scala
+          val exposed = expose(lo, hi)
+          typr.println(s"$tp exposed to =====> $exposed")
+          exposed
+
+        case AppliedType(tycon: TypeRef, args) if isBounds(tycon.underlying) =>
+          val args2 = args.map(this)
+          val lo = this(tycon.info.loBound).applyIfParameterized(args2)
+          val hi = this(tycon.info.hiBound).applyIfParameterized(args2)
+          val exposed = expose(lo, hi)
+          typr.println(s"$tp exposed to =====> $exposed")
+          exposed
+
+        case _ =>
+          mapOver(tp)
+      }
+    }
+
+    def minTypeMap(implicit ctx: Context) = new AbstractTypeMap(maximize = false)
+    def maxTypeMap(implicit ctx: Context) = new AbstractTypeMap(maximize = true)
+
+    // Fix subtype checking for child instantiation,
+    // such that `Foo(Test.this.foo) <:< Foo(Foo.this)`
+    // See tests/patmat/i3938.scala
+    class RemoveThisMap extends TypeMap {
+      var prefixTVar: Type = null
+      def apply(tp: Type): Type = tp match {
+        case ThisType(tref: TypeRef) if !tref.symbol.isStaticOwner =>
+          if (tref.symbol.is(Module))
+            TermRef(this(tref.prefix), tref.symbol.sourceModule)
+          else if (prefixTVar != null)
+            this(tref)
+          else {
+            prefixTVar = WildcardType  // prevent recursive call from assigning it
+            prefixTVar = newTypeVar(TypeBounds.upper(this(tref)))
+            prefixTVar
+          }
+        case tp => mapOver(tp)
+      }
+    }
+
+    // replace uninstantiated type vars with WildcardType, check tests/patmat/3333.scala
+    def instUndetMap(implicit ctx: Context) = new TypeMap {
+      def apply(t: Type): Type = t match {
+        case tvar: TypeVar if !tvar.isInstantiated => WildcardType(tvar.origin.underlying.bounds)
+        case _ => mapOver(t)
+      }
+    }
+
+    val removeThisType = new RemoveThisMap
+    val tvars = tp1.typeParams.map { tparam => newTypeVar(tparam.paramInfo.bounds) }
+    val protoTp1 = removeThisType.apply(tp1).appliedTo(tvars)
+
+    val force = new ForceDegree.Value(
+      tvar =>
+        !(ctx.typerState.constraint.entry(tvar.origin) `eq` tvar.origin.underlying) ||
+        (tvar `eq` removeThisType.prefixTVar),
+      minimizeAll = false,
+      allowBottom = false
+    )
+
+    // If parent contains a reference to an abstract type, then we should
+    // refine subtype checking to eliminate abstract types according to
+    // variance. As this logic is only needed in exhaustivity check,
+    // we manually patch subtyping check instead of changing TypeComparer.
+    // See tests/patmat/i3645b.scala
+    def parentQualify = tp1.widen.classSymbol.info.parents.exists { parent =>
+      implicit val ictx = ctx.fresh.setNewTyperState()
+      parent.argInfos.nonEmpty && minTypeMap.apply(parent) <:< maxTypeMap.apply(tp2)
+    }
+
+    if (protoTp1 <:< tp2) {
+      if (isFullyDefined(protoTp1, force)) protoTp1
+      else instUndetMap.apply(protoTp1)
+    }
+    else {
+      val protoTp2 = maxTypeMap.apply(tp2)
+      if (protoTp1 <:< protoTp2 || parentQualify) {
+        if (isFullyDefined(AndType(protoTp1, protoTp2), force)) protoTp1
+        else instUndetMap.apply(protoTp1)
+      }
+      else {
+        typr.println(s"$protoTp1 <:< $protoTp2 = false")
+        NoType
+      }
+    }
+  }
 }