Add actionable item to PatternMatchExhaustivity diag

Author: ghostbuster91

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

@@ -840,10 +840,12 @@ extends Message(LossyWideningConstantConversionID):
                 |Write `.to$targetType` instead."""
   def explain(using Context) = ""
 
-class PatternMatchExhaustivity(uncoveredFn: => String, hasMore: Boolean)(using Context)
+class PatternMatchExhaustivity(val uncovered: Seq[String], tree: untpd.Match)(using Context)
 extends Message(PatternMatchExhaustivityID) {
   def kind = MessageKind.PatternMatchExhaustivity
-  lazy val uncovered = uncoveredFn
+
+  private val hasMore = uncovered.lengthCompare(6) > 0
+
   def msg(using Context) =
     val addendum = if hasMore then "(More unmatched cases are elided)" else ""
     i"""|${hl("match")} may not be exhaustive.
@@ -858,6 +860,26 @@ extends Message(PatternMatchExhaustivityID) {
         | - If an extractor always return ${hl("Some(...)")}, write ${hl("Some[X]")} for its return type
         | - Add a ${hl("case _ => ...")} at the end to match all remaining cases
         |"""
+
+  override def actions(using Context) =
+    import scala.language.unsafeNulls
+    val endPos = tree.cases.lastOption.map(_.endPos).getOrElse(tree.selector.endPos)
+    val startColumn = tree.cases.lastOption.map(_.startPos.startColumn).getOrElse(tree.selector.startPos.startColumn + 2)
+    val pathes = List(
+          ActionPatch(endPos, uncovered.map(c=> indent(s"case $c => ???", startColumn)).mkString("\n", "\n", "")),
+        )
+    List(
+      CodeAction(title = s"Insert missing cases (${uncovered.size})",
+        description = None,
+        patches = pathes
+      )
+    )
+
+
+  private def indent(text:String, margin: Int): String = {
+    import scala.language.unsafeNulls
+    " " * margin + text
+  }
 }
 
 class UncheckedTypePattern(msgFn: => String)(using Context)
@@ -2985,4 +3007,4 @@ class ImplausiblePatternWarning(pat: tpd.Tree, selType: Type)(using Context)
       i"""|Implausible pattern:
           |$pat  could match selector of type  $selType
           |only if there is an `equals` method identifying elements of the two types."""
-    def explain(using Context) = ""
+    def explain(using Context) = ""

compiler/src/dotty/tools/dotc/transform/patmat/Space.scala

@@ -769,7 +769,7 @@ object SpaceEngine {
     checkConstraint(genConstraint(sp))(using ctx.fresh.setNewTyperState())
   }
 
-  def showSpaces(ss: Seq[Space])(using Context): String = ss.map(show).mkString(", ")
+  def showSpaces(ss: Seq[Space])(using Context): Seq[String] = ss.map(show)
 
   /** Display spaces */
   def show(s: Space)(using Context): String = {
@@ -894,9 +894,8 @@ object SpaceEngine {
 
 
     if uncovered.nonEmpty then
-      val hasMore = uncovered.lengthCompare(6) > 0
-      val deduped = dedup(uncovered.take(6))
-      report.warning(PatternMatchExhaustivity(showSpaces(deduped), hasMore), m.selector)
+      val deduped = dedup(uncovered)
+      report.warning(PatternMatchExhaustivity(showSpaces(deduped), m), m.selector)
   }
 
   private def redundancyCheckable(sel: Tree)(using Context): Boolean =

compiler/test/dotty/tools/dotc/reporting/CodeActionTest.scala

@@ -52,7 +52,31 @@ class CodeActionTest extends DottyTest:
       // TODO look into trying to remove the extra space that is left behind
       """|final  class Test
          |""".stripMargin
+      )
 
+  @Test def insertMissingCases =
+    checkCodeAction(
+      code = """|enum Tree:
+         |  case Node(l: Tree, r: Tree)
+         |  case Leaf(v: String)
+         |
+         |object Test:
+         |  def foo(tree: Tree) = tree match {
+         |    case Tree.Node(_, _) => ???
+         |  }
+         |""".stripMargin,
+         title = "Insert missing cases (1)",
+      expected = """|enum Tree:
+         |  case Node(l: Tree, r: Tree)
+         |  case Leaf(v: String)
+         |
+         |object Test:
+         |  def foo(tree: Tree) = tree match {
+         |    case Tree.Node(_, _) => ???
+         |    case Tree.Leaf(_) => ???
+         |  }
+         |""".stripMargin,
+         afterPhase = "patternMatcher"
       )
 
   // Make sure we're not using the default reporter, which is the ConsoleReporter,
@@ -61,16 +85,16 @@ class CodeActionTest extends DottyTest:
     val rep = new StoreReporter(null) with UniqueMessagePositions with HideNonSensicalMessages
     initialCtx.setReporter(rep).withoutColors
 
-  private def checkCodeAction(code: String, title: String, expected: String) =
+  private def checkCodeAction(code: String, title: String, expected: String, afterPhase: String = "typer") =
     ctx = newContext
     val source = SourceFile.virtual("test", code).content
-    val runCtx = checkCompile("typer", code) { (_, _) => () }
+    val runCtx = checkCompile(afterPhase, code) { (_, _) => () }
     val diagnostics = runCtx.reporter.removeBufferedMessages
-    assertEquals(1, diagnostics.size)
+    assertEquals("Expected exactly one diagnostic", 1, diagnostics.size)
 
     val diagnostic = diagnostics.head
     val actions = diagnostic.msg.actions.toList
-    assertEquals(1, actions.size)
+    assertEquals("Expected exactly one action", 1, actions.size)
 
     // TODO account for more than 1 action
     val action = actions.head

compiler/test/dotty/tools/dotc/reporting/TestReporter.scala

@@ -75,7 +75,7 @@ extends Reporter with UniqueMessagePositions with HideNonSensicalMessages with M
 
     // Here we add extra information that we should know about the error message
     val extra = dia.msg match {
-      case pm: PatternMatchExhaustivity => s": ${pm.uncovered}"
+      case pm: PatternMatchExhaustivity => s": ${pm.uncovered.mkString("\n")}"
       case _ => ""
     }