Refactor explanation interpolator

3 files changed, 14 insertions, 14 deletions

diff --git a/src/dotty/tools/dotc/typer/Applications.scala b/src/dotty/tools/dotc/typer/Applications.scala
index 2c9039db1..56595a637 100644
--- a/src/dotty/tools/dotc/typer/Applications.scala
+++ b/src/dotty/tools/dotc/typer/Applications.scala
@@ -27,6 +27,7 @@ import collection.mutable
 import config.Printers.{typr, unapp, overload}
 import TypeApplications._
 import language.implicitConversions
+import reporting.diagnostic.Message
 
 object Applications {
   import tpd._
@@ -132,10 +133,10 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
     protected def harmonizeArgs(args: List[TypedArg]): List[TypedArg]
 
     /** Signal failure with given message at position of given argument */
-    protected def fail(msg: => String, arg: Arg): Unit
+    protected def fail(msg: => Message, arg: Arg): Unit
 
     /** Signal failure with given message at position of the application itself */
-    protected def fail(msg: => String): Unit
+    protected def fail(msg: => Message): Unit
 
     protected def appPos: Position
 
@@ -186,7 +187,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
               // it might be healed by an implicit conversion
               assert(ctx.typerState.constraint eq savedConstraint)
             else
-              fail(err.typeMismatchStr(methType.resultType, resultType))
+              fail(err.typeMismatchMsg(methType.resultType, resultType))
         }
         // match all arguments with corresponding formal parameters
         matchArgs(orderedArgs, methType.paramTypes, 0)
@@ -388,9 +389,9 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
     def addArg(arg: TypedArg, formal: Type) =
       ok = ok & isCompatible(argType(arg, formal), formal)
     def makeVarArg(n: Int, elemFormal: Type) = {}
-    def fail(msg: => String, arg: Arg) =
+    def fail(msg: => Message, arg: Arg) =
       ok = false
-    def fail(msg: => String) =
+    def fail(msg: => Message) =
       ok = false
     def appPos = NoPosition
     lazy val normalizedFun = ref(methRef)
@@ -455,12 +456,12 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
 
     override def appPos = app.pos
 
-    def fail(msg: => String, arg: Trees.Tree[T]) = {
+    def fail(msg: => Message, arg: Trees.Tree[T]) = {
       ctx.error(msg, arg.pos)
       ok = false
     }
 
-    def fail(msg: => String) = {
+    def fail(msg: => Message) = {
       ctx.error(msg, app.pos)
       ok = false
     }
diff --git a/src/dotty/tools/dotc/typer/ErrorReporting.scala b/src/dotty/tools/dotc/typer/ErrorReporting.scala
index 8b740c3dc..1fd4fc96e 100644
--- a/src/dotty/tools/dotc/typer/ErrorReporting.scala
+++ b/src/dotty/tools/dotc/typer/ErrorReporting.scala
@@ -12,12 +12,13 @@ import printing.{Showable, RefinedPrinter}
 import scala.collection.mutable
 import java.util.regex.Matcher.quoteReplacement
 import reporting.diagnostic.Message
+import reporting.diagnostic.messages._
 
 object ErrorReporting {
 
   import tpd._
 
-  def errorTree(tree: untpd.Tree, msg: => String)(implicit ctx: Context): tpd.Tree =
+  def errorTree(tree: untpd.Tree, msg: => Message)(implicit ctx: Context): tpd.Tree =
     tree withType errorType(msg, tree.pos)
 
   def errorType(msg: => Message, pos: Position)(implicit ctx: Context): ErrorType = {
@@ -101,7 +102,7 @@ object ErrorReporting {
     def patternConstrStr(tree: Tree): String = ???
 
     def typeMismatch(tree: Tree, pt: Type, implicitFailure: SearchFailure = NoImplicitMatches): Tree =
-      errorTree(tree, typeMismatchStr(normalize(tree.tpe, pt), pt) + implicitFailure.postscript)
+      errorTree(tree, typeMismatchMsg(normalize(tree.tpe, pt), pt) /*+ implicitFailure.postscript*/)
 
     /** A subtype log explaining why `found` does not conform to `expected` */
     def whyNoMatchStr(found: Type, expected: Type) =
@@ -110,7 +111,7 @@ object ErrorReporting {
       else
         ""
 
-    def typeMismatchStr(found: Type, expected: Type) = {
+    def typeMismatchMsg(found: Type, expected: Type) = {
       // replace constrained polyparams and their typevars by their bounds where possible
       object reported extends TypeMap {
         def setVariance(v: Int) = variance = v
@@ -132,9 +133,7 @@ object ErrorReporting {
       val found1 = reported(found)
       reported.setVariance(-1)
       val expected1 = reported(expected)
-      ex"""|type mismatch:
-           |found:    $found1
-           |required: $expected1""".stripMargin + whyNoMatchStr(found, expected)
+      TypeMismatch(found1, expected1, whyNoMatchStr(found, expected))
     }
 
     /** Format `raw` implicitNotFound argument, replacing all
diff --git a/src/dotty/tools/dotc/typer/RefChecks.scala b/src/dotty/tools/dotc/typer/RefChecks.scala
index 1f150c519..4d82a2d12 100644
--- a/src/dotty/tools/dotc/typer/RefChecks.scala
+++ b/src/dotty/tools/dotc/typer/RefChecks.scala
@@ -200,7 +200,7 @@ object RefChecks {
               infoStringWithLocation(other),
               infoStringWithLocation(member))
           else if (ctx.settings.debug.value)
-            err.typeMismatchStr(memberTp, otherTp)
+            err.typeMismatchMsg(memberTp, otherTp)
           else ""
 
         "overriding %s;\n %s %s%s".format(