Use the specced match types for abstract tycons in patterns.

An abstract tycon can be matched if it is exactly equal to the
scrutinee's tycon.

Author: sjrd

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

@@ -3345,16 +3345,14 @@ class TrackingTypeComparer(initctx: Context) extends TypeComparer(initctx) {
                 val innerScrutIsWidenedAbstract =
                   scrutIsWidenedAbstract
                     || (needsConcreteScrut && !isConcrete(scrut)) // no point in checking concreteness if it does not need to be concrete
+                matchArgs(argPatterns, baseArgs, classType.typeParams, innerScrutIsWidenedAbstract)
+              case _ =>
+                false
 
-                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 MatchTypeCasePattern.AbstractTypeConstructor(tycon, argPatterns) =>
+            scrut.dealias match
+              case scrutDealias @ AppliedType(scrutTycon, args) if scrutTycon =:= tycon =>
+                matchArgs(argPatterns, args, tycon.typeParams, scrutIsWidenedAbstract)
               case _ =>
                 false
 
@@ -3366,6 +3364,13 @@ class TrackingTypeComparer(initctx: Context) extends TypeComparer(initctx) {
                 false
       end rec
 
+      def matchArgs(argPatterns: List[MatchTypeCasePattern], args: List[Type], tparams: List[TypeParamInfo], scrutIsWidenedAbstract: Boolean): Boolean =
+        if argPatterns.isEmpty then
+          true
+        else
+          rec(argPatterns.head, args.head, tparams.head.paramVarianceSign, scrutIsWidenedAbstract)
+            && matchArgs(argPatterns.tail, args.tail, tparams.tail, scrutIsWidenedAbstract)
+
       // This might not be needed
       val constrainedCaseLambda = constrained(spec.origMatchCase, ast.tpd.EmptyTree)._1.asInstanceOf[HKTypeLambda]
 

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

@@ -5093,6 +5093,7 @@ object Types extends TypeUtils {
     case TypeTest(tpe: Type)
     case BaseTypeTest(classType: TypeRef, argPatterns: List[MatchTypeCasePattern], needsConcreteScrut: Boolean)
     case CompileTimeS(argPattern: MatchTypeCasePattern)
+    case AbstractTypeConstructor(tycon: Type, argPatterns: List[MatchTypeCasePattern])
 
     def isTypeTest: Boolean =
       this.isInstanceOf[TypeTest]
@@ -5167,25 +5168,15 @@ object Types extends TypeUtils {
           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
+              if tyconSym.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)
+                recArgPatterns(pat) { argPatterns =>
+                  val needsConcreteScrut = argPatterns.zip(tycon.typeParams).exists {
+                    (argPattern, tparam) => tparam.paramVarianceSign != 0 && argPattern.needsConcreteScrutInVariantPos
+                  }
+                  MatchTypeCasePattern.BaseTypeTest(tycon, argPatterns, needsConcreteScrut)
                 }
-                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 if defn.isCompiletime_S(tyconSym) && args.sizeIs == 1 then
               val argPattern = rec(args.head, variance)
               if argPattern == null then
@@ -5195,12 +5186,39 @@ object Types extends TypeUtils {
               else
                 MatchTypeCasePattern.CompileTimeS(argPattern)
             else
-              null
+              tycon.info match
+                case _: RealTypeBounds => recAbstractTypeConstructor(pat)
+                case _                 => null
+
+          case pat @ AppliedType(tycon: TypeParamRef, _) if variance == 1 =>
+            recAbstractTypeConstructor(pat)
 
           case _ =>
             MatchTypeCasePattern.TypeTest(pat)
       end rec
 
+      def recAbstractTypeConstructor(pat: AppliedType): MatchTypeCasePattern | Null =
+        recArgPatterns(pat) { argPatterns =>
+          MatchTypeCasePattern.AbstractTypeConstructor(pat.tycon, argPatterns)
+        }
+      end recAbstractTypeConstructor
+
+      def recArgPatterns(pat: AppliedType)(whenNotTypeTest: List[MatchTypeCasePattern] => MatchTypeCasePattern | Null): MatchTypeCasePattern | Null =
+        val AppliedType(tycon, args) = pat
+        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
+            whenNotTypeTest(argPatterns1)
+      end recArgPatterns
+
       val result = rec(pat, variance = 1)
       if typeParamRefsAccountedFor == caseLambda.paramNames.size then result
       else null