Report a compile error on illegal match types.

The error can be silenced with `-source:3.3`. In that case,
illegal match types are reduced using the legacy matching
algorithm, as before.

Author: sjrd

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

@@ -125,4 +125,9 @@ object MatchTypeTrace:
        |
        |    ${casesText(cases)}"""
 
+  def illegalPatternText(scrut: Type, cas: MatchTypeCaseSpec.LegacyPatMat)(using Context): String =
+    i"""The match type contains an illegal case:
+       |    ${caseText(cas)}
+       |(this error can be ignored for now with `-source:3.3`)"""
+
 end MatchTypeTrace

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

@@ -10,8 +10,9 @@ import TypeOps.refineUsingParent
 import collection.mutable
 import util.{Stats, NoSourcePosition, EqHashMap}
 import config.Config
-import config.Feature.migrateTo3
+import config.Feature.{migrateTo3, sourceVersion}
 import config.Printers.{subtyping, gadts, matchTypes, noPrinter}
+import config.SourceVersion
 import TypeErasure.{erasedLub, erasedGlb}
 import TypeApplications.*
 import Variances.{Variance, variancesConform}
@@ -3467,6 +3468,9 @@ class TrackingTypeComparer(initctx: Context) extends TypeComparer(initctx) {
       MatchResult.Stuck
 
     def recur(remaining: List[MatchTypeCaseSpec]): Type = remaining match
+      case (cas: MatchTypeCaseSpec.LegacyPatMat) :: _ if sourceVersion.isAtLeast(SourceVersion.`3.4`) =>
+        val errorText = MatchTypeTrace.illegalPatternText(scrut, cas)
+        ErrorType(reporting.MatchTypeLegacyPattern(errorText))
       case cas :: remaining1 =>
         matchCase(cas) match
           case MatchResult.Disjoint =>

compiler/src/dotty/tools/dotc/reporting/ErrorMessageID.scala

@@ -204,6 +204,7 @@ enum ErrorMessageID(val isActive: Boolean = true) extends java.lang.Enum[ErrorMe
   case VarArgsParamCannotBeGivenID // errorNumber: 188
   case ExtractorNotFoundID // errorNumber: 189
   case PureUnitExpressionID // errorNumber: 190
+  case MatchTypeLegacyPatternID // errorNumber: 191
 
   def errorNumber = ordinal - 1
 

compiler/src/dotty/tools/dotc/reporting/messages.scala

@@ -3073,6 +3073,10 @@ class MatchTypeScrutineeCannotBeHigherKinded(tp: Type)(using Context)
     def msg(using Context) = i"the scrutinee of a match type cannot be higher-kinded"
     def explain(using Context) = ""
 
+class MatchTypeLegacyPattern(errorText: String)(using Context) extends TypeMsg(MatchTypeLegacyPatternID):
+  def msg(using Context) = errorText
+  def explain(using Context) = ""
+
 class ClosureCannotHaveInternalParameterDependencies(mt: Type)(using Context)
   extends TypeMsg(ClosureCannotHaveInternalParameterDependenciesID):
     def msg(using Context) =

tests/neg/6570.scala

@@ -1,3 +1,5 @@
+//> using options -source:3.3
+
 object Base {
   trait Trait1
   trait Trait2

tests/neg/illegal-match-types.check

@@ -0,0 +1,42 @@
+-- [E191] Type Error: tests/neg/illegal-match-types.scala:7:23 ---------------------------------------------------------
+7 |type InvNesting[X] = X match // error
+  |                     ^
+  |                     The match type contains an illegal case:
+  |                         case Inv[Cov[t]] => t
+  |                     (this error can be ignored for now with `-source:3.3`)
+8 |  case Inv[Cov[t]] => t
+-- [E191] Type Error: tests/neg/illegal-match-types.scala:10:26 --------------------------------------------------------
+10 |type ContraNesting[X] = X match // error
+   |                        ^
+   |                        The match type contains an illegal case:
+   |                            case Contra[Cov[t]] => t
+   |                        (this error can be ignored for now with `-source:3.3`)
+11 |  case Contra[Cov[t]] => t
+-- [E191] Type Error: tests/neg/illegal-match-types.scala:15:22 --------------------------------------------------------
+15 |type AndTypeMT[X] = X match // error
+   |                    ^
+   |                    The match type contains an illegal case:
+   |                        case t & Seq[Any] => t
+   |                    (this error can be ignored for now with `-source:3.3`)
+16 |  case t & Seq[Any] => t
+-- [E191] Type Error: tests/neg/illegal-match-types.scala:22:33 --------------------------------------------------------
+22 |type TypeAliasWithBoundMT[X] = X match // error
+   |                               ^
+   |                               The match type contains an illegal case:
+   |                                   case IsSeq[t] => t
+   |                               (this error can be ignored for now with `-source:3.3`)
+23 |  case IsSeq[t] => t
+-- [E191] Type Error: tests/neg/illegal-match-types.scala:29:34 --------------------------------------------------------
+29 |type TypeMemberExtractorMT[X] = X match // error
+   |                                ^
+   |                                The match type contains an illegal case:
+   |                                    case TypeMemberAux[t] => t
+   |                                (this error can be ignored for now with `-source:3.3`)
+30 |  case TypeMemberAux[t] => t
+-- [E191] Type Error: tests/neg/illegal-match-types.scala:40:35 --------------------------------------------------------
+40 |type TypeMemberExtractorMT2[X] = X match // error
+   |                                 ^
+   |                                 The match type contains an illegal case:
+   |                                     case TypeMemberAux2[t] => t
+   |                                 (this error can be ignored for now with `-source:3.3`)
+41 |  case TypeMemberAux2[t] => t

tests/neg/illegal-match-types.scala

@@ -0,0 +1,41 @@
+class Inv[T]
+class Cov[+T]
+class Contra[-T]
+
+// Nesting captures in non-covariant position
+
+type InvNesting[X] = X match // error
+  case Inv[Cov[t]] => t
+
+type ContraNesting[X] = X match // error
+  case Contra[Cov[t]] => t
+
+// Intersection type to type-test and capture at the same time
+
+type AndTypeMT[X] = X match // error
+  case t & Seq[Any] => t
+
+// Poly type alias with a bound to type-test and capture at the same time
+
+type IsSeq[X <: Seq[Any]] = X
+
+type TypeAliasWithBoundMT[X] = X match // error
+  case IsSeq[t] => t
+
+// Poly type alias with an unknown type member refinement
+
+type TypeMemberAux[X] = { type TypeMember = X }
+
+type TypeMemberExtractorMT[X] = X match // error
+  case TypeMemberAux[t] => t
+
+// Poly type alias with a refined member of stronger bounds than in the parent
+
+class Base {
+  type TypeMember
+}
+
+type TypeMemberAux2[X <: Seq[Any]] = Base { type TypeMember = X }
+
+type TypeMemberExtractorMT2[X] = X match // error
+  case TypeMemberAux2[t] => t

tests/pos/10747-shapeless-min-spec.scala

@@ -0,0 +1,13 @@
+trait Monoidal {
+  type to[_] <: Tuple
+}
+
+object eithers extends Monoidal {
+  class Wrap[T]
+
+  type to[t] <: Tuple = Wrap[t] match {
+    case Wrap[Nothing] => EmptyTuple
+    case Wrap[other] => other match
+      case Either[hd, tl] => hd *: to[tl]
+  }
+}

tests/pos/10747-shapeless-min.scala

@@ -1,3 +1,5 @@
+//> using options -source:3.3
+
 trait Monoidal {
   type to[_] <: Tuple
 }

tests/pos/8647.scala

@@ -1,3 +1,5 @@
+//> using options -source:3.3
+
 final class Two[A, B]()
 
 final class Blaaa