Turn more strings into messages

In particular: The missingArg message of ImplicitSearchError becomes a
regular Message now.

Author: odersky

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

@@ -442,8 +442,7 @@ object Inlines:
               val evidence = evTyper.inferImplicitArg(tpt.tpe, tpt.span)
               evidence.tpe match
                 case fail: Implicits.SearchFailureType =>
-                  val msg = evTyper.missingArgMsg(evidence, tpt.tpe, "")
-                  errorTree(call, em"$msg")
+                  errorTree(call, evTyper.missingArgMsg(evidence, tpt.tpe, ""))
                 case _ =>
                   evidence
             }

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

@@ -185,6 +185,8 @@ enum ErrorMessageID(val isActive: Boolean = true) extends java.lang.Enum[ErrorMe
   case TargetNameOnTopLevelClassID // errorNumber: 169
   case NotClassTypeID // errorNumber 170
   case MissingArgumentID // errorNumer 171
+  case MissingImplicitArgumentID // errorNumber 172
+  case CannotBeAccessedID // errorNumber 173
 
   def errorNumber = ordinal - 1
 

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

@@ -133,6 +133,9 @@ abstract class Message(val errorId: ErrorMessageID)(using Context) { self =>
     def explain    = self.explain ++ suffix
     override def canExplain = true
 
+  def wrap(header: => String, trailer: => String): Message =
+    mapMsg(s => header ++ s ++ trailer)
+
   /** Override with `true` for messages that should always be shown even if their
    *  position overlaps another messsage of a different class. On the other hand
    *  multiple messages of the same class with overlapping positions will lead
@@ -144,7 +147,7 @@ abstract class Message(val errorId: ErrorMessageID)(using Context) { self =>
 }
 
 /** The fallback `Message` containing no explanation and having no `kind` */
-class NoExplanation(msgFn: => String)(using Context) extends Message(ErrorMessageID.NoExplanationID) {
+final class NoExplanation(msgFn: => String)(using Context) extends Message(ErrorMessageID.NoExplanationID) {
   def msg: String = msgFn
   def explain: String = ""
   val kind: MessageKind = MessageKind.NoKind

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

@@ -246,10 +246,10 @@ class PCPCheckAndHeal(@constructorOnly ictx: Context) extends TreeMapWithStages(
         checkStable(tp, pos, "type witness")
         getQuoteTypeTags.getTagRef(tp)
       case _: SearchFailureType =>
-        report.error(i"""Reference to $tp within quotes requires a given $reqType in scope.
-                     |${ctx.typer.missingArgMsg(tag, reqType, "")}
-                     |
-                     |""", pos)
+        report.error(
+          ctx.typer.missingArgMsg(tag, reqType, "").wrap(
+            i"Reference to $tp within quotes requires a given $reqType in scope.\n", "\n"),
+            pos)
         tp
       case _ =>
         report.error(i"""Reference to $tp within quotes requires a given $reqType in scope.

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

@@ -478,7 +478,7 @@ trait Applications extends Compatibility {
         matchArgs(orderedArgs, methType.paramInfos, 0)
       case _ =>
         if (methType.isError) ok = false
-        else fail(s"$methString does not take parameters".toMessage)
+        else fail(em"$methString does not take parameters")
     }
 
     /** The application was successful */
@@ -518,10 +518,10 @@ trait Applications extends Compatibility {
               else { // name not (or no longer) available for named arg
                 def msg =
                   if (methodType.paramNames contains aname)
-                    s"parameter $aname of $methString is already instantiated"
+                    em"parameter $aname of $methString is already instantiated"
                   else
-                    s"$methString does not have a parameter $aname"
-                fail(msg.toMessage, arg.asInstanceOf[Arg])
+                    em"$methString does not have a parameter $aname"
+                fail(msg, arg.asInstanceOf[Arg])
                 arg :: handleNamed(pnamesRest, args1, nameToArg, toDrop)
               }
             case arg :: args1 =>
@@ -647,10 +647,10 @@ trait Applications extends Compatibility {
               def msg = arg match
                 case untpd.Tuple(Nil)
                 if applyKind == ApplyKind.InfixTuple && funType.widen.isNullaryMethod =>
-                  i"can't supply unit value with infix notation because nullary $methString takes no arguments; use dotted invocation instead: (...).${methRef.name}()"
+                  em"can't supply unit value with infix notation because nullary $methString takes no arguments; use dotted invocation instead: (...).${methRef.name}()"
                 case _ =>
-                  i"too many arguments for $methString"
-              fail(msg.toMessage, arg)
+                  em"too many arguments for $methString"
+              fail(msg, arg)
             case nil =>
           }
       }

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

@@ -843,9 +843,9 @@ trait Checking {
               case Select(id, _) => id
               case _ => EmptyTree
           if extractor.isEmpty then
-            e"pattern binding uses refutable extractor"
+            i"pattern binding uses refutable extractor"
           else
-            e"pattern binding uses refutable extractor `$extractor`"
+            i"pattern binding uses refutable extractor `$extractor`"
 
       val fix =
         if isPatDef then "adding `: @unchecked` after the expression"

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

@@ -10,11 +10,9 @@ import Trees._
 import NameOps._
 import util.SrcPos
 import config.Feature
-import java.util.regex.Matcher.quoteReplacement
 import reporting._
 import collection.mutable
 
-import scala.util.matching.Regex
 
 object ErrorReporting {
 
@@ -87,18 +85,18 @@ object ErrorReporting {
 
     def expectedTypeStr(tp: Type): String = tp match {
       case tp: PolyProto =>
-        e"type arguments [${tp.targs.tpes}%, %] and ${expectedTypeStr(revealDeepenedArgs(tp.resultType))}"
+        i"type arguments [${tp.targs.tpes}%, %] and ${expectedTypeStr(revealDeepenedArgs(tp.resultType))}"
       case tp: FunProto =>
         def argStr(tp: FunProto): String =
           val result = revealDeepenedArgs(tp.resultType) match {
             case restp: FunProto => argStr(restp)
             case _: WildcardType | _: IgnoredProto => ""
-            case tp => e" and expected result type $tp"
+            case tp => i" and expected result type $tp"
           }
-          e"(${tp.typedArgs().tpes}%, %)$result"
+          i"(${tp.typedArgs().tpes}%, %)$result"
         s"arguments ${argStr(tp)}"
       case _ =>
-        e"expected type $tp"
+        i"expected type $tp"
     }
 
     def anonymousTypeMemberStr(tpe: Type): String = {
@@ -107,12 +105,12 @@ object ErrorReporting {
         case _: MethodOrPoly => "method"
         case _ => "value of type"
       }
-      e"$kind $tpe"
+      i"$kind $tpe"
     }
 
     def overloadedAltsStr(alts: List[SingleDenotation]): String =
-      e"overloaded alternatives of ${denotStr(alts.head)} with types\n" +
-      e" ${alts map (_.info)}%\n %"
+      i"""overloaded alternatives of ${denotStr(alts.head)} with types
+         | ${alts map (_.info)}%\n %"""
 
     def denotStr(denot: Denotation): String =
       if (denot.isOverloaded) overloadedAltsStr(denot.alternatives)
@@ -263,195 +261,3 @@ object ErrorReporting {
 
   def err(using Context): Errors = new Errors
 }
-
-class ImplicitSearchError(
-  arg: tpd.Tree,
-  pt: Type,
-  where: String,
-  paramSymWithMethodCallTree: Option[(Symbol, tpd.Tree)] = None,
-  ignoredInstanceNormalImport: => Option[SearchSuccess],
-  importSuggestionAddendum: => String
-)(using ctx: Context) {
-
-  def missingArgMsg = arg.tpe match {
-    case ambi: AmbiguousImplicits =>
-      (ambi.alt1, ambi.alt2) match {
-        case (alt @ AmbiguousImplicitMsg(msg), _) =>
-          userDefinedAmbiguousImplicitMsg(alt, msg)
-        case (_, alt @ AmbiguousImplicitMsg(msg)) =>
-          userDefinedAmbiguousImplicitMsg(alt, msg)
-        case _ =>
-          defaultAmbiguousImplicitMsg(ambi)
-      }
-    case ambi @ TooUnspecific(target) =>
-      ex"""No implicit search was attempted${location("for")}
-          |since the expected type $target is not specific enough"""
-    case _ =>
-      val shortMessage = userDefinedImplicitNotFoundParamMessage
-        .orElse(userDefinedImplicitNotFoundTypeMessage)
-        .getOrElse(defaultImplicitNotFoundMessage)
-      formatMsg(shortMessage)()
-      ++ hiddenImplicitsAddendum
-      ++ ErrorReporting.matchReductionAddendum(pt)
-  }
-
-  private def formatMsg(shortForm: String)(headline: String = shortForm) = arg match
-    case arg: Trees.SearchFailureIdent[?] =>
-      arg.tpe match
-        case _: NoMatchingImplicits => headline
-        case tpe: SearchFailureType =>
-          i"$headline. ${tpe.explanation}"
-        case _ => headline
-    case _ =>
-      arg.tpe match
-        case tpe: SearchFailureType =>
-          val original = arg match
-            case Inlined(call, _, _) => call
-            case _ => arg
-          i"""$headline.
-            |I found:
-            |
-            |    ${original.show.replace("\n", "\n    ")}
-            |
-            |But ${tpe.explanation}."""
-        case _ => headline
-
-  /** Format `raw` implicitNotFound or implicitAmbiguous argument, replacing
-   *  all occurrences of `${X}` where `X` is in `paramNames` with the
-   *  corresponding shown type in `args`.
-   */
-  private def userDefinedErrorString(raw: String, paramNames: List[String], args: List[Type]): String = {
-    def translate(name: String): Option[String] = {
-      val idx = paramNames.indexOf(name)
-      if (idx >= 0) Some(ex"${args(idx)}") else None
-    }
-
-    """\$\{\s*([^}\s]+)\s*\}""".r.replaceAllIn(raw, (_: Regex.Match) match {
-      case Regex.Groups(v) => quoteReplacement(translate(v).getOrElse("")).nn
-    })
-  }
-
-  /** Extract a user defined error message from a symbol `sym`
-   *  with an annotation matching the given class symbol `cls`.
-   */
-  private def userDefinedMsg(sym: Symbol, cls: Symbol) = for {
-    ann <- sym.getAnnotation(cls)
-    msg <- ann.argumentConstantString(0)
-  } yield msg
-
-  private def location(preposition: String) = if (where.isEmpty) "" else s" $preposition $where"
-
-  private def defaultAmbiguousImplicitMsg(ambi: AmbiguousImplicits) =
-    s"Ambiguous given instances: ${ambi.explanation}${location("of")}"
-
-  private def defaultImplicitNotFoundMessage =
-    ex"No given instance of type $pt was found${location("for")}"
-
-  /** Construct a custom error message given an ambiguous implicit
-   *  candidate `alt` and a user defined message `raw`.
-   */
-  private def userDefinedAmbiguousImplicitMsg(alt: SearchSuccess, raw: String) = {
-    val params = alt.ref.underlying match {
-      case p: PolyType => p.paramNames.map(_.toString)
-      case _           => Nil
-    }
-    def resolveTypes(targs: List[tpd.Tree])(using Context) =
-      targs.map(a => Inferencing.fullyDefinedType(a.tpe, "type argument", a.srcPos))
-
-    // We can extract type arguments from:
-    //   - a function call:
-    //     @implicitAmbiguous("msg A=${A}")
-    //     implicit def f[A](): String = ...
-    //     implicitly[String] // found: f[Any]()
-    //
-    //   - an eta-expanded function:
-    //     @implicitAmbiguous("msg A=${A}")
-    //     implicit def f[A](x: Int): String = ...
-    //     implicitly[Int => String] // found: x => f[Any](x)
-
-    val call = tpd.closureBody(alt.tree) // the tree itself if not a closure
-    val targs = tpd.typeArgss(call).flatten
-    val args = resolveTypes(targs)(using ctx.fresh.setTyperState(alt.tstate))
-    userDefinedErrorString(raw, params, args)
-  }
-
-  /** @param rawMsg           Message template with variables, e.g. "Variable A is ${A}"
-   *  @param sym              Symbol of the annotated type or of the method whose parameter was annotated
-   *  @param substituteType   Function substituting specific types for abstract types associated with variables, e.g A -> Int
-   */
-  private def formatAnnotationMessage(rawMsg: String, sym: Symbol, substituteType: Type => Type): String = {
-    val substitutableTypesSymbols = ErrorReporting.substitutableTypeSymbolsInScope(sym)
-
-    userDefinedErrorString(
-      rawMsg,
-      paramNames = substitutableTypesSymbols.map(_.name.unexpandedName.toString),
-      args = substitutableTypesSymbols.map(_.typeRef).map(substituteType)
-    )
-  }
-
-  /** Extracting the message from a method parameter, e.g. in
-   *
-   *  trait Foo
-   *
-   *  def foo(implicit @annotation.implicitNotFound("Foo is missing") foo: Foo): Any = ???
-   */
-  private def userDefinedImplicitNotFoundParamMessage: Option[String] = paramSymWithMethodCallTree.flatMap { (sym, applTree) =>
-    userDefinedMsg(sym, defn.ImplicitNotFoundAnnot).map { rawMsg =>
-      val fn = tpd.funPart(applTree)
-      val targs = tpd.typeArgss(applTree).flatten
-      val methodOwner = fn.symbol.owner
-      val methodOwnerType = tpd.qualifier(fn).tpe
-      val methodTypeParams = fn.symbol.paramSymss.flatten.filter(_.isType)
-      val methodTypeArgs = targs.map(_.tpe)
-      val substituteType = (_: Type).asSeenFrom(methodOwnerType, methodOwner).subst(methodTypeParams, methodTypeArgs)
-      formatAnnotationMessage(rawMsg, sym.owner, substituteType)
-    }
-  }
-
-  /** Extracting the message from a type, e.g. in
-   *
-   *  @annotation.implicitNotFound("Foo is missing")
-   *  trait Foo
-   *
-   *  def foo(implicit foo: Foo): Any = ???
-   */
-  private def userDefinedImplicitNotFoundTypeMessage: Option[String] =
-    def recur(tp: Type): Option[String] = tp match
-      case tp: TypeRef =>
-        val sym = tp.symbol
-        userDefinedImplicitNotFoundTypeMessage(sym).orElse(recur(tp.info))
-      case tp: ClassInfo =>
-        tp.baseClasses.iterator
-          .map(userDefinedImplicitNotFoundTypeMessage)
-          .find(_.isDefined).flatten
-      case tp: TypeProxy =>
-        recur(tp.superType)
-      case tp: AndType =>
-        recur(tp.tp1).orElse(recur(tp.tp2))
-      case _ =>
-        None
-    recur(pt)
-
-  private def userDefinedImplicitNotFoundTypeMessage(sym: Symbol): Option[String] =
-    for
-      rawMsg <- userDefinedMsg(sym, defn.ImplicitNotFoundAnnot)
-      if Feature.migrateTo3 || sym != defn.Function1
-        // Don't inherit "No implicit view available..." message if subtypes of Function1 are not treated as implicit conversions anymore
-    yield
-      val substituteType = (_: Type).asSeenFrom(pt, sym)
-      formatAnnotationMessage(rawMsg, sym, substituteType)
-
-  private def hiddenImplicitsAddendum: String =
-    def hiddenImplicitNote(s: SearchSuccess) =
-      e"\n\nNote: ${s.ref.symbol.showLocated} was not considered because it was not imported with `import given`."
-
-    val normalImports = ignoredInstanceNormalImport.map(hiddenImplicitNote)
-
-    normalImports.getOrElse(importSuggestionAddendum)
-  end hiddenImplicitsAddendum
-
-  private object AmbiguousImplicitMsg {
-    def unapply(search: SearchSuccess): Option[String] =
-      userDefinedMsg(search.ref.symbol, defn.ImplicitAmbiguousAnnot)
-  }
-}