Refactor error message handling

 - Revise string interpolators; `em` and `exm` nor produce
   messages, whereas `i`, `e`, and `ex` produce strings.
 - Use Message intead of () => String in some places.

Author: odersky

compiler/src/dotty/tools/backend/sjs/JSExportsGen.scala

@@ -135,8 +135,7 @@ final class JSExportsGen(jsCodeGen: JSCodeGen)(using Context) {
 
     for ((info, _) <- tups.tail) {
       report.error(
-          em"export overload conflicts with export of $firstSym: " +
-          "a field may not share its exported name with another export",
+          em"export overload conflicts with export of $firstSym: a field may not share its exported name with another export",
           info.pos)
     }
 
@@ -264,8 +263,8 @@ final class JSExportsGen(jsCodeGen: JSCodeGen)(using Context) {
       .alternatives
 
     assert(!alts.isEmpty,
-        em"Ended up with no alternatives for ${classSym.fullName}::$name. " +
-        em"Original set was ${alts} with types ${alts.map(_.info)}")
+        em"""Ended up with no alternatives for ${classSym.fullName}::$name.
+            |Original set was ${alts} with types ${alts.map(_.info)}""")
 
     val (jsName, isProp) = exportNameInfo(name)
 

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -1137,7 +1137,7 @@ object desugar {
       def errorOnGivenBinding(bind: Bind)(using Context): Boolean =
         report.error(
           em"""${hl("given")} patterns are not allowed in a ${hl("val")} definition,
-              |please bind to an identifier and use an alias given.""".stripMargin, bind)
+              |please bind to an identifier and use an alias given.""", bind)
         false
 
       def isTuplePattern(arity: Int): Boolean = pat match {

compiler/src/dotty/tools/dotc/ast/tpd.scala

@@ -428,7 +428,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       else
         val res = Select(TypeTree(pre), tp)
         if needLoad && !res.symbol.isStatic then
-          throw new TypeError(em"cannot establish a reference to $res")
+          throw new TypeError(e"cannot establish a reference to $res")
         res
 
   def ref(sym: Symbol)(using Context): Tree =
@@ -1296,7 +1296,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     else if (tree.tpe.widen isRef numericCls)
       tree
     else {
-      report.warning(i"conversion from ${tree.tpe.widen} to ${numericCls.typeRef} will always fail at runtime.")
+      report.warning(em"conversion from ${tree.tpe.widen} to ${numericCls.typeRef} will always fail at runtime.")
       Throw(New(defn.ClassCastExceptionClass.typeRef, Nil)).withSpan(tree.span)
     }
   }

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

@@ -559,7 +559,7 @@ object CaptureSet:
             // elements from variable sources in contra- and non-variant positions. In essence,
             // we approximate types resulting from such maps by returning a possible super type
             // from the actual type. But this is neither sound nor complete.
-            report.warning(i"trying to add elems ${CaptureSet(newElems)} from unrecognized source $origin of mapped set $this$whereCreated")
+            report.warning(em"trying to add elems ${CaptureSet(newElems)} from unrecognized source $origin of mapped set $this$whereCreated")
             CompareResult.fail(this)
           else
             CompareResult.OK

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

@@ -255,7 +255,7 @@ object Contexts {
           file
         catch
           case ex: InvalidPathException =>
-            report.error(s"invalid file path: ${ex.getMessage}")
+            report.error(em"invalid file path: ${ex.getMessage}")
             NoAbstractFile
 
     /** AbstractFile with given path, memoized */

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

@@ -59,7 +59,7 @@ object Decorators {
   end extension
 
   extension (str: => String)
-    def toMessage: Message = reporting.NoExplanation(str)
+    def toMessage: Message = NoExplanation(str)
 
   /** Implements a findSymbol method on iterators of Symbols that
    *  works like find but avoids Option, replacing None with NoSymbol.
@@ -291,17 +291,41 @@ object Decorators {
     def derivedCons(x1: T, xs1: List[T]) =
       if (xs.head eq x1) && (xs.tail eq xs1) then xs else x1 :: xs1
 
+  /* This extension defines the following string formatters:
+   *   i, e, ex, em, exm
+   * String formatters ending in `m` produce a message, the others produce a string.
+   * Details are as follows:
+   *
+   *   i  : Gneral purpose string interpolator that uses Formtting.show to print compiler data
+   *   e  : Like `i`, but with logic that limits the size of messages and that
+   *        filters out nonsensical messages after the first error is reported.
+   *        `e` or its variants should be used for error messages and warnings instead of `i`.
+   *   ex : Like `e`, but it assembles additional info on type variables and for
+   *        disambiguating symbols.
+   *   em : Like `e`, but producing a message
+   *   exm: Like `ex`, but producing a message
+   */
   extension (sc: StringContext)
     /** General purpose string formatting */
     def i(args: Shown*)(using Context): String =
       new StringFormatter(sc).assemble(args)
 
-    /** Formatting for error messages: Like `i` but suppress follow-on
-     *  error messages after the first one if some of their arguments are "non-sensical".
+    /** Formatting for error messages: Like `i`, with two modifications
+     *   - limit size of messages
+     *   - mark some parts of messages with <nonsensical> tags, so that
+     *     error messages after the first one are filtered out if some of
+     *     their arguments are "non-sensical".
      */
-    def em(args: Shown*)(using Context): String =
+    def e(args: Shown*)(using Context): String =
       forErrorMessages(new StringFormatter(sc).assemble(args))
 
+    /** A NoExplanation message formatted with `e` */
+    def em(args: Shown*)(using Context): NoExplanation =
+      NoExplanation(e(args*))
+
+    def exm(args: Shown*)(using Context): NoExplanation =
+      NoExplanation(ex(args*))
+
     /** Formatting with added explanations: Like `em`, but add explanations to
      *  give more info about type variables and to disambiguate where needed.
      */

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

@@ -1268,9 +1268,9 @@ object Denotations {
       if sd1.exists then
         if sd2.exists then
           throw TypeError(
-            em"""Failure to disambiguate overloaded reference with
-                |  ${denot1.symbol.showLocated}: ${denot1.info}  and
-                |  ${denot2.symbol.showLocated}: ${denot2.info}""")
+            e"""Failure to disambiguate overloaded reference with
+               |  ${denot1.symbol.showLocated}: ${denot1.info}  and
+               |  ${denot2.symbol.showLocated}: ${denot2.info}""")
         else sd1
       else sd2
     }

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

@@ -2438,10 +2438,10 @@ object SymDenotations {
             val youngest = assocFiles.filter(_.lastModified == lastModDate)
             val chosen = youngest.head
             def ambiguousFilesMsg(f: AbstractFile) =
-              em"""Toplevel definition $name is defined in
-                  |  $chosen
-                  |and also in
-                  |  $f"""
+              e"""Toplevel definition $name is defined in
+                 |  $chosen
+                 |and also in
+                 |  $f"""
             if youngest.size > 1 then
               throw TypeError(i"""${ambiguousFilesMsg(youngest.tail.head)}
                                  |One of these files should be removed from the classpath.""")
@@ -2454,8 +2454,8 @@ object SymDenotations {
               try f.container == chosen.container catch case NonFatal(ex) => true
             if !ambiguityWarningIssued then
               for conflicting <- assocFiles.find(!sameContainer(_)) do
-                report.warning(i"""${ambiguousFilesMsg(conflicting.nn)}
-                               |Keeping only the definition in $chosen""")
+                report.warning(em"""${ambiguousFilesMsg(conflicting.nn)}
+                                   |Keeping only the definition in $chosen""")
                 ambiguityWarningIssued = true
             multi.filterWithPredicate(_.symbol.associatedFile == chosen)
       end dropStale

compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala

@@ -326,7 +326,7 @@ class ClassfileParser(
       if (isEnum) {
         val enumClass = sym.owner.linkedClass
         if (!enumClass.exists)
-          report.warning(s"no linked class for java enum $sym in ${sym.owner}. A referencing class file might be missing an InnerClasses entry.")
+          report.warning(em"no linked class for java enum $sym in ${sym.owner}. A referencing class file might be missing an InnerClasses entry.")
         else {
           if (!enumClass.is(Flags.Sealed)) enumClass.setFlag(Flags.AbstractSealed)
           enumClass.addAnnotation(Annotation.Child(sym, NoSpan))
@@ -656,7 +656,7 @@ class ClassfileParser(
       case tp: TypeRef if tp.denot.infoOrCompleter.isInstanceOf[StubInfo] =>
         // Silently ignore missing annotation classes like javac
         if ctx.debug then
-          report.warning(i"Error while parsing annotations in ${classfile}: annotation class $tp not present on classpath")
+          report.warning(em"Error while parsing annotations in ${classfile}: annotation class $tp not present on classpath")
         None
       case _ =>
         if (hasError || skip) None
@@ -671,7 +671,7 @@ class ClassfileParser(
       // the classpath would *not* end up here. A class not found is signaled
       // with a `FatalError` exception, handled above. Here you'd end up after a NPE (for example),
       // and that should never be swallowed silently.
-      report.warning("Caught: " + ex + " while parsing annotations in " + classfile)
+      report.warning(em"Caught: $ex while parsing annotations in $classfile")
       if (ctx.debug) ex.printStackTrace()
 
       None // ignore malformed annotations
@@ -753,7 +753,7 @@ class ClassfileParser(
         case tpnme.ConstantValueATTR =>
           val c = pool.getConstant(in.nextChar)
           if (c ne null) res.constant = c
-          else report.warning(s"Invalid constant in attribute of ${sym.showLocated} while parsing ${classfile}")
+          else report.warning(em"Invalid constant in attribute of ${sym.showLocated} while parsing ${classfile}")
 
         case tpnme.MethodParametersATTR =>
           val paramCount = in.nextByte
@@ -967,15 +967,15 @@ class ClassfileParser(
                 }
               }
               else {
-                report.error(s"Could not find $path in ${classfile.underlyingSource}")
+                report.error(em"Could not find $path in ${classfile.underlyingSource}")
                 Array.empty
               }
             case _ =>
               val dir = classfile.container
               val name = classfile.name.stripSuffix(".class") + ".tasty"
               val tastyFileOrNull = dir.lookupName(name, false)
               if (tastyFileOrNull == null) {
-                report.error(s"Could not find TASTY file $name under $dir")
+                report.error(em"Could not find TASTY file $name under $dir")
                 Array.empty
               } else
                 tastyFileOrNull.toByteArray

compiler/src/dotty/tools/dotc/core/tasty/PositionPickler.scala

@@ -14,6 +14,7 @@ import core._
 import Annotations._, Decorators._
 import collection.mutable
 import util.Spans._
+import reporting.Message
 
 class PositionPickler(
     pickler: TastyPickler,
@@ -33,7 +34,7 @@ class PositionPickler(
     (addrDelta << 3) | (toInt(hasStartDelta) << 2) | (toInt(hasEndDelta) << 1) | toInt(hasPoint)
   }
 
-  def picklePositions(source: SourceFile, roots: List[Tree], warnings: mutable.ListBuffer[String]): Unit = {
+  def picklePositions(source: SourceFile, roots: List[Tree], warnings: mutable.ListBuffer[Message]): Unit = {
     /** Pickle the number of lines followed by the length of each line */
     def pickleLineOffsets(): Unit = {
       val content = source.content()

compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala

@@ -127,10 +127,10 @@ class TreeUnpickler(reader: TastyReader,
           if f == null then "" else s" in $f"
         if ctx.settings.YdebugUnpickling.value then throw ex
         else throw TypeError(
-          em"""Could not read definition of $denot$where
-              |An exception was encountered:
-              |  $ex
-              |Run with -Ydebug-unpickling to see full stack trace.""")
+          e"""Could not read definition of $denot$where
+             |An exception was encountered:
+             |  $ex
+             |Run with -Ydebug-unpickling to see full stack trace.""")
       treeAtAddr(currentAddr) =
         try
           atPhaseBeforeTransforms {

compiler/src/dotty/tools/dotc/fromtasty/ReadTasty.scala

@@ -29,7 +29,7 @@ class ReadTasty extends Phase {
       val className = unit.className.toTypeName
 
       def cannotUnpickle(reason: String): None.type = {
-        report.error(s"class $className cannot be unpickled because $reason")
+        report.error(em"class $className cannot be unpickled because $reason")
         None
       }
 

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -1743,7 +1743,7 @@ object Parsers {
           Ident(tpnme.USCOREkw).withSpan(Span(start, in.lastOffset, start))
         else
           if sourceVersion.isAtLeast(future) then
-            deprecationWarning(em"`_` is deprecated for wildcard arguments of types: use `?` instead".toMessage)
+            deprecationWarning(em"`_` is deprecated for wildcard arguments of types: use `?` instead")
             patch(source, Span(in.offset, in.offset + 1), "?")
           val start = in.skipToken()
           typeBounds().withSpan(Span(start, in.lastOffset, start))
@@ -3488,7 +3488,7 @@ object Parsers {
               if sourceVersion.isAtLeast(future) then
                 deprecationWarning(
                   em"""`= _` has been deprecated; use `= uninitialized` instead.
-                      |`uninitialized` can be imported with `scala.compiletime.uninitialized`.""".toMessage,
+                      |`uninitialized` can be imported with `scala.compiletime.uninitialized`.""",
                   rhsOffset)
               placeholderParams = placeholderParams.tail
               atSpan(rhs0.span) { Ident(nme.WILDCARD) }

compiler/src/dotty/tools/dotc/quoted/Interpreter.scala

@@ -60,7 +60,7 @@ abstract class Interpreter(pos: SrcPos, classLoader: ClassLoader)(using Context)
     case tree: Ident if tree.symbol.is(Inline, butNot = Method) =>
       tree.tpe.widenTermRefExpr match
         case ConstantType(c) => c.value.asInstanceOf[Object]
-        case _ => throw new StopInterpretation(em"${tree.symbol} could not be inlined", tree.srcPos)
+        case _ => throw new StopInterpretation(e"${tree.symbol} could not be inlined", tree.srcPos)
 
     // TODO disallow interpreted method calls as arguments
     case Call(fn, args) =>
@@ -231,7 +231,7 @@ abstract class Interpreter(pos: SrcPos, classLoader: ClassLoader)(using Context)
     try clazz.getMethod(name.toString, paramClasses: _*)
     catch {
       case _: NoSuchMethodException =>
-        val msg = em"Could not find method ${clazz.getCanonicalName}.$name with parameters ($paramClasses%, %)"
+        val msg = e"Could not find method ${clazz.getCanonicalName}.$name with parameters ($paramClasses%, %)"
         throw new StopInterpretation(msg, pos)
       case MissingClassDefinedInCurrentRun(sym) if ctx.compilationUnit.isSuspendable =>
           if (ctx.settings.XprintSuspension.value)

compiler/src/dotty/tools/dotc/quoted/PickledQuotes.scala

@@ -12,7 +12,7 @@ import dotty.tools.dotc.core.tasty.{ PositionPickler, TastyPickler, TastyPrinter
 import dotty.tools.dotc.core.tasty.DottyUnpickler
 import dotty.tools.dotc.core.tasty.TreeUnpickler.UnpickleMode
 import dotty.tools.dotc.report
-
+import dotty.tools.dotc.reporting.Message
 
 import scala.quoted.Quotes
 import scala.quoted.runtime.impl._
@@ -220,7 +220,7 @@ object PickledQuotes {
     treePkl.pickle(tree :: Nil)
     treePkl.compactify()
     if tree.span.exists then
-      val positionWarnings = new mutable.ListBuffer[String]()
+      val positionWarnings = new mutable.ListBuffer[Message]()
       val reference = ctx.settings.sourceroot.value
       new PositionPickler(pickler, treePkl.buf.addrOfTree, treePkl.treeAnnots, reference)
         .picklePositions(ctx.compilationUnit.source, tree :: Nil, positionWarnings)

compiler/src/dotty/tools/dotc/report.scala

@@ -70,6 +70,9 @@ object report:
   def warning(msg: Message, pos: SrcPos)(using Context): Unit =
     issueWarning(new Warning(msg, addInlineds(pos)))
 
+  def warning(msg: Message)(using Context): Unit =
+    warning(msg, NoSourcePosition)
+
   def warning(msg: => String, pos: SrcPos = NoSourcePosition)(using Context): Unit =
     warning(msg.toMessage, pos)
 
@@ -78,6 +81,9 @@ object report:
     ctx.reporter.report(new Error(msg, fullPos))
     if ctx.settings.YdebugError.value then Thread.dumpStack()
 
+  def error(msg: Message)(using Context): Unit =
+    error(msg, NoSourcePosition)
+
   def error(msg: => String, pos: SrcPos = NoSourcePosition)(using Context): Unit =
     error(msg.toMessage, pos)