Explain match type reduction failures in error messages

Author: odersky

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

@@ -0,0 +1,86 @@
+package dotty.tools
+package dotc
+package core
+
+import Types._, Contexts._, Symbols._, Decorators._
+import util.Property
+
+object MatchTypeTrace:
+  private enum TraceEntry:
+    case TryReduce(scrut: Type)
+    case NoMatches(scrut: Type, cases: List[Type])
+    case Stuck(scrut: Type, stuckCase: Type, otherCases: List[Type])
+  import TraceEntry._
+
+  private class MatchTrace:
+    var entries: List[TraceEntry] = Nil
+
+  private val MatchTrace = new Property.Key[MatchTrace]
+
+  def record(op: Context ?=> Any)(using Context): String =
+    val trace = new MatchTrace
+    inContext(ctx.fresh.setProperty(MatchTrace, trace)) {
+      op
+      if trace.entries.isEmpty then ""
+      else
+        i"""
+           |
+           |Note: a match type could not be fully reduced:
+           |
+           |${trace.entries.reverse.map(explainEntry)}%\n%"""
+    }
+
+  def isRecording(using Context): Boolean =
+    ctx.property(MatchTrace).isDefined
+
+  private def matchTypeFail(entry: TraceEntry)(using Context) =
+    ctx.property(MatchTrace) match
+      case Some(trace) =>
+        trace.entries match
+          case (e: TryReduce) :: es => trace.entries = entry :: trace.entries
+          case _ =>
+      case _ =>
+
+  def noMatches(scrut: Type, cases: List[Type])(using Context) =
+    matchTypeFail(NoMatches(scrut, cases))
+
+  def stuck(scrut: Type, stuckCase: Type, otherCases: List[Type])(using Context) =
+    matchTypeFail(Stuck(scrut, stuckCase, otherCases))
+
+  def recurseWith(scrut: Type)(op: => Type)(using Context): Type =
+    ctx.property(MatchTrace) match
+      case Some(trace) =>
+        val prev = trace.entries
+        trace.entries = TryReduce(scrut) :: prev
+        val res = op
+        if res.exists then trace.entries = prev
+        res
+      case _ =>
+        op
+
+  private def caseText(tp: Type)(using Context): String = tp match
+    case tp: HKTypeLambda => caseText(tp.resultType)
+    case defn.MatchCase(pat, body) => i"case $pat => $body"
+    case _ => i"case $tp"
+
+  private def casesText(cases: List[Type])(using Context) =
+    i"${cases.map(caseText)}%\n    %"
+
+  private def explainEntry(entry: TraceEntry)(using Context): String = entry match
+    case TryReduce(scrut: Type) =>
+      i"  trying to reduce  $scrut"
+    case NoMatches(scrut, cases) =>
+      i"""  failed since selector  $scrut
+         |  matches none of the cases
+         |
+         |    ${casesText(cases)}"""
+    case Stuck(scrut, stuckCase, otherCases) =>
+      i"""  failed since selector  $scrut
+         |  does not match  ${caseText(stuckCase)}
+         |  and cannot be shown to be disjoint from it either.
+         |  Therefore, reduction cannot advance to the remaining case${if otherCases.length == 1 then "" else "s"}
+         |
+         |    ${casesText(otherCases)}"""
+
+end MatchTypeTrace
+

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

@@ -2798,10 +2798,20 @@ class TrackingTypeComparer(initctx: Context) extends TypeComparer(initctx) {
         Some(NoType)
     }
 
-    def recur(cases: List[Type]): Type = cases match {
-      case cas :: cases1 => matchCase(cas).getOrElse(recur(cases1))
-      case Nil => NoType
-    }
+    def recur(remaining: List[Type]): Type = remaining match
+      case cas :: remaining1 =>
+        matchCase(cas) match
+          case None =>
+            recur(remaining1)
+          case Some(NoType) =>
+            if remaining1.isEmpty then MatchTypeTrace.noMatches(scrut, cases)
+            else MatchTypeTrace.stuck(scrut, cas, remaining1)
+            NoType
+          case Some(tp) =>
+            tp
+      case Nil =>
+        MatchTypeTrace.noMatches(scrut, cases)
+        NoType
 
     inFrozenConstraint {
       // Empty types break the basic assumption that if a scrutinee and a

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

@@ -4025,7 +4025,9 @@ object Types {
         def tryMatchAlias = tycon.info match {
           case MatchAlias(alias) =>
             trace(i"normalize $this", typr, show = true) {
-              alias.applyIfParameterized(args).tryNormalize
+              MatchTypeTrace.recurseWith(this) {
+                alias.applyIfParameterized(args).tryNormalize
+              }
             }
           case _ =>
             NoType
@@ -4537,7 +4539,11 @@ object Types {
         }
 
       record("MatchType.reduce called")
-      if (!Config.cacheMatchReduced || myReduced == null || !isUpToDate) {
+      if !Config.cacheMatchReduced
+          || myReduced == null
+          || !isUpToDate
+          || MatchTypeTrace.isRecording
+      then
         record("MatchType.reduce computed")
         if (myReduced != null) record("MatchType.reduce cache miss")
         myReduced =
@@ -4549,7 +4555,6 @@ object Types {
               finally updateReductionContext(cmp.footprint)
             TypeComparer.tracked(matchCases)
           }
-      }
       myReduced
     }
 

compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala

@@ -182,9 +182,9 @@ class PlainPrinter(_ctx: Context) extends Printer {
             case _ => "case " ~ toText(tp)
           }
           def casesText = Text(cases.map(caseText), "\n")
-            atPrec(InfixPrec) { toText(scrutinee) } ~
-            keywordStr(" match ") ~ "{" ~ casesText ~ "}" ~
-            (" <: " ~ toText(bound) provided !bound.isAny)
+          atPrec(InfixPrec) { toText(scrutinee) } ~
+          keywordStr(" match ") ~ "{" ~ casesText ~ "}" ~
+          (" <: " ~ toText(bound) provided !bound.isAny)
         }.close
       case tp: PreviousErrorType if ctx.settings.XprintTypes.value =>
         "<error>" // do not print previously reported error message because they may try to print this error type again recuresevely

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

@@ -58,6 +58,9 @@ abstract class Message(val errorId: ErrorMessageID) { self =>
     */
   protected def explain: String
 
+  /** A message suffix that can be added for certain subclasses */
+  protected def msgSuffix: String = ""
+
   /** Does this message have an explanation?
    *  This is normally the same as `explain.nonEmpty` but can be overridden
    *  if we need a way to return `true` without actually calling the
@@ -82,7 +85,7 @@ abstract class Message(val errorId: ErrorMessageID) { self =>
   def rawMessage = message
 
   /** The message to report. <nonsensical> tags are filtered out */
-  lazy val message: String = dropNonSensical(msg)
+  lazy val message: String = dropNonSensical(msg + msgSuffix)
 
   /** The explanation to report. <nonsensical> tags are filtered out */
   lazy val explanation: String = dropNonSensical(explain)

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

@@ -50,6 +50,17 @@ import transform.SymUtils._
     def explain = err.whyNoMatchStr(found, expected)
     override def canExplain = true
 
+    override def msgSuffix: String =
+      val collectMatchTrace = new TypeAccumulator[String]:
+        def apply(s: String, tp: Type): String =
+          if s.nonEmpty then s
+          else tp match
+            case tp: AppliedType if tp.isMatchAlias => MatchTypeTrace.record(tp.tryNormalize)
+            case tp: MatchType => MatchTypeTrace.record(tp.tryNormalize)
+            case _ => foldOver(s, tp)
+      collectMatchTrace(collectMatchTrace("", found), expected)
+  end TypeMismatchMsg
+
   abstract class NamingMsg(errorId: ErrorMessageID) extends Message(errorId):
     def kind = "Naming"
 

tests/neg/i12049.scala

@@ -0,0 +1,7 @@
+trait A
+trait B
+type M[X] = X match
+  case A => Int
+  case B => String
+val x: String = ??? : M[B]
+