Refactoring: Replace Addenda by list of Notes

Author: odersky

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

@@ -5,7 +5,6 @@ package cc
 import core.*
 import Types.*, Symbols.*, Contexts.*, Decorators.*
 import util.{SimpleIdentitySet, EqHashMap}
-import typer.ErrorReporting.Addenda
 import util.common.alwaysTrue
 import scala.collection.mutable
 import CCState.*

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

@@ -13,7 +13,6 @@ import reporting.trace
 import printing.{Showable, Printer}
 import printing.Texts.*
 import util.{SimpleIdentitySet, Property, EqHashMap}
-import typer.ErrorReporting.Addenda
 import scala.collection.{mutable, immutable}
 import TypeComparer.ErrorNote
 import CCState.*

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.{Addenda, NothingToAdd, err}
+import typer.ErrorReporting.{Note, err}
 import typer.ProtoTypes.{LhsProto, WildcardSelectionProto, SelectionProto}
 import util.{SimpleIdentitySet, EqHashMap, EqHashSet, SrcPos, Property}
 import util.chaining.tap
@@ -399,7 +399,7 @@ class CheckCaptures extends Recheck, SymTransformer:
             case (fail: IncludeFailure) :: _ => fail.cs
             case _ => target
           def msg(provisional: Boolean) =
-            def toAdd: String = errorNotes(otherNotes).toAdd.mkString
+            def toAdd: String = errorNotes(otherNotes).map(_.render).mkString
             def descr: String =
               val d = realTarget.description
               if d.isEmpty then provenance else ""
@@ -1208,7 +1208,7 @@ class CheckCaptures extends Recheck, SymTransformer:
           // too annoying. This is a hole since a defualt getter's result type
           // might leak into a type variable.
 
-      def fail(tree: Tree, expected: Type, addenda: Addenda): Unit =
+      def fail(tree: Tree, expected: Type, notes: List[Note]): Unit =
         def maybeResult = if sym.is(Method) then " result" else ""
         report.error(
           em"""$sym needs an explicit$maybeResult type because the inferred type does not conform to
@@ -1218,7 +1218,7 @@ class CheckCaptures extends Recheck, SymTransformer:
               | Externally visible type: $expected""",
           tree.srcPos)
 
-      def addenda(expected: Type) = Addenda:
+      def addendum(expected: Type) = Note:
         def result = if tree.isInstanceOf[ValDef] then"" else " result"
         i"""
           |
@@ -1237,7 +1237,7 @@ class CheckCaptures extends Recheck, SymTransformer:
             val expected = tpt.tpe.dropAllRetains
             todoAtPostCheck += { () =>
               withCapAsRoot:
-                testAdapted(tp, expected, tree.rhs, addenda(expected))(fail)
+                testAdapted(tp, expected, tree.rhs, addendum(expected) :: Nil)(fail)
                 // The check that inferred <: expected is done after recheck so that it
                 // does not interfere with normal rechecking by constraining capture set variables.
             }
@@ -1444,34 +1444,34 @@ class CheckCaptures extends Recheck, SymTransformer:
 
     type BoxErrors = mutable.ListBuffer[Message] | Null
 
-    private def errorNotes(notes: List[TypeComparer.ErrorNote])(using Context): Addenda =
-      if notes.isEmpty then NothingToAdd
-      else new Addenda:
-        override def toAdd(using Context) = notes.map: note =>
+    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 a a capability in contravariant position to the empty set because
+     *  mapping of a capability in contravariant position to the empty set because
      *  the original result type of the map was not itself a capability.
      */
-    private def addApproxAddenda(using Context) =
-      new TypeAccumulator[Addenda]:
-        def apply(add: Addenda, t: Type) = t match
+    private def addApproxAddenda(using Context): TypeAccumulator[List[Note]] =
+      new TypeAccumulator:
+        def apply(notes: List[Note], t: Type) = t match
           case CapturingType(t, CaptureSet.EmptyWithProvenance(ref, mapped)) =>
             /* val (origCore, kind) = original match
               case tp @ AnnotatedType(parent, ann) if ann.hasSymbol(defn.ReachCapabilityAnnot) =>
                 (parent, " deep")
               case _ =>
                 (original, "")*/
-            add ++ Addenda:
+            Note:
                 i"""
                    |
                    |Note that a capability $ref in a capture set appearing in contravariant position
                    |was mapped to $mapped which is not a capability. Therefore, it was under-approximated to the empty set."""
+            :: notes
           case _ =>
-            foldOver(add, t)
+            foldOver(notes, t)
 
     /** Massage `actual` and `expected` types before checking conformance.
      *  Massaging is done by the methods following this one:
@@ -1480,8 +1480,8 @@ class CheckCaptures extends Recheck, SymTransformer:
      *  If the resulting types are not compatible, try again with an actual type
      *  where local capture roots are instantiated to root variables.
      */
-    override def checkConformsExpr(actual: Type, expected: Type, tree: Tree, addenda: Addenda)(using Context): Type =
-      try testAdapted(actual, expected, tree, addenda)(err.typeMismatch)
+    override def checkConformsExpr(actual: Type, expected: Type, tree: Tree, notes: List[Note])(using Context): Type =
+      try testAdapted(actual, expected, tree, notes: List[Note])(err.typeMismatch)
       catch case ex: AssertionError =>
         println(i"error while checking $tree: $actual against $expected")
         throw ex
@@ -1496,8 +1496,8 @@ class CheckCaptures extends Recheck, SymTransformer:
           case _ => NoType
       case _ => NoType
 
-    inline def testAdapted(actual: Type, expected: Type, tree: Tree, addenda: Addenda)
-        (fail: (Tree, Type, Addenda) => Unit)(using Context): Type =
+    inline def testAdapted(actual: Type, expected: Type, tree: Tree, notes: List[Note])
+        (fail: (Tree, Type, List[Note]) => Unit)(using Context): Type =
 
       var expected1 = alignDependentFunction(expected, actual.stripCapturing)
       val falseDeps = expected1 ne expected
@@ -1544,11 +1544,12 @@ class CheckCaptures extends Recheck, SymTransformer:
         }
 
       TypeComparer.compareResult(tryCurrentType || tryWidenNamed) match
-        case TypeComparer.CompareResult.Fail(notes) =>
+        case TypeComparer.CompareResult.Fail(errNotes) =>
           capt.println(i"conforms failed for ${tree}: $actual vs $expected")
           if falseDeps then expected1 = unalignFunction(expected1)
-          fail(tree.withType(actualBoxed), expected1,
-            addApproxAddenda(addenda ++ errorNotes(notes), expected1))
+          val toAdd0 = notes ++ errorNotes(errNotes)
+          val toAdd1 = addApproxAddenda(toAdd0, expected1)
+          fail(tree.withType(actualBoxed), expected1, toAdd1)
           actual
         case /*OK*/ _ =>
           if debugSuccesses then tree match

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

@@ -3327,7 +3327,7 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
    *  the same class as `note`.
    */
   def addErrorNote(note: ErrorNote): Unit =
-    if errorNotes.forall(_._2.kind != note.kind) then
+    if errorNotes.forall(_._2.getClass != note.getClass) then
       errorNotes = (recCount, note) :: errorNotes
       assert(maxErrorLevel <= recCount)
       maxErrorLevel = recCount
@@ -3357,11 +3357,6 @@ object TypeComparer {
 
   /** A base trait for data producing addenda to error messages */
   trait ErrorNote:
-    /** A disciminating kind. An error note is not added if it has the same kind
-     *  as an already existing error note.
-     */
-    def kind: Class[?] = getClass
-
     def description(using Context): String
   end ErrorNote
 

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, Addenda, NothingToAdd}
+import typer.ErrorReporting.{err, matchReductionAddendum, substitutableTypeSymbolsInScope, Note}
 import typer.ProtoTypes.{ViewProto, SelectionProto, FunProto}
 import typer.Implicits.*
 import typer.Inferencing
@@ -298,7 +298,7 @@ extends NotFoundMsg(MissingIdentID) {
   }
 }
 
-class TypeMismatch(val found: Type, expected: Type, val inTree: Option[untpd.Tree], addenda: Addenda = NothingToAdd)(using Context)
+class TypeMismatch(val found: Type, expected: Type, val inTree: Option[untpd.Tree], notes: List[Note] = Nil)(using Context)
   extends TypeMismatchMsg(found, expected)(TypeMismatchID):
 
   private val shouldSuggestNN =
@@ -359,8 +359,7 @@ class TypeMismatch(val found: Type, expected: Type, val inTree: Option[untpd.Tre
     def importSuggestions =
       if expected.isTopType || found.isBottomType then ""
       else ctx.typer.importSuggestionAddendum(ViewProto(found.widen, expected))
-
-    addenda.toAdd.mkString ++ super.msgPostscript ++ importSuggestions
+    notes.map(_.render).mkString ++ super.msgPostscript ++ importSuggestions
 
   override def explain(using Context) =
     val treeStr = inTree.map(x => s"\nTree:\n\n${x.show}\n").getOrElse("")

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.{Addenda, NothingToAdd}
+import typer.ErrorReporting.Note
 import config.Printers.recheckr
 import util.Property
 import StdNames.nme
@@ -633,11 +633,11 @@ abstract class Recheck extends Phase, SymTransformer:
       println(i"fail while $actual iscompat $expected")
       throw ex
 
-    def checkConformsExpr(actual: Type, expected: Type, tree: Tree, addenda: Addenda = NothingToAdd)(using Context): Type =
+    def checkConformsExpr(actual: Type, expected: Type, tree: Tree, notes: List[Note] = Nil)(using Context): Type =
       //println(i"check conforms $actual <:< $expected")
       if !isCompatible(actual, expected) then
         recheckr.println(i"conforms failed for ${tree}: $actual vs $expected")
-        err.typeMismatch(tree.withType(actual), expected, addenda)
+        err.typeMismatch(tree.withType(actual), expected, notes)
       actual
 
     def checkUnit(unit: CompilationUnit)(using Context): Unit =

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

@@ -71,18 +71,13 @@ object ErrorReporting {
           case _ => foldOver(s, tp)
     tps.foldLeft("")(collectMatchTrace)
 
-  /** A mixin trait that can produce added elements for an error message */
-  trait Addenda:
-    def toAdd(using Context): List[String]
-    def ++(follow: Addenda) = new Addenda:
-      def toAdd(using Context) = Addenda.this.toAdd ++ follow.toAdd
+  /** A note can produce an added string for an error message */
+  abstract class Note(val prefix: Boolean = false):
+    def render(using Context): String
 
-  object Addenda:
-    def apply(msg: Context ?=> String): Addenda = new Addenda:
-      def toAdd(using Context) = msg :: Nil
-
-  object NothingToAdd extends Addenda:
-    def toAdd(using Context): List[String] = Nil
+  object Note:
+    def apply(msg: Context ?=> String, prefix: Boolean = false) = new Note(prefix):
+      def render(using Context) = msg
 
   class Errors(using Context) {
 
@@ -180,7 +175,7 @@ object ErrorReporting {
 
     def patternConstrStr(tree: Tree): String = ???
 
-    def typeMismatch(tree: Tree, pt: Type, addenda: Addenda = NothingToAdd): Tree = {
+    def typeMismatch(tree: Tree, pt: Type, notes: List[Note] = Nil): Tree = {
       val normTp = normalize(tree.tpe, pt)
       val normPt = normalize(pt, pt)
 
@@ -199,11 +194,11 @@ object ErrorReporting {
 
       def missingElse = tree match
         case If(_, _, elsep @ Literal(Constant(()))) if elsep.span.isSynthetic =>
-          Addenda("\nMaybe you are missing an else part for the conditional?")
+          Note("\nMaybe you are missing an else part for the conditional?") :: Nil
         case _ =>
-          NothingToAdd
+          Nil
 
-      errorTree(tree, TypeMismatch(treeTp, expectedTp, Some(tree), addenda ++ missingElse))
+      errorTree(tree, TypeMismatch(treeTp, expectedTp, Some(tree), notes ++ missingElse))
     }
 
     /** A subtype log explaining why `found` does not conform to `expected` */

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

@@ -467,7 +467,7 @@ object Implicits:
     }
   }
 
-  abstract class SearchFailureType extends ErrorType, Addenda {
+  abstract class SearchFailureType extends ErrorType {
     def expectedType: Type
     def argument: Tree
 
@@ -485,7 +485,7 @@ object Implicits:
         else i"convert from ${argument.tpe} to ${clarify(expectedType)}"
     }
 
-    def toAdd(using Context) = Nil
+    def notes(using Context): List[Note] = Nil
   }
 
   class NoMatchingImplicits(val expectedType: Type, val argument: Tree, constraint: Constraint = OrderingConstraint.empty)
@@ -540,10 +540,12 @@ object Implicits:
   /** A failure value indicating that an implicit search for a conversion was not tried */
   case class TooUnspecific(target: Type) extends NoMatchingImplicits(NoType, EmptyTree, OrderingConstraint.empty):
 
-    override def toAdd(using Context) =
-      i"""
-         |Note that implicit conversions were not tried because the result of an implicit conversion
-         |must be more specific than $target""" :: Nil
+    override def notes(using Context) =
+      Note:
+        i"""
+          |Note that implicit conversions were not tried because the result of an implicit conversion
+          |must be more specific than $target"""
+      :: Nil
 
     override def msg(using Context) =
       super.msg.append(i"\nThe expected type $target is not specific enough, so no search was attempted")
@@ -567,14 +569,16 @@ object Implicits:
         str2 = alt2.ref.showRef
       em"both $str1 and $str2 $qualify".withoutDisambiguation()
 
-    override def toAdd(using Context) =
+    override def notes(using Context) =
       if !argument.isEmpty && argument.tpe.widen.isRef(defn.NothingClass) then
         Nil
       else
         val what = if (expectedType.isInstanceOf[SelectionProto]) "extension methods" else "conversions"
-        i"""
-           |Note that implicit $what cannot be applied because they are ambiguous;
-           |$explanation""" :: Nil
+        Note:
+          i"""
+             |Note that implicit $what cannot be applied because they are ambiguous;
+             |$explanation"""
+        :: Nil
 
     def asNested = if nested then this else AmbiguousImplicits(alt1, alt2, expectedType, argument, nested = true)
   end AmbiguousImplicits

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

@@ -4218,7 +4218,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
                 then
                   tryExtensionOrConversion(tree, pt, mbrProto, qual, locked, compat, inSelect)
                 else
-                  err.typeMismatch(qual, selProto, failure.reason) // TODO: report NotAMember instead, but need to be aware of failure
+                  err.typeMismatch(qual, selProto, failure.reason.notes) // TODO: report NotAMember instead, but need to be aware of failure
             rememberSearchFailure(qual, failure)
       catch case ex: TypeError => nestedFailure(ex)
 
@@ -4889,7 +4889,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
         else
           val tree1 = healAdapt(tree, pt)
           if tree1 ne tree then readapt(tree1)
-          else err.typeMismatch(tree, pt, failure)
+          else err.typeMismatch(tree, pt, failure.notes)
 
       pt match
         case _: SelectionProto =>