Refactor: move multi-span handling logic to Message

Author: Linyxus

compiler/src/dotty/tools/dotc/cc/SepCheck.scala

@@ -443,22 +443,39 @@ class SepCheck(checker: CheckCaptures.CheckerAPI) extends tpd.TreeTraverser:
             |No clashing definitions were found. This might point to an internal error.""",
         tree.srcPos)
 
-  class UseAfterConsume(ref: Capability, consumedLoc: SrcPos, useLoc: SrcPos)(using Context) extends reporting.Diagnostic.Error(
-    em"""Separation failure: Illegal access to $ref, which was passed to a
-        |consume parameter or was used as a prefix to a consume method
-        |and therefore is no longer available.""",
-    useLoc.sourcePos
-  ):
-      addSubdiag(em"The capability was consumed here.", consumedLoc.sourcePos)
-      addPrimaryNote(em"Then, it was used here")
+  class UseAfterConsume(ref: Capability, consumedLoc: SrcPos, useLoc: SrcPos)(using Context) extends reporting.Message(reporting.ErrorMessageID.NoExplanationID):
+    def kind = reporting.MessageKind.NoKind
+
+    protected def msg(using Context): String = ""
+
+    protected def explain(using Context): String = ""
+
+    override def leading(using Context): Option[String] = Some(
+      em"""Separation failure: Illegal access to $ref, which was passed to a
+          |consume parameter or was used as a prefix to a consume method
+          |and therefore is no longer available.""".message
+    )
+
+    override def parts(using Context): List[reporting.Message.MessagePart] = List(
+      reporting.Message.MessagePart(
+        "The capability was consumed here.",
+        consumedLoc.sourcePos,
+        isPrimary = false
+      ),
+      reporting.Message.MessagePart(
+        "Then, it was used here",
+        useLoc.sourcePos,
+        isPrimary = true
+      )
+    )
 
   /** Report a failure where a previously consumed capability is used again,
    *  @param ref     the capability that is used after being consumed
    *  @param loc     the position where the capability was consumed
    *  @param pos     the position where the capability was used again
    */
   def consumeError(ref: Capability, loc: SrcPos, pos: SrcPos)(using Context): Unit =
-    ctx.reporter.report(UseAfterConsume(ref, loc, pos))
+    report.error(UseAfterConsume(ref, loc, pos), pos)
 
   /** Report a failure where a capability is consumed in a loop.
    *  @param ref     the capability

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

@@ -11,8 +11,6 @@ import dotty.tools.dotc.util.chaining.*
 import java.util.{Collections, Optional, List => JList}
 import core.Decorators.toMessage
 
-import collection.mutable.ArrayBuffer
-
 object Diagnostic:
 
   def shouldExplain(dia: Diagnostic)(using Context): Boolean =
@@ -120,30 +118,5 @@ class Diagnostic(
   override def diagnosticRelatedInformation: JList[interfaces.DiagnosticRelatedInformation] =
     Collections.emptyList()
   override def toString: String = s"$getClass at $pos L${pos.line+1}: $message"
-
-  private val subdiags: ArrayBuffer[Subdiagnostic] = ArrayBuffer.empty
-
-  private var primaryNote: Message | Null = null
-
-  def addSubdiag(diag: Subdiagnostic): Unit =
-    subdiags += diag
-
-  def addPrimaryNote(msg: Message): Unit =
-    assert(primaryNote eq null)
-    primaryNote = msg
-
-  def getPrimaryNote: Option[Message] =
-    if primaryNote eq null then None else Some(primaryNote.nn)
-
-  def addSubdiag(msg: Message, pos: SourcePosition): Unit =
-    addSubdiag(Subdiagnostic(msg, pos))
-
-  def withSubdiags(diags: List[Subdiagnostic]): this.type =
-    diags.foreach(addSubdiag)
-    this
-
-  def getSubdiags: List[Subdiagnostic] = subdiags.toList
 end Diagnostic
 
-class Subdiagnostic(val msg: Message, val pos: SourcePosition)
-

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

@@ -300,6 +300,13 @@ object Message:
       super.toText(sym)
   end Printer
 
+  /** A part of a multi-span message, associating text with a source position.
+   *  @param text       the message text for this part
+   *  @param srcPos     the source position where this part applies
+   *  @param isPrimary  whether this is the primary message (true) or a secondary note (false)
+   */
+  case class MessagePart(text: String, srcPos: util.SourcePosition, isPrimary: Boolean)
+
 end Message
 
 /** A `Message` contains all semantic information necessary to easily
@@ -370,6 +377,17 @@ abstract class Message(val errorId: ErrorMessageID)(using Context) { self =>
     */
   protected def explain(using Context): String
 
+  /** Optional leading text to be displayed before the source snippet.
+    * If present along with parts, triggers multi-span rendering.
+    */
+  def leading(using Context): Option[String] = None
+
+  /** Optional list of message parts for multi-span error messages.
+    * Each part associates text with a source position and indicates
+    * whether it's a primary message or a secondary note.
+    */
+  def parts(using Context): List[MessagePart] = Nil
+
   /** What gets printed after the message proper */
   protected def msgPostscript(using Context): String =
     if ctx eq NoContext then ""

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

@@ -253,55 +253,31 @@ trait MessageRendering {
     else
     pos
 
-  /** Render diagnostics with positions in different files separately */
-  private def renderSeparateSpans(dia: Diagnostic)(using Context): String =
+  /** Render a message using multi-span information from Message.parts. */
+  def messageAndPosFromParts(dia: Diagnostic)(using Context): String =
     val msg = dia.msg
     val pos = dia.pos
     val pos1 = adjust(pos.nonInlined)
-    given Level = Level(dia.level)
-    given Offset =
-      val maxLineNumber = if pos.exists then pos1.endLine + 1 else 0
-      Offset(maxLineNumber.toString.length + 2)
-
-    val sb = StringBuilder()
-    val posString = posStr(pos1, msg, diagnosticLevel(dia))
-    if posString.nonEmpty then sb.append(posString).append(EOL)
+    val msgParts = msg.parts
 
-    if pos.exists && pos1.exists && pos1.source.file.exists then
-      val (srcBefore, srcAfter, offset) = sourceLines(pos1)
-      val marker = positionMarker(pos1)
-      val err = errorMsg(pos1, msg.message)
-      sb.append((srcBefore ::: marker :: err :: srcAfter).mkString(EOL))
-    else
-      sb.append(msg.message)
+    if msgParts.isEmpty then
+      return msg.leading.getOrElse("") + (if msg.leading.isDefined then "\n" else "") + msg.message
 
-    dia.getSubdiags.foreach(addSubdiagnostic(sb, _))
-    sb.toString
+    // Collect all positions from message parts
+    val validParts = msgParts.filter(_.srcPos.exists)
 
-  def messageAndPosMultiSpan(dia: Diagnostic)(using Context): String =
-    val msg = dia.msg
-    val pos = dia.pos
-    val pos1 = adjust(pos.nonInlined)
-    val subdiags = dia.getSubdiags
-
-    // Collect all positions with their associated messages
-    case class PosAndMsg(pos: SourcePosition, msg: Message, isPrimary: Boolean)
-    val allPosAndMsg = PosAndMsg(pos1, msg, true) :: subdiags.map(s => PosAndMsg(adjust(s.pos), s.msg, false))
-    val validPosAndMsg = allPosAndMsg.filter(_.pos.exists)
-
-    if validPosAndMsg.isEmpty then
-      return msg.message
+    if validParts.isEmpty then
+      return msg.leading.getOrElse("") + (if msg.leading.isDefined then "\n" else "") + msg.message
 
     // Check all positions are in the same source file
-    val source = validPosAndMsg.head.pos.source
-    if !validPosAndMsg.forall(_.pos.source == source) || !source.file.exists then
-      // Cannot render multi-span if positions are in different files
-      // Fall back to showing them separately
-      return renderSeparateSpans(dia)
+    val source = validParts.head.srcPos.source
+    if !validParts.forall(_.srcPos.source == source) || !source.file.exists then
+      // TODO: support rendering source positions across multiple files
+      return msg.leading.getOrElse("") + (if msg.leading.isDefined then "\n" else "") + msg.message
 
     // Find the line range covering all positions
-    val minLine = validPosAndMsg.map(_.pos.startLine).min
-    val maxLine = validPosAndMsg.map(_.pos.endLine).max
+    val minLine = validParts.map(_.srcPos.startLine).min
+    val maxLine = validParts.map(_.srcPos.endLine).max
     val maxLineNumber = maxLine + 1
 
     given Level = Level(dia.level)
@@ -313,12 +289,13 @@ trait MessageRendering {
     val posString = posStr(pos1, msg, diagnosticLevel(dia))
     if posString.nonEmpty then sb.append(posString).append(EOL)
 
-    // Always display primary error message before code snippet
-    sb.append(msg.message)
-    if !msg.message.endsWith(EOL) then sb.append(EOL)
+    // Display leading text if present
+    msg.leading.foreach { leadingText =>
+      sb.append(leadingText)
+      if !leadingText.endsWith(EOL) then sb.append(EOL)
+    }
 
     // Render the unified code snippet
-    // Get syntax-highlighted content for the entire range
     val startOffset = source.lineToOffset(minLine)
     val endOffset = source.nextLine(source.lineToOffset(maxLine))
     val content = source.content.slice(startOffset, endOffset)
@@ -352,19 +329,13 @@ trait MessageRendering {
         sb.append(lnum).append(lineContent.stripLineEnd).append(EOL)
 
         // Find all positions that should show markers after this line
-        // A position shows its marker after its start line
-        val positionsOnLine = validPosAndMsg.filter(_.pos.startLine == lineNum)
-          .sortBy(pm => (pm.pos.startColumn, !pm.isPrimary)) // Primary positions first if same column
-
-        for posAndMsg <- positionsOnLine do
-          // Use '^' for primary error, '-' for sub-diagnostics
-          val markerChar = if posAndMsg.isPrimary then '^' else '-'
-          val marker = positionMarker(posAndMsg.pos, markerChar)
-          // For primary position: use PrimaryNote if available, otherwise use primary message
-          val messageToShow =
-            if posAndMsg.isPrimary then dia.getPrimaryNote.map(_.message).getOrElse(posAndMsg.msg.message)
-            else posAndMsg.msg.message
-          val err = errorMsg(posAndMsg.pos, messageToShow)
+        val partsOnLine = validParts.filter(_.srcPos.startLine == lineNum)
+          .sortBy(p => (p.srcPos.startColumn, !p.isPrimary))
+
+        for part <- partsOnLine do
+          val markerChar = if part.isPrimary then '^' else '-'
+          val marker = positionMarker(part.srcPos, markerChar)
+          val err = errorMsg(part.srcPos, part.text)
           sb.append(marker).append(EOL)
           sb.append(err).append(EOL)
 
@@ -381,7 +352,7 @@ trait MessageRendering {
       sb.append(EOL).append(offsetBox).append(" longer explanation available when compiling with `-explain`")
 
     sb.toString
-  end messageAndPosMultiSpan
+  end messageAndPosFromParts
 
   /** The whole message rendered from `dia.msg`.
    *
@@ -403,9 +374,11 @@ trait MessageRendering {
    *
    */
   def messageAndPos(dia: Diagnostic)(using Context): String =
-    if dia.getSubdiags.nonEmpty then messageAndPosMultiSpan(dia)
+    val msg = dia.msg
+    // Check if message provides its own multi-span structure
+    if msg.leading.isDefined || msg.parts.nonEmpty then
+      messageAndPosFromParts(dia)
     else
-      val msg = dia.msg
       val pos = dia.pos
       val pos1 = adjust(pos.nonInlined) // innermost pos contained by call.pos
       val outermost = pos.outermost // call.pos
@@ -439,8 +412,6 @@ trait MessageRendering {
         end if
       else sb.append(msg.message)
 
-      dia.getSubdiags.foreach(addSubdiagnostic(sb, _))
-
       if dia.isVerbose then
         appendFilterHelp(dia, sb)
 
@@ -458,20 +429,6 @@ trait MessageRendering {
       sb.toString
   end messageAndPos
 
-  private def addSubdiagnostic(sb: StringBuilder, subdiag: Subdiagnostic)(using Context, Level, Offset): Unit =
-    val pos1 = adjust(subdiag.pos)
-    val msg = subdiag.msg
-    assert(pos1.exists && pos1.source.file.exists)
-
-    val posString = posStr(pos1, msg, "Note", isSubdiag = true)
-    val (srcBefore, srcAfter, offset) = sourceLines(pos1)
-    val marker = positionMarker(pos1, '-')  // Use '-' for sub-diagnostics
-    val err = errorMsg(pos1, msg.message)
-
-    val diagText = (posString :: srcBefore ::: marker :: err :: srcAfter).mkString(EOL)
-    sb.append(EOL)
-    sb.append(diagText)
-
   private def hl(str: String)(using Context, Level): String =
     summon[Level].value match
       case interfaces.Diagnostic.ERROR   => Red(str).show