Refactoring: Merge TypeComparer.ErrorNote and ErrorReporting.Note

The merged class is reporting.Message.Note.

Author: odersky

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

@@ -10,11 +10,11 @@ import annotation.threadUnsafe
 import annotation.constructorOnly
 import annotation.internal.sharable
 import reporting.trace
+import reporting.Message.Note
 import printing.{Showable, Printer}
 import printing.Texts.*
 import util.{SimpleIdentitySet, Property, EqHashMap}
 import scala.collection.{mutable, immutable}
-import TypeComparer.ErrorNote
 import CCState.*
 import TypeOps.AvoidMap
 import compiletime.uninitialized
@@ -160,8 +160,8 @@ sealed abstract class CaptureSet extends Showable:
 
   final def keepAlways: Boolean = this.isInstanceOf[EmptyWithProvenance]
 
-  def failWith(fail: TypeComparer.ErrorNote)(using Context): false =
-    TypeComparer.addErrorNote(fail)
+  def failWith(note: Note)(using Context): false =
+    TypeComparer.addErrorNote(note)
     false
 
   /** Try to include an element in this capture set.
@@ -1304,16 +1304,18 @@ object CaptureSet:
    *  when a subsumes check decides that an existential variable `ex` cannot be
    *  instantiated to the other capability `other`.
    */
-  case class ExistentialSubsumesFailure(val ex: ResultCap, val other: Capability) extends ErrorNote:
-    def description(using Context): String =
+  case class ExistentialSubsumesFailure(val ex: ResultCap, val other: Capability) extends Note:
+    def render(using Context): String =
       def reason =
         if other.isTerminalCapability then ""
         else " since that capability is not a `Sharable` capability"
-      i"""the existential capture root in ${ex.originalBinder.resType}
+      i"""
+         |
+         |Note that the existential capture root in ${ex.originalBinder.resType}
          |cannot subsume the capability $other$reason."""
 
   /** Failure indicating that `elem` cannot be included in `cs` */
-  case class IncludeFailure(cs: CaptureSet, elem: Capability, levelError: Boolean = false) extends ErrorNote, Showable:
+  case class IncludeFailure(cs: CaptureSet, elem: Capability, levelError: Boolean = false) extends Note, Showable:
     private var myTrace: List[CaptureSet] = cs :: Nil
 
     def trace: List[CaptureSet] = myTrace
@@ -1322,7 +1324,12 @@ object CaptureSet:
       res.myTrace = cs1 :: this.myTrace
       res
 
-    def description(using Context): String =
+    def render(using Context) =
+      i"""
+         |
+         |Note that $description."""
+
+    private def description(using Context): String =
       def why =
         val reasons = cs.elems.toList.collect:
           case c: FreshCap if !c.acceptsLevelOf(elem) =>
@@ -1371,11 +1378,13 @@ object CaptureSet:
    *  @param  lo    the lower type of the orginal type comparison, or NoType if not known
    *  @param  hi    the upper type of the orginal type comparison, or NoType if not known
    */
-  case class MutAdaptFailure(cs: CaptureSet, lo: Type = NoType, hi: Type = NoType) extends ErrorNote:
-    def description(using Context): String =
+  case class MutAdaptFailure(cs: CaptureSet, lo: Type = NoType, hi: Type = NoType) extends Note:
+    def render(using Context): String =
       def ofType(tp: Type) = if tp.exists then i"of the mutable type $tp" else "of a mutable type"
-      i"""$cs is an exclusive capture set ${ofType(hi)},
-          |it cannot subsume a read-only capture set ${ofType(lo)}"""
+      i"""
+         |
+         |Note that $cs is an exclusive capture set ${ofType(hi)},
+         |it cannot subsume a read-only capture set ${ofType(lo)}."""
 
   /** A VarState serves as a snapshot mechanism that can undo
    *  additions of elements or super sets if an operation fails

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

@@ -14,7 +14,7 @@ import typer.ForceDegree
 import typer.Inferencing.isFullyDefined
 import typer.RefChecks.{checkAllOverrides, checkSelfAgainstParents, OverridingPairsChecker}
 import typer.Checking.{checkBounds, checkAppliedTypesIn}
-import typer.ErrorReporting.{Note, err}
+import typer.ErrorReporting.err
 import typer.ProtoTypes.{LhsProto, WildcardSelectionProto, SelectionProto}
 import util.{SimpleIdentitySet, EqHashMap, EqHashSet, SrcPos, Property}
 import util.chaining.tap
@@ -26,6 +26,7 @@ import CCState.*
 import StdNames.nme
 import NameKinds.{DefaultGetterName, WildcardParamName, UniqueNameKind}
 import reporting.{trace, Message, OverrideError}
+import reporting.Message.Note
 import Annotations.Annotation
 import Capabilities.*
 import Mutability.*
@@ -399,7 +400,7 @@ class CheckCaptures extends Recheck, SymTransformer:
             case (fail: IncludeFailure) :: _ => fail.cs
             case _ => target
           def msg(provisional: Boolean) =
-            def toAdd: String = errorNotes(otherNotes).map(_.render).mkString
+            def toAdd: String = otherNotes.map(_.render).mkString
             def descr: String =
               val d = realTarget.description
               if d.isEmpty then provenance else ""
@@ -1444,13 +1445,6 @@ class CheckCaptures extends Recheck, SymTransformer:
 
     type BoxErrors = mutable.ListBuffer[Message] | Null
 
-    private def errorNotes(notes: List[TypeComparer.ErrorNote])(using Context): List[Note] =
-      notes.map: note =>
-        Note:
-          i"""
-             |
-             |Note that ${note.description}."""
-
     /** Addendas for error messages that show where we have under-approximated by
      *  mapping of a capability in contravariant position to the empty set because
      *  the original result type of the map was not itself a capability.
@@ -1544,10 +1538,10 @@ class CheckCaptures extends Recheck, SymTransformer:
         }
 
       TypeComparer.compareResult(tryCurrentType || tryWidenNamed) match
-        case TypeComparer.CompareResult.Fail(errNotes) =>
+        case TypeComparer.CompareResult.Fail(cmpNotes) =>
           capt.println(i"conforms failed for ${tree}: $actual vs $expected")
           if falseDeps then expected1 = unalignFunction(expected1)
-          val toAdd0 = notes ++ errorNotes(errNotes)
+          val toAdd0 = notes ++ cmpNotes
           val toAdd1 = addApproxAddenda(toAdd0, expected1)
           fail(tree.withType(actualBoxed), expected1, toAdd1)
           actual

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

@@ -26,6 +26,7 @@ import cc.*
 import Capabilities.Capability
 import NameKinds.WildcardParamName
 import MatchTypes.isConcrete
+import reporting.Message.Note
 import scala.util.boundary, boundary.break
 
 /** Provides methods to compare types.
@@ -61,7 +62,7 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
   private var monitored = false
 
   private var maxErrorLevel: Int = -1
-  protected var errorNotes: List[(Int, ErrorNote)] = Nil
+  protected var errorNotes: List[(Int, Note)] = Nil
 
   val undoLog = mutable.ArrayBuffer[() => Unit]()
 
@@ -3323,10 +3324,10 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
   def reduceMatchWith[T](op: MatchReducer => T)(using Context): T =
     inSubComparer(matchReducer)(op)
 
-  /** Add given ErrorNote note, provided there is not yet an error note with
+  /** Add given note, provided there is not yet an error note with
    *  the same class as `note`.
    */
-  def addErrorNote(note: ErrorNote): Unit =
+  def addErrorNote(note: Note): Unit =
     if errorNotes.forall(_._2.getClass != note.getClass) then
       errorNotes = (recCount, note) :: errorNotes
       assert(maxErrorLevel <= recCount)
@@ -3355,15 +3356,10 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
 
 object TypeComparer {
 
-  /** A base trait for data producing addenda to error messages */
-  trait ErrorNote:
-    def description(using Context): String
-  end ErrorNote
-
   /** A richer compare result, returned by `testSubType` and `test`. */
   enum CompareResult:
     case OK, OKwithGADTUsed, OKwithOpaquesUsed
-    case Fail(errorNotes: List[ErrorNote])
+    case Fail(errorNotes: List[Note])
 
   /** Class for unification variables used in `natValue`. */
   private class AnyConstantType extends UncachedGroundType with ValueType {
@@ -3541,10 +3537,10 @@ object TypeComparer {
   def inNestedLevel(op: => Boolean)(using Context): Boolean =
     currentComparer.inNestedLevel(op)
 
-  def addErrorNote(note: ErrorNote)(using Context): Unit =
+  def addErrorNote(note: Note)(using Context): Unit =
     currentComparer.addErrorNote(note)
 
-  def updateErrorNotes(f: PartialFunction[ErrorNote, ErrorNote])(using Context): Unit =
+  def updateErrorNotes(f: PartialFunction[Note, Note])(using Context): Unit =
     currentComparer.errorNotes = currentComparer.errorNotes.mapConserve: p =>
       val (level, note) = p
       if f.isDefinedAt(note) then (level, f(note)) else p
@@ -3958,7 +3954,7 @@ class ExplainingTypeComparer(initctx: Context, short: Boolean) extends TypeCompa
   private val b = new StringBuilder
   private var lastForwardGoal: String | Null = null
 
-  private def appendFailure(notes: List[ErrorNote]) =
+  private def appendFailure(notes: List[Note]) =
     if lastForwardGoal != null then  // last was deepest goal that failed
       b.append(s"  = false")
       for case note: printing.Showable <- notes do

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

@@ -41,6 +41,14 @@ object Message:
       i"\n$what can be rewritten automatically under -rewrite $optionStr."
     else ""
 
+  /** A note can produce an added string for an error message */
+  abstract class Note(val prefix: Boolean = false):
+    def render(using Context): String
+
+  object Note:
+    def apply(msg: Context ?=> String, prefix: Boolean = false) = new Note(prefix):
+      def render(using Context) = msg
+
   enum Disambiguation:
     case All
     case AllExcept(strs: List[String])

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

@@ -18,7 +18,7 @@ import ast.desugar
 import config.{Feature, MigrationVersion, ScalaVersion}
 import transform.patmat.Space
 import transform.patmat.SpaceEngine
-import typer.ErrorReporting.{err, matchReductionAddendum, substitutableTypeSymbolsInScope, Note}
+import typer.ErrorReporting.{err, matchReductionAddendum, substitutableTypeSymbolsInScope}
 import typer.ProtoTypes.{ViewProto, SelectionProto, FunProto}
 import typer.Implicits.*
 import typer.Inferencing
@@ -38,7 +38,7 @@ import scala.jdk.CollectionConverters.*
 import dotty.tools.dotc.util.SourceFile
 import dotty.tools.dotc.config.SourceVersion
 import DidYouMean.*
-import Message.Disambiguation
+import Message.{Disambiguation, Note}
 
 /**  Messages
   *  ========

compiler/src/dotty/tools/dotc/transform/Recheck.scala

@@ -15,7 +15,7 @@ import typer.ErrorReporting.err
 import typer.ProtoTypes.{AnySelectionProto, LhsProto}
 import typer.TypeAssigner.seqLitType
 import typer.ConstFold
-import typer.ErrorReporting.Note
+import reporting.Message.Note
 import config.Printers.recheckr
 import util.Property
 import StdNames.nme

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

@@ -12,9 +12,9 @@ import util.Spans.NoSpan
 import util.SrcPos
 import config.Feature
 import reporting.*
+import Message.Note
 import collection.mutable
 
-
 object ErrorReporting {
 
   import tpd.*
@@ -71,14 +71,6 @@ object ErrorReporting {
           case _ => foldOver(s, tp)
     tps.foldLeft("")(collectMatchTrace)
 
-  /** A note can produce an added string for an error message */
-  abstract class Note(val prefix: Boolean = false):
-    def render(using Context): String
-
-  object Note:
-    def apply(msg: Context ?=> String, prefix: Boolean = false) = new Note(prefix):
-      def render(using Context) = msg
-
   class Errors(using Context) {
 
     /** An explanatory note to be added to error messages

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

@@ -31,6 +31,7 @@ import Feature.{migrateTo3, sourceVersion}
 import config.Printers.{implicits, implicitsDetailed}
 import collection.mutable
 import reporting.*
+import Message.Note
 import transform.Splicer
 import annotation.tailrec
 

tests/neg-custom-args/captures/heal-tparam-cs.check

@@ -20,7 +20,7 @@
    |    Note that capability x$0 is not included in capture set {cap}.
    |
    |    Note that the existential capture root in () =>² Unit
-   |    cannot subsume the capability (x$0 : Capp^'s4) since that capability is not a `Sharable` capability..
+   |    cannot subsume the capability (x$0 : Capp^'s4) since that capability is not a `Sharable` capability.
    |
    |    where:    =>        refers to a root capability associated with the result type of (c: Capp^): () => Unit
    |              =>² and ^ refer to the universal root capability

tests/neg-custom-args/captures/i16226.check

@@ -25,7 +25,7 @@
    |Note that capability f1 is not included in capture set {cap}.
    |
    |Note that the existential capture root in LazyRef[B]^²
-   |cannot subsume the capability (f1 : A^'s15 ->'s16 B^'s17) since that capability is not a `Sharable` capability..
+   |cannot subsume the capability (f1 : A^'s15 ->'s16 B^'s17) since that capability is not a `Sharable` capability.
    |
    |where:    => and cap refer to a root capability associated with the result type of (ref1: LazyRef[A^'s11]{val elem: () ->'s12 A^'s13}^'s14, f1: A^'s15 ->'s16 B^'s17):
    |  LazyRef[B^'s19]{val elem: () => B^'s20}^{f1, ref1}