Drop toNoExplanation implicit conversion

`toNoExplanation` was an old-style implicit conversion. It could not be made a
`Conversion` since it was defined over a call-by-name argument. It also hid
important implementation details since it delayed constructing the argument.
So knowing whether a string would be evaluated strictly or lazily depended on
knowing how type inference would work.

We replace the conversion by a combination of

 - an extension method `.toMessage` converting a lazy string explicitly, and
 - some overloading of core methods that take either a message or a lazy string.

We should over time get rid of overloads and convert most strings passed as messges
to proper messages. But that will take time. At least by now we see better where
the work is needed.

Author: odersky

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

@@ -9,6 +9,7 @@ import scala.util.control.NonFatal
 import Contexts._, Names._, Phases._, Symbols._
 import printing.{ Printer, Showable }, printing.Formatting._, printing.Texts._
 import transform.MegaPhase
+import reporting.{Message, NoExplanation}
 
 /** This object provides useful implicit decorators for types defined elsewhere */
 object Decorators {
@@ -57,6 +58,9 @@ object Decorators {
       padding + s.replace("\n", "\n" + padding)
   end extension
 
+  extension (str: => String)
+    def toMessage: Message = reporting.NoExplanation(str)
+
   /** Implements a findSymbol method on iterators of Symbols that
    *  works like find but avoids Option, replacing None with NoSymbol.
    */

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

@@ -18,13 +18,14 @@ class TypeError(msg: String) extends Exception(msg) {
   def this() = this("")
   final def toMessage(using Context): Message =
     withMode(Mode.Printing)(produceMessage)
-  def produceMessage(using Context): Message = super.getMessage.nn
+  def produceMessage(using Context): Message = super.getMessage.nn.toMessage
   override def getMessage: String = super.getMessage.nn
 }
 
 class MalformedType(pre: Type, denot: Denotation, absMembers: Set[Name]) extends TypeError {
   override def produceMessage(using Context): Message =
     i"malformed type: $pre is not a legal prefix for $denot because it contains abstract type member${if (absMembers.size == 1) "" else "s"} ${absMembers.mkString(", ")}"
+      .toMessage
 }
 
 class MissingType(pre: Type, name: Name) extends TypeError {
@@ -38,6 +39,7 @@ class MissingType(pre: Type, name: Name) extends TypeError {
     if (ctx.debug) printStackTrace()
     i"""cannot resolve reference to type $pre.$name
        |the classfile defining the type might be missing from the classpath${otherReason(pre)}"""
+      .toMessage
   }
 }
 

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

@@ -5296,16 +5296,18 @@ object Types {
       val et = new PreviousErrorType
       ctx.base.errorTypeMsg(et) = m
       et
+    def apply(s: => String)(using Context): ErrorType =
+      apply(s.toMessage)
   end ErrorType
 
   class PreviousErrorType extends ErrorType:
     def msg(using Context): Message =
       ctx.base.errorTypeMsg.get(this) match
         case Some(m) => m
-        case None => "error message from previous run no longer available"
+        case None => "error message from previous run no longer available".toMessage
 
   object UnspecifiedErrorType extends ErrorType {
-    override def msg(using Context): Message = "unspecified error"
+    override def msg(using Context): Message = "unspecified error".toMessage
   }
 
   /* Type used to track Select nodes that could not resolve a member and their qualifier is a scala.Dynamic. */

compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala

@@ -20,6 +20,7 @@ import printing.Texts._
 import printing.Printer
 import io.AbstractFile
 import util.common._
+import util.NoSourcePosition
 import typer.Checking.checkNonCyclic
 import typer.Nullables._
 import transform.SymUtils._
@@ -744,7 +745,7 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas
       val anyTypes = boundSyms map (_ => defn.AnyType)
       val boundBounds = boundSyms map (_.info.bounds.hi)
       val tp2 = tp1.subst(boundSyms, boundBounds).subst(boundSyms, anyTypes)
-      report.warning(FailureToEliminateExistential(tp, tp1, tp2, boundSyms, classRoot.symbol))
+      report.warning(FailureToEliminateExistential(tp, tp1, tp2, boundSyms, classRoot.symbol), NoSourcePosition)
       tp2
     }
     else tp1

compiler/src/dotty/tools/dotc/inlines/Inlines.scala

@@ -155,7 +155,7 @@ object Inlines:
           tree,
           i"""|Maximal number of $reason (${setting.value}) exceeded,
               |Maybe this is caused by a recursive inline method?
-              |You can use ${setting.name} to change the limit.""",
+              |You can use ${setting.name} to change the limit.""".toMessage,
           (tree :: enclosingInlineds).last.srcPos
         )
     if ctx.base.stopInlining && enclosingInlineds.isEmpty then

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

@@ -142,14 +142,22 @@ object Parsers {
         val length = if offset == in.offset && in.name != null then in.name.show.length else 0
         syntaxError(msg, Span(offset, offset + length))
         lastErrorOffset = in.offset
-      end if
+
+    def syntaxError(msg: => String, offset: Int): Unit =
+      syntaxError(msg.toMessage, offset)
+
+    def syntaxError(msg: => String): Unit =
+      syntaxError(msg, in.offset)
 
     /** Unconditionally issue an error at given span, without
      *  updating lastErrorOffset.
      */
     def syntaxError(msg: Message, span: Span): Unit =
       report.error(msg, source.atSpan(span))
 
+    def syntaxError(msg: => String, span: Span): Unit =
+      syntaxError(msg.toMessage, span)
+
     def unimplementedExpr(using Context): Select =
       Select(Select(rootDot(nme.scala), nme.Predef), nme.???)
   }
@@ -259,9 +267,6 @@ object Parsers {
       in.skip()
       lastErrorOffset = in.offset
 
-    def warning(msg: Message, sourcePos: SourcePosition): Unit =
-      report.warning(msg, sourcePos)
-
     def warning(msg: Message, offset: Int = in.offset): Unit =
       report.warning(msg, source.atSpan(Span(offset)))
 
@@ -283,6 +288,9 @@ object Parsers {
         syntaxError(msg, offset)
         skip()
 
+    def syntaxErrorOrIncomplete(msg: => String): Unit =
+      syntaxErrorOrIncomplete(msg.toMessage, in.offset)
+
     def syntaxErrorOrIncomplete(msg: Message, span: Span): Unit =
       if in.token == EOF then
         incompleteInputError(msg)
@@ -350,7 +358,7 @@ object Parsers {
           val statFollows = mustStartStatTokens.contains(found)
           syntaxError(
             if noPrevStat then IllegalStartOfStatement(what, isModifier, statFollows)
-            else i"end of $what expected but ${showToken(found)} found")
+            else i"end of $what expected but ${showToken(found)} found".toMessage)
           if mustStartStatTokens.contains(found) then
             false // it's a statement that might be legal in an outer context
           else
@@ -610,11 +618,11 @@ object Parsers {
           if in.isNewLine && !(nextIndentWidth < startIndentWidth) then
             warning(
               if startIndentWidth <= nextIndentWidth then
-                i"""Line is indented too far to the right, or a `{` is missing before:
+                  i"""Line is indented too far to the right, or a `{` is missing before:
                    |
-                   |${t.tryToShow}"""
+                   |${t.tryToShow}""".toMessage
               else
-                in.spaceTabMismatchMsg(startIndentWidth, nextIndentWidth),
+                in.spaceTabMismatchMsg(startIndentWidth, nextIndentWidth).toMessage,
               in.next.offset
             )
           t
@@ -627,7 +635,7 @@ object Parsers {
       if in.isNewLine then
         val nextIndentWidth = in.indentWidth(in.next.offset)
         if in.currentRegion.indentWidth < nextIndentWidth then
-          warning(i"Line is indented too far to the right, or a `{` or `:` is missing", in.next.offset)
+          warning(i"Line is indented too far to the right, or a `{` or `:` is missing".toMessage, in.next.offset)
 
 /* -------- REWRITES ----------------------------------------------------------- */
 
@@ -1732,7 +1740,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")
+            deprecationWarning(em"`_` is deprecated for wildcard arguments of types: use `?` instead".toMessage)
             patch(source, Span(in.offset, in.offset + 1), "?")
           val start = in.skipToken()
           typeBounds().withSpan(Span(start, in.lastOffset, start))
@@ -2171,10 +2179,11 @@ object Parsers {
               else Literal(Constant(())) // finally without an expression
             }
             else {
-              if (handler.isEmpty) warning(
-                EmptyCatchAndFinallyBlock(body),
-                source.atSpan(Span(tryOffset, endOffset(body)))
-              )
+              if handler.isEmpty then
+                report.warning(
+                  EmptyCatchAndFinallyBlock(body),
+                  source.atSpan(Span(tryOffset, endOffset(body)))
+                )
               EmptyTree
             }
           ParsedTry(body, handler, finalizer)
@@ -2768,7 +2777,7 @@ object Parsers {
             warning(i"""Misleading indentation: this expression forms part of the preceding catch case.
                        |If this is intended, it should be indented for clarity.
                        |Otherwise, if the handler is intended to be empty, use a multi-line catch with
-                       |an indented case.""")
+                       |an indented case.""".toMessage)
           expr()
         else block()
       })
@@ -2989,7 +2998,8 @@ object Parsers {
         inBrackets {
           if in.token == THIS then
             if sourceVersion.isAtLeast(future) then
-              deprecationWarning("The [this] qualifier will be deprecated in the future; it should be dropped.")
+              deprecationWarning(
+                "The [this] qualifier will be deprecated in the future; it should be dropped.".toMessage)
             in.nextToken()
             mods | Local
           else mods.withPrivateWithin(ident().toTypeName)
@@ -3471,7 +3481,8 @@ object Parsers {
               if sourceVersion.isAtLeast(future) then
                 deprecationWarning(
                   em"""`= _` has been deprecated; use `= uninitialized` instead.
-                      |`uninitialized` can be imported with `scala.compiletime.uninitialized`.""", rhsOffset)
+                      |`uninitialized` can be imported with `scala.compiletime.uninitialized`.""".toMessage,
+                  rhsOffset)
               placeholderParams = placeholderParams.tail
               atSpan(rhs0.span) { Ident(nme.WILDCARD) }
             case rhs0 => rhs0

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

@@ -112,7 +112,7 @@ object Scanners {
 
     /** signal an error where the input ended in the middle of a token */
     def incompleteInputError(msg: String): Unit = {
-      report.incompleteInputError(msg, sourcePos())
+      report.incompleteInputError(msg.toMessage, sourcePos())
       token = EOF
       errOffset = offset
     }

compiler/src/dotty/tools/dotc/parsing/xml/MarkupParsers.scala

@@ -13,6 +13,7 @@ import Parsers._
 import util.Spans._
 import core._
 import Constants._
+import Decorators.toMessage
 import util.SourceFile
 import Utility._
 
@@ -379,7 +380,7 @@ object MarkupParsers {
           ts(0)
         }
       },
-      msg => parser.incompleteInputError(msg)
+      msg => parser.incompleteInputError(msg.toMessage)
     )
 
     /** @see xmlPattern. resynchronizes after successful parse

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

@@ -18,23 +18,35 @@ object report:
     if ctx.settings.verbose.value then echo(msg, pos)
 
   def echo(msg: => String, pos: SrcPos = NoSourcePosition)(using Context): Unit =
-    ctx.reporter.report(new Info(msg, pos.sourcePos))
+    ctx.reporter.report(new Info(msg.toMessage, pos.sourcePos))
 
   private def issueWarning(warning: Warning)(using Context): Unit =
     ctx.reporter.report(warning)
 
-  def deprecationWarning(msg: Message, pos: SrcPos = NoSourcePosition)(using Context): Unit =
+  def deprecationWarning(msg: Message, pos: SrcPos)(using Context): Unit =
     issueWarning(new DeprecationWarning(msg, pos.sourcePos))
 
-  def migrationWarning(msg: Message, pos: SrcPos = NoSourcePosition)(using Context): Unit =
+  def deprecationWarning(msg: => String, pos: SrcPos)(using Context): Unit =
+    deprecationWarning(msg.toMessage, pos)
+
+  def migrationWarning(msg: Message, pos: SrcPos)(using Context): Unit =
     issueWarning(new MigrationWarning(msg, pos.sourcePos))
 
-  def uncheckedWarning(msg: Message, pos: SrcPos = NoSourcePosition)(using Context): Unit =
+  def migrationWarning(msg: => String, pos: SrcPos)(using Context): Unit =
+    migrationWarning(msg.toMessage, pos)
+
+  def uncheckedWarning(msg: Message, pos: SrcPos)(using Context): Unit =
     issueWarning(new UncheckedWarning(msg, pos.sourcePos))
 
-  def featureWarning(msg: Message, pos: SrcPos = NoSourcePosition)(using Context): Unit =
+  def uncheckedWarning(msg: => String, pos: SrcPos)(using Context): Unit =
+    uncheckedWarning(msg.toMessage, pos)
+
+  def featureWarning(msg: Message, pos: SrcPos)(using Context): Unit =
     issueWarning(new FeatureWarning(msg, pos.sourcePos))
 
+  def featureWarning(msg: => String, pos: SrcPos)(using Context): Unit =
+    featureWarning(msg.toMessage, pos)
+
   def featureWarning(feature: String, featureDescription: => String,
       featureUseSite: Symbol, required: Boolean, pos: SrcPos)(using Context): Unit = {
     val req = if (required) "needs to" else "should"
@@ -52,30 +64,43 @@ object report:
                  |by adding the import clause 'import $fqname'
                  |or by setting the compiler option -language:$feature.$explain""".stripMargin
     if (required) error(msg, pos)
-    else issueWarning(new FeatureWarning(msg, pos.sourcePos))
+    else issueWarning(new FeatureWarning(msg.toMessage, pos.sourcePos))
   }
 
-  def warning(msg: Message, pos: SrcPos = NoSourcePosition)(using Context): Unit =
+  def warning(msg: Message, pos: SrcPos)(using Context): Unit =
     issueWarning(new Warning(msg, addInlineds(pos)))
 
-  def error(msg: Message, pos: SrcPos = NoSourcePosition, sticky: Boolean = false)(using Context): Unit =
+  def warning(msg: => String, pos: SrcPos = NoSourcePosition)(using Context): Unit =
+    warning(msg.toMessage, pos)
+
+  def error(msg: Message, pos: SrcPos)(using Context): Unit =
     val fullPos = addInlineds(pos)
-    ctx.reporter.report(if (sticky) new StickyError(msg, fullPos) else new Error(msg, fullPos))
+    ctx.reporter.report(new Error(msg, fullPos))
     if ctx.settings.YdebugError.value then Thread.dumpStack()
 
+  def error(msg: => String, pos: SrcPos = NoSourcePosition)(using Context): Unit =
+    error(msg.toMessage, pos)
+
   def error(ex: TypeError, pos: SrcPos)(using Context): Unit =
-    error(ex.toMessage, pos, sticky = true)
-    if ctx.settings.YdebugTypeError.value then ex.printStackTrace()
+    val fullPos = addInlineds(pos)
+    ctx.reporter.report(new StickyError(ex.toMessage, fullPos))
+    if ctx.settings.YdebugError.value then Thread.dumpStack()
 
-  def errorOrMigrationWarning(msg: Message, pos: SrcPos = NoSourcePosition, from: SourceVersion)(using Context): Unit =
+  def errorOrMigrationWarning(msg: Message, pos: SrcPos, from: SourceVersion)(using Context): Unit =
     if sourceVersion.isAtLeast(from) then
       if sourceVersion.isMigrating && sourceVersion.ordinal <= from.ordinal then migrationWarning(msg, pos)
       else error(msg, pos)
 
-  def gradualErrorOrMigrationWarning(msg: Message, pos: SrcPos = NoSourcePosition, warnFrom: SourceVersion, errorFrom: SourceVersion)(using Context): Unit =
+  def errorOrMigrationWarning(msg: => String, pos: SrcPos, from: SourceVersion)(using Context): Unit =
+    errorOrMigrationWarning(msg.toMessage, pos, from)
+
+  def gradualErrorOrMigrationWarning(msg: Message, pos: SrcPos, warnFrom: SourceVersion, errorFrom: SourceVersion)(using Context): Unit =
     if sourceVersion.isAtLeast(errorFrom) then errorOrMigrationWarning(msg, pos, errorFrom)
     else if sourceVersion.isAtLeast(warnFrom) then warning(msg, pos)
 
+  def gradualErrorOrMigrationWarning(msg: => String, pos: SrcPos, warnFrom: SourceVersion, errorFrom: SourceVersion)(using Context): Unit =
+    gradualErrorOrMigrationWarning(msg.toMessage, pos, warnFrom, errorFrom)
+
   def restrictionError(msg: Message, pos: SrcPos = NoSourcePosition)(using Context): Unit =
     error(msg.mapMsg("Implementation restriction: " + _), pos)
 

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

@@ -11,6 +11,7 @@ import dotty.tools.dotc.util.SourcePosition
 
 import java.util.Optional
 import scala.util.chaining._
+import core.Decorators.toMessage
 
 object Diagnostic:
 
@@ -23,7 +24,8 @@ object Diagnostic:
   class Error(
     msg: Message,
     pos: SourcePosition
-  ) extends Diagnostic(msg, pos, ERROR)
+  ) extends Diagnostic(msg, pos, ERROR):
+    def this(str: => String, pos: SourcePosition) = this(str.toMessage, pos)
 
   /** A sticky error is an error that should not be hidden by backtracking and
    *  trying some alternative path. Typically, errors issued after catching
@@ -46,7 +48,8 @@ object Diagnostic:
   class Info(
     msg: Message,
     pos: SourcePosition
-  ) extends Diagnostic(msg, pos, INFO)
+  ) extends Diagnostic(msg, pos, INFO):
+    def this(str: => String, pos: SourcePosition) = this(str.toMessage, pos)
 
   abstract class ConditionalWarning(
     msg: Message,