Introduce MatchTypeCaseSpec to categorize match type cases.

For now, we only have `SubTypeTest` and `LegacyPatMat`.

* `SubTypeTest` is used when there is no type capture.
* `LegacyPatMat` is used when there are captures.

In the match type reduction algorithm, we already have a simpler
path for `SubTypeTest`.

The `LegacyPatMat` path is basically the same as before, but with
static knowledge that we have an `HKTypeLambda`.

Author: sjrd

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

@@ -12,8 +12,8 @@ object MatchTypeTrace:
 
   private enum TraceEntry:
     case TryReduce(scrut: Type)
-    case Stuck(scrut: Type, stuckCase: Type, otherCases: List[Type])
-    case NoInstance(scrut: Type, stuckCase: Type, fails: List[(Name, TypeBounds)])
+    case Stuck(scrut: Type, stuckCase: MatchTypeCaseSpec, otherCases: List[MatchTypeCaseSpec])
+    case NoInstance(scrut: Type, stuckCase: MatchTypeCaseSpec, fails: List[(Name, TypeBounds)])
     case EmptyScrutinee(scrut: Type)
   import TraceEntry.*
 
@@ -54,10 +54,10 @@ object MatchTypeTrace:
    *  not disjoint from it either, which means that the remaining cases `otherCases`
    *  cannot be visited. Only the first failure is recorded.
    */
-  def stuck(scrut: Type, stuckCase: Type, otherCases: List[Type])(using Context) =
+  def stuck(scrut: Type, stuckCase: MatchTypeCaseSpec, otherCases: List[MatchTypeCaseSpec])(using Context) =
     matchTypeFail(Stuck(scrut, stuckCase, otherCases))
 
-  def noInstance(scrut: Type, stuckCase: Type, fails: List[(Name, TypeBounds)])(using Context) =
+  def noInstance(scrut: Type, stuckCase: MatchTypeCaseSpec, fails: List[(Name, TypeBounds)])(using Context) =
     matchTypeFail(NoInstance(scrut, stuckCase, fails))
 
   /** Record a failure that scrutinee `scrut` is provably empty.
@@ -80,13 +80,16 @@ object MatchTypeTrace:
       case _ =>
         op
 
+  def caseText(spec: MatchTypeCaseSpec)(using Context): String =
+    caseText(spec.origMatchCase)
+
   def caseText(tp: Type)(using Context): String = tp match
     case tp: HKTypeLambda => caseText(tp.resultType)
     case defn.MatchCase(any, body) if any eq defn.AnyType => i"case _ => $body"
     case defn.MatchCase(pat, body) => i"case $pat => $body"
     case _ => i"case $tp"
 
-  private def casesText(cases: List[Type])(using Context) =
+  private def casesText(cases: List[MatchTypeCaseSpec])(using Context) =
     i"${cases.map(caseText)}%\n    %"
 
   private def explainEntry(entry: TraceEntry)(using Context): String = entry match
@@ -116,7 +119,7 @@ object MatchTypeTrace:
          |    ${fails.map((name, bounds) => i"$name$bounds")}%\n    %"""
 
   /** The failure message when the scrutinee `scrut` does not match any case in `cases`. */
-  def noMatchesText(scrut: Type, cases: List[Type])(using Context): String =
+  def noMatchesText(scrut: Type, cases: List[MatchTypeCaseSpec])(using Context): String =
     i"""failed since selector $scrut
        |matches none of the cases
        |

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

@@ -3189,7 +3189,7 @@ class TrackingTypeComparer(initctx: Context) extends TypeComparer(initctx) {
     super.typeVarInstance(tvar)
   }
 
-  def matchCases(scrut: Type, cases: List[Type])(using Context): Type = {
+  def matchCases(scrut: Type, cases: List[MatchTypeCaseSpec])(using Context): Type = {
     // a reference for the type parameters poisoned during matching
     // for use during the reduction step
     var poisoned: Set[TypeParamRef] = Set.empty
@@ -3230,16 +3230,26 @@ class TrackingTypeComparer(initctx: Context) extends TypeComparer(initctx) {
     }
 
     /** Match a single case. */
-    def matchCase(cas: Type): MatchResult = trace(i"$scrut match ${MatchTypeTrace.caseText(cas)}", matchTypes, show = true) {
-      val cas1 = cas match {
-        case cas: HKTypeLambda =>
-          caseLambda = constrained(cas, ast.tpd.EmptyTree)._1
-          caseLambda.resultType
-        case _ =>
-          cas
-      }
+    def matchCase(cas: MatchTypeCaseSpec): MatchResult = trace(i"$scrut match ${MatchTypeTrace.caseText(cas)}", matchTypes, show = true) {
+      cas match
+        case cas: MatchTypeCaseSpec.SubTypeTest  => matchSubTypeTest(cas)
+        case cas: MatchTypeCaseSpec.LegacyPatMat => matchLegacyPatMat(cas)
+    }
+
+    def matchSubTypeTest(spec: MatchTypeCaseSpec.SubTypeTest): MatchResult =
+      if necessarySubType(scrut, spec.pattern) then
+        MatchResult.Reduced(spec.body)
+      else if provablyDisjoint(scrut, spec.pattern) then
+        MatchResult.Disjoint
+      else
+        MatchResult.Stuck
+    end matchSubTypeTest
 
-      val defn.MatchCase(pat, body) = cas1: @unchecked
+    def matchLegacyPatMat(spec: MatchTypeCaseSpec.LegacyPatMat): MatchResult =
+      val caseLambda = constrained(spec.origMatchCase, ast.tpd.EmptyTree)._1.asInstanceOf[HKTypeLambda]
+      this.caseLambda = caseLambda
+
+      val defn.MatchCase(pat, body) = caseLambda.resultType: @unchecked
 
       def matches(canWidenAbstract: Boolean): Boolean =
         val saved = this.canWidenAbstract
@@ -3253,22 +3263,18 @@ class TrackingTypeComparer(initctx: Context) extends TypeComparer(initctx) {
           this.canWidenAbstract = saved
 
       def redux(canApprox: Boolean): MatchResult =
-        caseLambda match
-          case caseLambda: HKTypeLambda =>
-            val instances = paramInstances(canApprox)(Array.fill(caseLambda.paramNames.length)(NoType), pat)
-            instantiateParams(instances)(body) match
-              case Range(lo, hi) =>
-                MatchResult.NoInstance {
-                  caseLambda.paramNames.zip(instances).collect {
-                    case (name, Range(lo, hi)) => (name, TypeBounds(lo, hi))
-                  }
-                }
-              case redux =>
-                MatchResult.Reduced(redux)
-          case _ =>
-            MatchResult.Reduced(body)
+        val instances = paramInstances(canApprox)(Array.fill(caseLambda.paramNames.length)(NoType), pat)
+        instantiateParams(instances)(body) match
+          case Range(lo, hi) =>
+            MatchResult.NoInstance {
+              caseLambda.paramNames.zip(instances).collect {
+                case (name, Range(lo, hi)) => (name, TypeBounds(lo, hi))
+              }
+            }
+          case redux =>
+            MatchResult.Reduced(redux)
 
-      if caseLambda.exists && matches(canWidenAbstract = false) then
+      if matches(canWidenAbstract = false) then
         redux(canApprox = true)
       else if matches(canWidenAbstract = true) then
         redux(canApprox = false)
@@ -3278,9 +3284,9 @@ class TrackingTypeComparer(initctx: Context) extends TypeComparer(initctx) {
         MatchResult.Disjoint
       else
         MatchResult.Stuck
-    }
+    end matchLegacyPatMat
 
-    def recur(remaining: List[Type]): Type = remaining match
+    def recur(remaining: List[MatchTypeCaseSpec]): Type = remaining match
       case cas :: remaining1 =>
         matchCase(cas) match
           case MatchResult.Disjoint =>

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

@@ -5037,7 +5037,7 @@ object Types {
           trace(i"reduce match type $this $hashCode", matchTypes, show = true)(inMode(Mode.Type) {
             def matchCases(cmp: TrackingTypeComparer): Type =
               val saved = ctx.typerState.snapshot()
-              try cmp.matchCases(scrutinee.normalized, cases)
+              try cmp.matchCases(scrutinee.normalized, cases.map(MatchTypeCaseSpec.analyze(_)))
               catch case ex: Throwable =>
                 handleRecursive("reduce type ", i"$scrutinee match ...", ex)
               finally
@@ -5089,6 +5089,24 @@ object Types {
         case _ => None
   }
 
+  enum MatchTypeCaseSpec:
+    case SubTypeTest(origMatchCase: Type, pattern: Type, body: Type)
+    case LegacyPatMat(origMatchCase: HKTypeLambda)
+
+    def origMatchCase: Type
+  end MatchTypeCaseSpec
+
+  object MatchTypeCaseSpec:
+    def analyze(cas: Type)(using Context): MatchTypeCaseSpec =
+      cas match
+        case cas: HKTypeLambda =>
+          LegacyPatMat(cas)
+        case _ =>
+          val defn.MatchCase(pat, body) = cas: @unchecked
+          SubTypeTest(cas, pat, body)
+    end analyze
+  end MatchTypeCaseSpec
+
   // ------ ClassInfo, Type Bounds --------------------------------------------------
 
   type TypeOrSymbol = Type | Symbol