Refactor string interpolators and error message handling (#16384)

The idea is that we want to concentrate error handling logic in the
`Message` type instead of dispersing it over various
string interpolators.

 - [x] Pass more messages instead of strings to `report` methods.
- [x] Make this easier by having string interpolators that produce
messages
 - [x] Use messages instead of strings elsewhere
- [x] Move logic for limiting size of messages and filtering out
nonsensical errors into `Message`.

From the doc comment for `Message`:

## Tips for error message generation

- You can use the `em` interpolator for error messages. It's defined in
core.Decorators.
- You can also use a simple string argument for `error` or `warning`
(not for the other variants),
but the string should not be interpolated or composed of objects that
require a
   Context for evaluation.
- When embedding interpolated substrings defined elsewhere in error
messages,
use `i` and make sure they are defined as def's instead of vals. That
way, the
possibly expensive interpolation will performed only in the case where
the message
is eventually printed. Note: At least during typer, it's common for
messages
to be discarded without being printed. Also, by making them defs, you
ensure that
they will be evaluated in the Message context, which makes formatting
safer
   and more robust.
- For common messages, or messages that might require explanation,
prefer defining
a new `Message` in file `messages.scala` and use that instead. The
advantage is that these
   messages have unique IDs that can be referenced elsewhere.

Author: odersky

compiler/src/dotty/tools/backend/jvm/BCodeBodyBuilder.scala

@@ -23,6 +23,7 @@ import dotty.tools.dotc.transform.SymUtils._
 import dotty.tools.dotc.util.Spans._
 import dotty.tools.dotc.core.Contexts._
 import dotty.tools.dotc.core.Phases._
+import dotty.tools.dotc.core.Decorators.em
 import dotty.tools.dotc.report
 
 /*
@@ -700,7 +701,7 @@ trait BCodeBodyBuilder extends BCodeSkelBuilder {
       var elemKind = arr.elementType
       val argsSize = args.length
       if (argsSize > dims) {
-        report.error(s"too many arguments for array constructor: found ${args.length} but array has only $dims dimension(s)", ctx.source.atSpan(app.span))
+        report.error(em"too many arguments for array constructor: found ${args.length} but array has only $dims dimension(s)", ctx.source.atSpan(app.span))
       }
       if (argsSize < dims) {
         /* In one step:

compiler/src/dotty/tools/backend/jvm/BCodeHelpers.scala

@@ -79,7 +79,7 @@ trait BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
       outputDirectory
     } catch {
       case ex: Throwable =>
-        report.error(s"Couldn't create file for class $cName\n${ex.getMessage}", ctx.source.atSpan(csym.span))
+        report.error(em"Couldn't create file for class $cName\n${ex.getMessage}", ctx.source.atSpan(csym.span))
         null
     }
   }
@@ -422,7 +422,7 @@ trait BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
           emitAssocs(nestedVisitor, assocs, bcodeStore)(innerClasesStore)
 
         case t =>
-          report.error(ex"Annotation argument is not a constant", t.sourcePos)
+          report.error(em"Annotation argument is not a constant", t.sourcePos)
       }
     }
 
@@ -871,10 +871,11 @@ trait BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
       try body
       catch {
         case ex: Throwable =>
-          report.error(i"""|compiler bug: created invalid generic signature for $sym in ${sym.denot.owner.showFullName}
-                      |signature: $sig
-                      |if this is reproducible, please report bug at https://github.com/lampepfl/dotty/issues
-                  """.trim, sym.sourcePos)
+          report.error(
+            em"""|compiler bug: created invalid generic signature for $sym in ${sym.denot.owner.showFullName}
+                 |signature: $sig
+                 |if this is reproducible, please report bug at https://github.com/lampepfl/dotty/issues
+               """, sym.sourcePos)
           throw  ex
       }
     }

compiler/src/dotty/tools/backend/jvm/BCodeSkelBuilder.scala

@@ -748,7 +748,7 @@ trait BCodeSkelBuilder extends BCodeHelpers {
 
       if (params.size > MaximumJvmParameters) {
         // SI-7324
-        report.error(s"Platform restriction: a parameter list's length cannot exceed $MaximumJvmParameters.", ctx.source.atSpan(methSymbol.span))
+        report.error(em"Platform restriction: a parameter list's length cannot exceed $MaximumJvmParameters.", ctx.source.atSpan(methSymbol.span))
         return
       }
 
@@ -800,9 +800,10 @@ trait BCodeSkelBuilder extends BCodeHelpers {
           val veryFirstProgramPoint = currProgramPoint()
 
           if trimmedRhs == tpd.EmptyTree then
-            report.error("Concrete method has no definition: " + dd + (
-              if (ctx.settings.Ydebug.value) "(found: " + methSymbol.owner.info.decls.toList.mkString(", ") + ")"
-              else ""),
+            report.error(
+              em"Concrete method has no definition: $dd${
+                  if (ctx.settings.Ydebug.value) "(found: " + methSymbol.owner.info.decls.toList.mkString(", ") + ")"
+                  else ""}",
               ctx.source.atSpan(NoSpan)
             )
           else

compiler/src/dotty/tools/backend/jvm/DottyBackendInterface.scala

@@ -14,6 +14,7 @@ import Contexts._
 import Types._
 import Symbols._
 import Phases._
+import Decorators.em
 
 import dotty.tools.dotc.util.ReadOnlyMap
 import dotty.tools.dotc.report
@@ -71,7 +72,7 @@ class DottyBackendInterface(val outputDirectory: AbstractFile, val superCallsMap
     def _1: Type = field.tpe match {
       case JavaArrayType(elem) => elem
       case _ =>
-        report.error(s"JavaSeqArray with type ${field.tpe} reached backend: $field", ctx.source.atSpan(field.span))
+        report.error(em"JavaSeqArray with type ${field.tpe} reached backend: $field", ctx.source.atSpan(field.span))
         UnspecifiedErrorType
     }
     def _2: List[Tree] = field.elems

compiler/src/dotty/tools/backend/jvm/GenBCode.scala

@@ -21,6 +21,7 @@ import dotty.tools.dotc.sbt.ExtractDependencies
 import Contexts._
 import Phases._
 import Symbols._
+import Decorators.em
 
 import java.io.DataOutputStream
 import java.nio.channels.ClosedByInterruptException
@@ -308,7 +309,7 @@ class GenBCodePipeline(val int: DottyBackendInterface, val primitives: DottyPrim
             getFileForClassfile(outF, cls.name, ".class")
           } catch {
             case e: FileConflictException =>
-              report.error(s"error writing ${cls.name}: ${e.getMessage}")
+              report.error(em"error writing ${cls.name}: ${e.getMessage}")
               null
           }
         } else null
@@ -608,11 +609,11 @@ class GenBCodePipeline(val int: DottyBackendInterface, val primitives: DottyPrim
         val method =
           s"${e.getClassName.replaceAll("/", ".")}.${e.getMethodName}"
         val msg =
-          s"Generated bytecode for method '$method' is too large. Size: ${e.getCodeSize} bytes. Limit is 64KB"
+          em"Generated bytecode for method '$method' is too large. Size: ${e.getCodeSize} bytes. Limit is 64KB"
         report.error(msg)
       case e: ClassTooLargeException =>
         val msg =
-          s"Class '${e.getClassName.replaceAll("/", ".")}' is too large. Constant pool size: ${e.getConstantPoolCount}. Limit is 64K entries"
+          em"Class '${e.getClassName.replaceAll("/", ".")}' is too large. Constant pool size: ${e.getConstantPoolCount}. Limit is 64K entries"
         report.error(msg)
 
   }

compiler/src/dotty/tools/backend/jvm/scalaPrimitives.scala

@@ -8,6 +8,7 @@ import Contexts._
 import Names.TermName, StdNames._
 import Types.{JavaArrayType, UnspecifiedErrorType, Type}
 import Symbols.{Symbol, NoSymbol}
+import Decorators.em
 import dotc.report
 import dotc.util.ReadOnlyMap
 
@@ -66,7 +67,7 @@ class DottyPrimitives(ictx: Context) {
       case defn.ArrayOf(el) => el
       case JavaArrayType(el) => el
       case _ =>
-        report.error(s"expected Array $tpe")
+        report.error(em"expected Array $tpe")
         UnspecifiedErrorType
     }
 
@@ -133,7 +134,7 @@ class DottyPrimitives(ictx: Context) {
     def addPrimitives(cls: Symbol, method: TermName, code: Int)(using Context): Unit = {
       val alts = cls.info.member(method).alternatives.map(_.symbol)
       if (alts.isEmpty)
-        report.error(s"Unknown primitive method $cls.$method")
+        report.error(em"Unknown primitive method $cls.$method")
       else alts foreach (s =>
         addPrimitive(s,
           s.info.paramInfoss match {

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

@@ -2926,7 +2926,7 @@ class JSCodeGen()(using genCtx: Context) {
       case defn.ArrayOf(el)  => el
       case JavaArrayType(el) => el
       case tpe =>
-        val msg = ex"expected Array $tpe"
+        val msg = em"expected Array $tpe"
         report.error(msg)
         ErrorType(msg)
     }
@@ -3652,7 +3652,7 @@ class JSCodeGen()(using genCtx: Context) {
     } else if (sym.isJSType) {
       if (sym.is(Trait)) {
         report.error(
-            s"isInstanceOf[${sym.fullName}] not supported because it is a JS trait",
+            em"isInstanceOf[${sym.fullName}] not supported because it is a JS trait",
             pos)
         js.BooleanLiteral(true)
       } else {

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)
 
@@ -309,7 +308,7 @@ final class JSExportsGen(jsCodeGen: JSCodeGen)(using Context) {
     if (isProp && methodSyms.nonEmpty) {
       val firstAlt = alts.head
       report.error(
-          i"Conflicting properties and methods for ${classSym.fullName}::$name.",
+          em"Conflicting properties and methods for ${classSym.fullName}::$name.",
           firstAlt.srcPos)
       implicit val pos = firstAlt.span
       js.JSPropertyDef(js.MemberFlags.empty, genExpr(name)(firstAlt.sourcePos), None, None)
@@ -613,7 +612,7 @@ final class JSExportsGen(jsCodeGen: JSCodeGen)(using Context) {
     val altsTypesInfo = alts.map(_.info.show).sorted.mkString("\n  ")
 
     report.error(
-        s"Cannot disambiguate overloads for $fullKind $displayName with types\n  $altsTypesInfo",
+        em"Cannot disambiguate overloads for $fullKind $displayName with types\n  $altsTypesInfo",
         pos)
   }
 

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

@@ -6,6 +6,7 @@ import java.net.{URI, URISyntaxException}
 
 import dotty.tools.dotc.core._
 import Contexts._
+import Decorators.em
 
 import dotty.tools.dotc.report
 
@@ -31,7 +32,7 @@ class JSPositions()(using Context) {
           URIMap(from, to) :: Nil
         } catch {
           case e: URISyntaxException =>
-            report.error(s"${e.getInput} is not a valid URI")
+            report.error(em"${e.getInput} is not a valid URI")
             Nil
         }
       }

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

@@ -5,6 +5,7 @@ import Names.TermName
 import Types._
 import Contexts._
 import Symbols._
+import Decorators.em
 
 import dotty.tools.dotc.ast.tpd._
 import dotty.tools.backend.jvm.DottyPrimitives
@@ -90,7 +91,7 @@ class JSPrimitives(ictx: Context) extends DottyPrimitives(ictx) {
     def addPrimitives(cls: Symbol, method: TermName, code: Int)(using Context): Unit = {
       val alts = cls.info.member(method).alternatives.map(_.symbol)
       if (alts.isEmpty) {
-        report.error(s"Unknown primitive method $cls.$method")
+        report.error(em"Unknown primitive method $cls.$method")
       } else {
         for (s <- alts)
           addPrimitive(s, code)