[WIP] Match Type with no cases should not reduce to ErrorType

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

@@ -3594,23 +3594,16 @@ class MatchReducer(initctx: Context) extends TypeComparer(initctx) {
             MatchTypeTrace.emptyScrutinee(scrut)
             NoType
       case Nil =>
-        val casesText = MatchTypeTrace.noMatchesText(scrut, cases)
-        ErrorType(reporting.MatchTypeNoCases(casesText))
-
-    inFrozenConstraint {
-      if scrut.isError then
-        // if the scrutinee is an error type
-        // then just return that as the result
-        // not doing so will result in the first type case matching
-        // because ErrorType (as a FlexType) is <:< any type case
-        // this situation can arise from any kind of nesting of match types,
-        // e.g. neg/i12049 `Tuple.Concat[Reverse[ts], (t2, t1)]`
-        // if Reverse[ts] fails with no matches,
-        // the error type should be the reduction of the Concat too
-        scrut
-      else
-        recur(cases)
-    }
+        if ctx.isTyper then
+          val casesText = MatchTypeTrace.noMatchesText(scrut, cases)
+          throw MatchTypeReductionError(em"Match type reduction $casesText")
+        else
+          NoType
+          /* The match type is left unreduced if an error can not be reported
+           * See pos/constvalue-of-failed-match-type.scala for an example
+           */
+
+    inFrozenConstraint(recur(cases))
   }
 }
 

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

@@ -53,6 +53,9 @@ object TypeError:
     def toMessage(using Context) = msg
 end TypeError
 
+class MatchTypeReductionError(msg: Message)(using Context) extends TypeError:
+  def toMessage(using Context) = msg
+
 class MalformedType(pre: Type, denot: Denotation, absMembers: Set[Name])(using Context) extends TypeError:
   def toMessage(using Context) = em"malformed type: $pre is not a legal prefix for $denot because it contains abstract type member${if (absMembers.size == 1) "" else "s"} ${absMembers.mkString(", ")}"
 

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

@@ -663,7 +663,7 @@ trait ImplicitRunInfo:
               traverseChildren(t)
             case t =>
               traverseChildren(t)
-              traverse(t.normalized)
+              traverse(try t.normalized catch case _: MatchTypeReductionError => t)
       catch case ex: Throwable => handleRecursive("collectParts of", t.show, ex)
 
       def apply(tp: Type): collection.Set[Type] =

tests/neg-macros/toexproftuple.scala

@@ -1,8 +1,33 @@
-import scala.quoted._, scala.deriving.*
+import scala.quoted._, scala.deriving.* // error
+// ^
+// Match type reduction failed since selector  ((2 : Int), quoted.Expr[(3 : Int)])
+// matches none of the cases
+//
+//     case quoted.Expr[x] *: t => x *: scala.Tuple.InverseMap[t, quoted.Expr]
+//     case EmptyTuple => EmptyTuple
 
-inline def mcr: Any = ${mcrImpl}
+inline def mcr: Any = ${mcrImpl} // error
+// ^
+// Match type reduction failed since selector  ((2 : Int), quoted.Expr[(3 : Int)])
+// matches none of the cases
+//
+//     case quoted.Expr[x] *: t => x *: scala.Tuple.InverseMap[t, quoted.Expr]
+//     case EmptyTuple => EmptyTuple
 
-def mcrImpl(using ctx: Quotes): Expr[Any] = {
+def mcrImpl(using ctx: Quotes): Expr[Any] = { // error // error
+  //^
+  // Match type reduction failed since selector  ((2 : Int), quoted.Expr[(3 : Int)])
+  // matches none of the cases
+  //
+  //     case quoted.Expr[x] *: t => x *: scala.Tuple.InverseMap[t, quoted.Expr]
+  //     case EmptyTuple => EmptyTuple
+
+  //                                        ^
+  // Match type reduction failed since selector  ((2 : Int), quoted.Expr[(3 : Int)])
+  // matches none of the cases
+  //
+  //     case quoted.Expr[x] *: t => x *: scala.Tuple.InverseMap[t, quoted.Expr]
+  //     case EmptyTuple => EmptyTuple
 
   val tpl: (Expr[1], Expr[2], Expr[3]) = ('{1}, '{2}, '{3})
   '{val res: (1, 3, 3) = ${Expr.ofTuple(tpl)}; res}  // error
@@ -11,12 +36,28 @@ def mcrImpl(using ctx: Quotes): Expr[Any] = {
   // Required: quoted.Expr[((1 : Int), (3 : Int), (3 : Int))]
 
   val tpl2: (Expr[1], 2, Expr[3]) = ('{1}, 2, '{3})
-  '{val res = ${Expr.ofTuple(tpl2)}; res}  // error
+  '{val res = ${Expr.ofTuple(tpl2)}; res}  // error // error // error // error
   //                                 ^
   // Cannot prove that (quoted.Expr[(1 : Int)], (2 : Int), quoted.Expr[(3 : Int)]) =:= scala.Tuple.Map[
   //   scala.Tuple.InverseMap[
   //     (quoted.Expr[(1 : Int)], (2 : Int), quoted.Expr[(3 : Int)])
   //   , quoted.Expr]
   // , quoted.Expr].
 
+  //    ^
+  // Match type reduction failed since selector  ((2 : Int), quoted.Expr[(3 : Int)])
+  // matches none of the cases
+  //
+  //     case quoted.Expr[x] *: t => x *: scala.Tuple.InverseMap[t, quoted.Expr]
+  //     case EmptyTuple => EmptyTuple
+
+  //                                  ^
+  //                                  Cyclic reference involving val res
+
+  // ^
+  // Match type reduction failed since selector  ((2 : Int), quoted.Expr[(3 : Int)])
+  // matches none of the cases
+  //
+  //     case quoted.Expr[x] *: t => x *: scala.Tuple.InverseMap[t, quoted.Expr]
+  //     case EmptyTuple => EmptyTuple
 }

tests/neg/i12049.check

@@ -15,17 +15,17 @@
   |                    case B => String
   |
   | longer explanation available when compiling with `-explain`
--- [E184] Type Error: tests/neg/i12049.scala:14:23 ---------------------------------------------------------------------
+-- 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
    |                       matches none of the cases
    |
    |                           case _ *: _ *: t => Last[t]
    |                           case t *: EmptyTuple => t
--- [E184] Type Error: tests/neg/i12049.scala:22:26 ---------------------------------------------------------------------
+-- Error: tests/neg/i12049.scala:22:26 ---------------------------------------------------------------------------------
 22 |val z3: (A, B, A) = ??? : Reverse[(A, B, A)] // error
-   |                          ^^^^^^^^^^^^^^^^^^
+   |                          ^
    |                          Match type reduction failed since selector A *: EmptyTuple.type
    |                          matches none of the cases
    |
@@ -45,17 +45,17 @@
    |                      Therefore, reduction cannot advance to the remaining case
    |
    |                        case B => String
--- [E184] Type Error: tests/neg/i12049.scala:25:26 ---------------------------------------------------------------------
+-- 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
    |                          matches none of the cases
    |
    |                              case _ *: _ *: t => Last[t]
    |                              case t *: EmptyTuple => t
--- [E184] Type Error: tests/neg/i12049.scala:26:29 ---------------------------------------------------------------------
+-- Error: tests/neg/i12049.scala:26:29 ---------------------------------------------------------------------------------
 26 |val _ = summon[(A, B, A) =:= Reverse[(A, B, A)]] // error
-   |                             ^^^^^^^^^^^^^^^^^^
+   |                             ^
    |                             Match type reduction failed since selector A *: EmptyTuple.type
    |                             matches none of the cases
    |

tests/neg/i13757-match-type-anykind.scala

@@ -8,9 +8,9 @@ object Test:
   type AnyKindMatchType3[X <: AnyKind] = X match // error: the scrutinee of a match type cannot be higher-kinded
     case _ => Int
 
-  type AnyKindMatchType4[X <: Option] = X match // error // error: the scrutinee of a match type cannot be higher-kinded
+  type AnyKindMatchType4[X <: Option] = X match // error // error: the scrutinee of a match type cannot be higher-kinded // error
     case _ => Int
 
-  type AnyKindMatchType5[X[_]] = X match // error: the scrutinee of a match type cannot be higher-kinded
+  type AnyKindMatchType5[X[_]] = X match // error: the scrutinee of a match type cannot be higher-kinded // error
     case _ => Int
 end Test

tests/neg/i19949.scala

@@ -0,0 +1,9 @@
+
+trait T[N]:
+  type M = N match
+    case 0 => Any
+
+val t: T[Double] = new T[Double] {}
+val x: t.M = "hello" // error
+
+val z: T[Double]#M = "hello" // error

tests/neg/matchtype-seq.check

@@ -1,14 +1,14 @@
--- [E184] Type Error: tests/neg/matchtype-seq.scala:9:11 ---------------------------------------------------------------
+-- Error: tests/neg/matchtype-seq.scala:9:11 ---------------------------------------------------------------------------
 9 |  identity[T1[3]]("") // error
-  |           ^^^^^
+  |           ^
   |           Match type reduction failed since selector (3 : Int)
   |           matches none of the cases
   |
   |               case (1 : Int) => Int
   |               case (2 : Int) => String
--- [E184] Type Error: tests/neg/matchtype-seq.scala:10:11 --------------------------------------------------------------
+-- Error: tests/neg/matchtype-seq.scala:10:11 --------------------------------------------------------------------------
 10 |  identity[T1[3]](1) // error
-   |           ^^^^^
+   |           ^
    |           Match type reduction failed since selector (3 : Int)
    |           matches none of the cases
    |

tests/pos/i19950.scala

@@ -0,0 +1,10 @@
+
+trait Apply[F[_]]:
+  extension [T <: NonEmptyTuple](tuple: T)(using toMap: Tuple.IsMappedBy[F][T])
+    def mapN[B](f: Tuple.InverseMap[T, F] => B): F[B] = ???
+
+given Apply[Option] = ???
+given Apply[List] = ???
+given Apply[util.Try] = ???
+
+@main def Repro = (Option(1), Option(2), Option(3)).mapN(_ + _ + _)