Use new specced match types for class type constructors.

sjrd · sjrd · commit 3a2c49e5f578 · 2023-11-24T16:33:47.000+01:00
This is the first step in using the new specified algorithm for
match type reduction. When the pattern of a case satisfies
elibility conditions, we use the new algorithm. Otherwise, we fall
back on the legacy algorithm.

To be eligible, a pattern with at least one capture must be:
an applied *class* type constructor whose arguments are all:
- either a type capture,
- or a fully defined type that contains no inner capture,
- or the argument must be in covariant position and recursively
  qualify to the elibility conditions.

With those criteria, all the type captures can be *computed* using
`baseType`, instead of inferred through the full `TypeComparer`
machinery.

The new algorithm directly handles preventing widening abstract
types, when doing so leads to captures being under-defined. With
the legacy algorithm, this prevention is scattered elsewhere in
the type comparer. Making it centralized improves the error
messages in those situations; it seems they were previously
entirely misleading (see changed check files).
diff --git a/compiler/src/dotty/tools/dotc/core/TypeComparer.scala b/compiler/src/dotty/tools/dotc/core/TypeComparer.scala
@@ -3229,11 +3229,22 @@ class TrackingTypeComparer(initctx: Context) extends TypeComparer(initctx) {
       }
     }
 
+    def instantiateParamsSpec(insts: Array[Type], caseLambda: HKTypeLambda) = new TypeMap {
+      variance = 0
+
+      def apply(t: Type) = t match {
+        case t @ TypeParamRef(b, n) if b `eq` caseLambda => insts(n)
+        case t: LazyRef => apply(t.ref)
+        case _ => mapOver(t)
+      }
+    }
+
     /** Match a single case. */
     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)
+        case cas: MatchTypeCaseSpec.SubTypeTest   => matchSubTypeTest(cas)
+        case cas: MatchTypeCaseSpec.SpeccedPatMat => matchSpeccedPatMat(cas)
+        case cas: MatchTypeCaseSpec.LegacyPatMat  => matchLegacyPatMat(cas)
     }
 
     def matchSubTypeTest(spec: MatchTypeCaseSpec.SubTypeTest): MatchResult =
@@ -3245,6 +3256,128 @@ class TrackingTypeComparer(initctx: Context) extends TypeComparer(initctx) {
         MatchResult.Stuck
     end matchSubTypeTest
 
+    def matchSpeccedPatMat(spec: MatchTypeCaseSpec.SpeccedPatMat): MatchResult =
+      /* Concreteness checking
+       *
+       * When following a baseType and reaching a non-wildcard, in-variant-pos type capture,
+       * we have to make sure that the scrutinee is concrete enough to uniquely determine
+       * the values of the captures. This comes down to checking that we do not follow any
+       * upper bound of an abstract type.
+       *
+       * See notably neg/wildcard-match.scala for examples of this.
+       */
+
+      def followEverythingConcrete(tp: Type): Type =
+        val widenedTp = tp.widenDealias
+        val tp1 = widenedTp.normalized
+
+        def followTp1: Type =
+          // If both widenDealias and normalized did something, start again
+          if (tp1 ne widenedTp) && (widenedTp ne tp) then followEverythingConcrete(tp1)
+          else tp1
+
+        tp1 match
+          case tp1: TypeRef =>
+            tp1.info match
+              case TypeAlias(tl: HKTypeLambda)  => tl
+              case MatchAlias(tl: HKTypeLambda) => tl
+              case _                            => followTp1
+          case tp1 @ AppliedType(tycon, args) =>
+            val concreteTycon = followEverythingConcrete(tycon)
+            if concreteTycon eq tycon then followTp1
+            else followEverythingConcrete(concreteTycon.applyIfParameterized(args))
+          case _ =>
+            followTp1
+      end followEverythingConcrete
+
+      def isConcrete(tp: Type): Boolean =
+        followEverythingConcrete(tp) match
+          case tp1: AndOrType => isConcrete(tp1.tp1) && isConcrete(tp1.tp2)
+          case tp1            => tp1.underlyingClassRef(refinementOK = true).exists
+
+      // Actual matching logic
+
+      val instances = Array.fill[Type](spec.captureCount)(NoType)
+
+      def rec(pattern: MatchTypeCasePattern, scrut: Type, variance: Int, scrutIsWidenedAbstract: Boolean): Boolean =
+        pattern match
+          case MatchTypeCasePattern.Capture(num, isWildcard) =>
+            instances(num) = scrut match
+              case scrut: TypeBounds =>
+                if isWildcard then
+                  // anything will do, as long as it conforms to the bounds for the subsequent `scrut <:< instantiatedPat` test
+                  scrut.hi
+                else if scrutIsWidenedAbstract then
+                  // always keep the TypeBounds so that we can report the correct NoInstances
+                  scrut
+                else
+                  variance match
+                    case 1  => scrut.hi
+                    case -1 => scrut.lo
+                    case 0  => scrut
+              case _ =>
+                if !isWildcard && scrutIsWidenedAbstract && variance != 0 then
+                  // force a TypeBounds to report the correct NoInstances
+                  // the Nothing and Any bounds are used so that they are not displayed; not for themselves in particular
+                  if variance > 0 then TypeBounds(defn.NothingType, scrut)
+                  else TypeBounds(scrut, defn.AnyType)
+                else
+                  scrut
+            !instances(num).isError
+
+          case MatchTypeCasePattern.TypeTest(tpe) =>
+            // The actual type test is handled by `scrut <:< instantiatedPat`
+            true
+
+          case MatchTypeCasePattern.BaseTypeTest(classType, argPatterns, needsConcreteScrut) =>
+            val cls = classType.classSymbol.asClass
+            scrut.baseType(cls) match
+              case base @ AppliedType(baseTycon, baseArgs) if baseTycon =:= classType =>
+                val innerScrutIsWidenedAbstract =
+                  scrutIsWidenedAbstract
+                    || (needsConcreteScrut && !isConcrete(scrut)) // no point in checking concreteness if it does not need to be concrete
+
+                def matchArgs(argPatterns: List[MatchTypeCasePattern], baseArgs: List[Type], tparams: List[TypeParamInfo]): Boolean =
+                  if argPatterns.isEmpty then
+                    true
+                  else
+                    rec(argPatterns.head, baseArgs.head, tparams.head.paramVarianceSign, innerScrutIsWidenedAbstract)
+                      && matchArgs(argPatterns.tail, baseArgs.tail, tparams.tail)
+
+                matchArgs(argPatterns, baseArgs, classType.typeParams)
+
+              case _ =>
+                false
+      end rec
+
+      // This might not be needed
+      val constrainedCaseLambda = constrained(spec.origMatchCase, ast.tpd.EmptyTree)._1.asInstanceOf[HKTypeLambda]
+
+      def tryDisjoint: MatchResult =
+        val defn.MatchCase(origPattern, _) = constrainedCaseLambda.resultType: @unchecked
+        if provablyDisjoint(scrut, origPattern) then
+          MatchResult.Disjoint
+        else
+          MatchResult.Stuck
+
+      if rec(spec.pattern, scrut, variance = 1, scrutIsWidenedAbstract = false) then
+        if instances.exists(_.isInstanceOf[TypeBounds]) then
+          MatchResult.NoInstance {
+            constrainedCaseLambda.paramNames.zip(instances).collect {
+              case (name, bounds: TypeBounds) => (name, bounds)
+            }
+          }
+        else
+          val defn.MatchCase(instantiatedPat, reduced) =
+            instantiateParamsSpec(instances, constrainedCaseLambda)(constrainedCaseLambda.resultType): @unchecked
+          if scrut <:< instantiatedPat then
+            MatchResult.Reduced(reduced)
+          else
+            tryDisjoint
+      else
+        tryDisjoint
+    end matchSpeccedPatMat
+
     def matchLegacyPatMat(spec: MatchTypeCaseSpec.LegacyPatMat): MatchResult =
       val caseLambda = constrained(spec.origMatchCase, ast.tpd.EmptyTree)._1.asInstanceOf[HKTypeLambda]
       this.caseLambda = caseLambda
diff --git a/compiler/src/dotty/tools/dotc/core/Types.scala b/compiler/src/dotty/tools/dotc/core/Types.scala
@@ -7,7 +7,7 @@ import Flags.*
 import Names.*
 import StdNames.*, NameOps.*
 import NullOpsDecorator.*
-import NameKinds.SkolemName
+import NameKinds.{SkolemName, WildcardParamName}
 import Scopes.*
 import Constants.*
 import Contexts.*
@@ -43,7 +43,7 @@ import scala.annotation.internal.sharable
 import scala.annotation.threadUnsafe
 
 import dotty.tools.dotc.transform.SymUtils.*
-import dotty.tools.dotc.transform.TypeUtils.isErasedClass
+import dotty.tools.dotc.transform.TypeUtils.{isErasedClass, toNestedPairs}
 
 object Types {
 
@@ -5089,8 +5089,23 @@ object Types {
         case _ => None
   }
 
+  enum MatchTypeCasePattern:
+    case Capture(num: Int, isWildcard: Boolean)
+    case TypeTest(tpe: Type)
+    case BaseTypeTest(classType: TypeRef, argPatterns: List[MatchTypeCasePattern], needsConcreteScrut: Boolean)
+
+    def isTypeTest: Boolean =
+      this.isInstanceOf[TypeTest]
+
+    def needsConcreteScrutInVariantPos: Boolean = this match
+      case Capture(_, isWildcard) => !isWildcard
+      case TypeTest(_)            => false
+      case _                      => true
+  end MatchTypeCasePattern
+
   enum MatchTypeCaseSpec:
     case SubTypeTest(origMatchCase: Type, pattern: Type, body: Type)
+    case SpeccedPatMat(origMatchCase: HKTypeLambda, captureCount: Int, pattern: MatchTypeCasePattern, body: Type)
     case LegacyPatMat(origMatchCase: HKTypeLambda)
 
     def origMatchCase: Type
@@ -5100,11 +5115,59 @@ object Types {
     def analyze(cas: Type)(using Context): MatchTypeCaseSpec =
       cas match
         case cas: HKTypeLambda =>
-          LegacyPatMat(cas)
+          val defn.MatchCase(pat, body) = cas.resultType: @unchecked
+          val specPattern = tryConvertToSpecPattern(cas, pat)
+          if specPattern != null then
+            SpeccedPatMat(cas, cas.paramNames.size, specPattern, body)
+          else
+            LegacyPatMat(cas)
         case _ =>
           val defn.MatchCase(pat, body) = cas: @unchecked
           SubTypeTest(cas, pat, body)
     end analyze
+
+    private def tryConvertToSpecPattern(caseLambda: HKTypeLambda, pat: Type)(using Context): MatchTypeCasePattern | Null =
+      var typeParamRefsAccountedFor: Int = 0
+
+      def rec(pat: Type, variance: Int): MatchTypeCasePattern | Null =
+        pat match
+          case pat @ TypeParamRef(binder, num) if binder eq caseLambda =>
+            typeParamRefsAccountedFor += 1
+            MatchTypeCasePattern.Capture(num, isWildcard = pat.paramName.is(WildcardParamName))
+
+          case pat @ AppliedType(tycon: TypeRef, args) if variance == 1 =>
+            val tyconSym = tycon.symbol
+            if tyconSym.isClass then
+              val cls = tyconSym.asClass
+              if cls.name.startsWith("Tuple") && defn.isTupleNType(pat) then
+                rec(pat.toNestedPairs, variance)
+              else
+                val tparams = tycon.typeParams
+                val argPatterns = args.zip(tparams).map { (arg, tparam) =>
+                  rec(arg, tparam.paramVarianceSign)
+                }
+                if argPatterns.exists(_ == null) then
+                  null
+                else
+                  val argPatterns1 = argPatterns.asInstanceOf[List[MatchTypeCasePattern]] // they are not null
+                  if argPatterns1.forall(_.isTypeTest) then
+                    MatchTypeCasePattern.TypeTest(pat)
+                  else
+                    val needsConcreteScrut = argPatterns1.zip(tparams).exists {
+                      (argPattern, tparam) => tparam.paramVarianceSign != 0 && argPattern.needsConcreteScrutInVariantPos
+                    }
+                    MatchTypeCasePattern.BaseTypeTest(tycon, argPatterns1, needsConcreteScrut)
+            else
+              null
+
+          case _ =>
+            MatchTypeCasePattern.TypeTest(pat)
+      end rec
+
+      val result = rec(pat, variance = 1)
+      if typeParamRefsAccountedFor == caseLambda.paramNames.size then result
+      else null
+    end tryConvertToSpecPattern
   end MatchTypeCaseSpec
 
   // ------ ClassInfo, Type Bounds --------------------------------------------------
diff --git a/tests/neg/6570-1.check b/tests/neg/6570-1.check
@@ -27,6 +27,6 @@
    |                                                  does not uniquely determine parameter x in
    |                                                    case Cov[x] => N[x]
    |                                                  The computed bounds for the parameter are:
-   |                                                    x >: Box[Int]
+   |                                                    x <: Box[Int]
    |
    | longer explanation available when compiling with `-explain`
diff --git a/tests/neg/i11982a.check b/tests/neg/i11982a.check
@@ -10,7 +10,7 @@
   |                                    does not uniquely determine parameter xs in
   |                                      case _ *: xs => xs
   |                                    The computed bounds for the parameter are:
-  |                                      xs >: Any *: EmptyTuple.type <: Tuple
+  |                                      xs <: Any *: EmptyTuple.type
   |
   | longer explanation available when compiling with `-explain`
 -- [E057] Type Mismatch Error: tests/neg/i11982a.scala:10:38 -----------------------------------------------------------
@@ -25,7 +25,7 @@
    |                                        does not uniquely determine parameter xs in
    |                                          case _ *: xs => xs
    |                                        The computed bounds for the parameter are:
-   |                                          xs >: Any *: EmptyTuple.type <: Tuple
+   |                                          xs <: Any *: EmptyTuple.type
    |
    | longer explanation available when compiling with `-explain`
 -- [E057] Type Mismatch Error: tests/neg/i11982a.scala:12:25 -----------------------------------------------------------
@@ -40,6 +40,6 @@
    |                           does not uniquely determine parameter xs in
    |                             case _ *: xs => xs
    |                           The computed bounds for the parameter are:
-   |                             xs >: Any *: EmptyTuple.type <: Tuple
+   |                             xs <: Any *: EmptyTuple.type
    |
    | longer explanation available when compiling with `-explain`
diff --git a/tests/neg/i12049.check b/tests/neg/i12049.check
@@ -18,7 +18,7 @@
 -- [E184] Type Error: tests/neg/i12049.scala:14:23 ---------------------------------------------------------------------
 14 |val y3: String = ??? : Last[Int *: Int *: Boolean *: String *: EmptyTuple]  // error
    |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |                       Match type reduction failed since selector EmptyTuple.type
+   |                       Match type reduction failed since selector EmptyTuple
    |                       matches none of the cases
    |
    |                           case _ *: _ *: t => Last[t]
@@ -48,7 +48,7 @@
 -- [E184] Type Error: tests/neg/i12049.scala:25:26 ---------------------------------------------------------------------
 25 |val _ = summon[String =:= Last[Int *: Int *: Boolean *: String *: EmptyTuple]] // error
    |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |                          Match type reduction failed since selector EmptyTuple.type
+   |                          Match type reduction failed since selector EmptyTuple
    |                          matches none of the cases
    |
    |                              case _ *: _ *: t => Last[t]
diff --git a/tests/neg/i13780.check b/tests/neg/i13780.check
@@ -14,8 +14,8 @@
    |                                  does not uniquely determine parameters a, b in
    |                                    case (a, b) => a
    |                                  The computed bounds for the parameters are:
-   |                                    a >: Any
-   |                                    b >: Any
+   |                                    a
+   |                                    b
    |
    | longer explanation available when compiling with `-explain`
 -- [E007] Type Mismatch Error: tests/neg/i13780.scala:18:31 ------------------------------------------------------------
@@ -34,8 +34,8 @@
    |                           does not uniquely determine parameters a, b in
    |                             case (a, b) => a
    |                           The computed bounds for the parameters are:
-   |                             a >: Int
-   |                             b >: Int
+   |                             a <: Int
+   |                             b <: Int
    |
    | longer explanation available when compiling with `-explain`
 -- [E007] Type Mismatch Error: tests/neg/i13780.scala:23:37 ------------------------------------------------------------
@@ -54,7 +54,7 @@
    |                                 does not uniquely determine parameters a, b in
    |                                   case (a, b) => a
    |                                 The computed bounds for the parameters are:
-   |                                   a >: String
-   |                                   b >: String
+   |                                   a <: String
+   |                                   b <: String
    |
    | longer explanation available when compiling with `-explain`
diff --git a/tests/neg/wildcard-match.check b/tests/neg/wildcard-match.check
diff --git a/tests/neg/wildcard-match.scala b/tests/neg/wildcard-match.scala

Original file line number	Diff line number	Diff line change
`@@ -27,6 +27,6 @@`
`27`	`27`	`\| does not uniquely determine parameter x in`
`28`	`28`	`\| case Cov[x] => N[x]`
`29`	`29`	`\| The computed bounds for the parameter are:`
`30`		`- \| x >: Box[Int]`
	`30`	`+ \| x <: Box[Int]`
`31`	`31`	`\|`
`32`	`32`	\| longer explanation available when compiling with `-explain`