Make relevant parts of compiler conform to new error handling

Author: felixmulder

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

@@ -27,9 +27,8 @@ import rewrite.Rewrites.patch
 object Parsers {
 
   import ast.untpd._
-  import reporting.diagnostic.MessageCreator
-  import MessageCreator._
-  import reporting.diagnostic.syntax._
+  import reporting.diagnostic.Message
+  import reporting.diagnostic.messages._
 
   case class OpInfo(operand: Tree, operator: Name, offset: Offset)
 
@@ -100,17 +99,17 @@ object Parsers {
     /** Issue an error at given offset if beyond last error offset
       *  and update lastErrorOffset.
       */
-    def syntaxError(expl: MessageCreator, offset: Int = in.offset): Unit =
+    def syntaxError(msg: Message, offset: Int = in.offset): Unit =
       if (offset > lastErrorOffset) {
-        syntaxError(expl, Position(offset))
+        syntaxError(msg, Position(offset))
         lastErrorOffset = in.offset
       }
 
     /** Unconditionally issue an error at given position, without
       *  updating lastErrorOffset.
       */
-    def syntaxError(expl: MessageCreator, pos: Position): Unit =
-      ctx.explainError(expl, source atPos pos)
+    def syntaxError(msg: Message, pos: Position): Unit =
+      ctx.error(msg, source atPos pos)
 
   }
 
@@ -216,20 +215,20 @@ object Parsers {
       }
     }
 
-    def warning(msg: MessageCreator, offset: Int = in.offset) =
-      ctx.explainWarning(msg, source atPos Position(offset))
+    def warning(msg: Message, offset: Int = in.offset) =
+      ctx.warning(msg, source atPos Position(offset))
 
-    def deprecationWarning(msg: String, offset: Int = in.offset) =
+    def deprecationWarning(msg: Message, offset: Int = in.offset) =
       ctx.deprecationWarning(msg, source atPos Position(offset))
 
     /** Issue an error at current offset taht input is incomplete */
-    def incompleteInputError(msg: String) =
+    def incompleteInputError(msg: Message) =
       ctx.incompleteInputError(msg, source atPos Position(in.offset))
 
     /** If at end of file, issue an incompleteInputError.
      *  Otherwise issue a syntax error and skip to next safe point.
      */
-    def syntaxErrorOrIncomplete(msg: String) =
+    def syntaxErrorOrIncomplete(msg: Message) =
       if (in.token == EOF) incompleteInputError(msg)
       else {
         syntaxError(msg)

src/dotty/tools/dotc/printing/Formatting.scala

@@ -8,7 +8,7 @@ import collection.Map
 import Decorators._
 import scala.annotation.switch
 import scala.util.control.NonFatal
-import reporting.diagnostic.Message
+import reporting.diagnostic.MessageContainer
 
 object Formatting {
 
@@ -67,6 +67,7 @@ object Formatting {
    */
   class ErrorMessageFormatter(sc: StringContext) extends StringFormatter(sc) {
     override protected def showArg(arg: Any)(implicit ctx: Context): String = {
+      import MessageContainer._
       def isSensical(arg: Any): Boolean = arg match {
         case tpe: Type =>
           tpe.exists && !tpe.isErroneous
@@ -76,7 +77,7 @@ object Formatting {
       }
       val str = super.showArg(arg)
       if (isSensical(arg)) str
-      else Message.nonSensicalStartTag + str + Message.nonSensicalEndTag
+      else nonSensicalStartTag + str + nonSensicalEndTag
     }
   }
 

src/dotty/tools/dotc/reporting/ConsoleReporter.scala

@@ -9,18 +9,19 @@ import Reporter._
 import java.io.{ BufferedReader, IOException, PrintWriter }
 import scala.reflect.internal.util._
 import diagnostic.Message
+import diagnostic.MessageContainer
 import diagnostic.messages._
 
 /**
  * This class implements a Reporter that displays messages on a text
  * console.
  */
 class ConsoleReporter(
-    reader: BufferedReader = Console.in,
-    writer: PrintWriter = new PrintWriter(Console.err, true))
-  extends Reporter with UniqueMessagePositions with HideNonSensicalMessages {
+  reader: BufferedReader = Console.in,
+  writer: PrintWriter = new PrintWriter(Console.err, true)
+) extends Reporter with UniqueMessagePositions with HideNonSensicalMessages {
 
-  import Message._
+  import MessageContainer._
 
   /** maximal number of error messages to be printed */
   protected def ErrorLimit = 100
@@ -35,9 +36,9 @@ class ConsoleReporter(
   def printMessage(msg: String): Unit = { writer.print(msg + "\n"); writer.flush() }
 
   /** Prints the message with the given position indication. */
-  def printMessageAndPos(msg: String, pos: SourcePosition, kind: String = "")(implicit ctx: Context): Unit = {
+  def printMessageAndPos(msg: Message, pos: SourcePosition, kind: String)(implicit ctx: Context): Unit = {
     val posStr = if (pos.exists) s"$pos: " else ""
-    printMessage(s"${posStr}$kind: $msg")
+    printMessage(s"${posStr}${kind}: ${msg.msg}")
     if (pos.exists) {
       printSourceLine(pos)
       printColumnMarker(pos)
@@ -52,21 +53,21 @@ class ConsoleReporter(
           |${m.explanation}""".stripMargin
     )
 
-  override def doReport(m: Message)(implicit ctx: Context): Unit = {
+  override def doReport(m: MessageContainer)(implicit ctx: Context): Unit = {
     m match {
       case m: Error =>
-        printMessageAndPos(m.message, m.pos, m.kind)
+        printMessageAndPos(m.contained, m.pos, m.kind)
         if (ctx.settings.prompt.value) displayPrompt()
       case m: ConditionalWarning if !m.enablingOption.value =>
       case m: MigrationWarning =>
-        printMessageAndPos(m.message, m.pos, m.kind)
+        printMessageAndPos(m.contained, m.pos, m.kind)
       case m: Warning =>
-        printMessageAndPos(m.message, m.pos, m.kind)
+        printMessageAndPos(m.contained, m.pos, m.kind)
       case _ =>
-        printMessageAndPos(m.message, m.pos, m.kind)
+        printMessageAndPos(m.contained, m.pos, m.kind)
     }
 
-    if (ctx.shouldExplain(m)) printExplanation(m)
+    if (ctx.shouldExplain(m)) printExplanation(m.contained)
   }
 
   def displayPrompt(): Unit = {

src/dotty/tools/dotc/reporting/FancyConsoleReporter.scala

@@ -73,15 +73,15 @@ class FancyConsoleReporter(
     }).show else ""
 
   /** Prints the message with the given position indication. */
-  override def printMessageAndPos(msg: String, pos: SourcePosition, kind: String = "")(implicit ctx: Context): Unit = {
+  override def printMessageAndPos(msg: Message, pos: SourcePosition, kind: String)(implicit ctx: Context): Unit = {
     printMessage(posStr(pos, kind))
     if (pos.exists) {
       val (src, offset) = sourceLine(pos)
       val marker = columnMarker(pos, offset)
-      val err = errorMsg(pos, msg, offset)
+      val err = errorMsg(pos, msg.msg, offset)
 
       printMessage(List(src, marker, err).mkString("\n"))
-    } else printMessage(msg)
+    } else printMessage(msg.msg)
   }
 
   override def printExplanation(m: Message)(implicit ctx: Context): Unit = {
@@ -90,16 +90,4 @@ class FancyConsoleReporter(
                       |${Blue("===========")}""".stripMargin)
     printMessage(m.explanation)
   }
-
-
-  //override def summary(implicit ctx: Context): String = {
-  //  val b = new mutable.ListBuffer[String]
-  //  if (warningCount > 0)
-  //    b += countString(warningCount, Yellow("warning").show) + " found"
-  //  if (errorCount > 0)
-  //    b += countString(errorCount, Red("error").show) + " found"
-  //  for ((settingName, count) <- unreportedWarnings)
-  //    b += s"there were $count ${settingName.tail} ${Yellow("warning(s)").show}; re-run with $settingName for details"
-  //  b.mkString("\n")
-  //}
 }

src/dotty/tools/dotc/reporting/HideNonSensicalMessages.scala

@@ -3,7 +3,7 @@ package dotc
 package reporting
 
 import core.Contexts.Context
-import diagnostic.Message
+import diagnostic.MessageContainer
 
 /**
  * This trait implements `isHidden` so that we avoid reporting non-sensical messages.
@@ -12,7 +12,7 @@ trait HideNonSensicalMessages extends Reporter {
   /** Hides non-sensical messages, unless we haven't reported any error yet or
    *  `-Yshow-suppressed-errors` is set.
    */
-  override def isHidden(m: Message)(implicit ctx: Context): Boolean =
+  override def isHidden(m: MessageContainer)(implicit ctx: Context): Boolean =
     super.isHidden(m) || {
         m.isNonSensical &&
         hasErrors && // if there are no errors yet, report even if diagnostic is non-sensical

src/dotty/tools/dotc/reporting/Reporter.scala

@@ -12,13 +12,13 @@ import core.Mode
 import dotty.tools.dotc.core.Symbols.Symbol
 import diagnostic.messages._
 import diagnostic._
-import MessageCreator._
+import Message._
 
 object Reporter {
   /** Convert a SimpleReporter into a real Reporter */
   def fromSimpleReporter(simple: interfaces.SimpleReporter): Reporter =
     new Reporter with UniqueMessagePositions with HideNonSensicalMessages {
-      override def doReport(m: Message)(implicit ctx: Context): Unit = m match {
+      override def doReport(m: MessageContainer)(implicit ctx: Context): Unit = m match {
         case m: ConditionalWarning if !m.enablingOption.value =>
         case _ =>
           simple.report(m)
@@ -37,17 +37,17 @@ trait Reporting { this: Context =>
   def echo(msg: => String, pos: SourcePosition = NoSourcePosition): Unit =
     reporter.report(new Info(msg, pos, "Info"))
 
-  def deprecationWarning(msg: => String, pos: SourcePosition = NoSourcePosition): Unit =
-    reporter.report(new DeprecationWarning(msg, pos, "Deprecation Warning"))
+  def deprecationWarning(msg: => Message, pos: SourcePosition = NoSourcePosition): Unit =
+    reporter.report(msg.deprecationWarning(pos))
 
-  def migrationWarning(msg: => String, pos: SourcePosition = NoSourcePosition): Unit =
-    reporter.report(new MigrationWarning(msg, pos, "Migration Warning"))
+  def migrationWarning(msg: => Message, pos: SourcePosition = NoSourcePosition): Unit =
+    reporter.report(msg.migrationWarning(pos))
 
-  def uncheckedWarning(msg: => String, pos: SourcePosition = NoSourcePosition): Unit =
-    reporter.report(new UncheckedWarning(msg, pos, "Unchecked Warning"))
+  def uncheckedWarning(msg: => Message, pos: SourcePosition = NoSourcePosition): Unit =
+    reporter.report(msg.uncheckedWarning(pos))
 
-  def featureWarning(msg: => String, pos: SourcePosition = NoSourcePosition): Unit =
-    reporter.report(new FeatureWarning(msg, pos, "Feature Warning"))
+  def featureWarning(msg: => Message, pos: SourcePosition = NoSourcePosition): Unit =
+    reporter.report(msg.featureWarning(pos))
 
   def featureWarning(feature: String, featureDescription: String, isScala2Feature: Boolean,
       featureUseSite: Symbol, required: Boolean, pos: SourcePosition): Unit = {
@@ -72,32 +72,24 @@ trait Reporting { this: Context =>
     else reporter.report(new FeatureWarning(msg, pos))
   }
 
-  def warning(msg: => String, pos: SourcePosition = NoSourcePosition): Unit =
-    reporter.report(new Warning(msg, pos))
-
-  def explainWarning(msg: => MessageCreator, pos: SourcePosition = NoSourcePosition): Unit =
+  def warning(msg: => Message, pos: SourcePosition = NoSourcePosition): Unit =
     reporter.report(msg.warning(pos))
 
-  def strictWarning(msg: => String, pos: SourcePosition = NoSourcePosition): Unit =
+  def strictWarning(msg: => Message, pos: SourcePosition = NoSourcePosition): Unit =
     if (this.settings.strict.value) error(msg, pos)
-    else warning(msg + "\n(This would be an error under strict mode)", pos)
-
-  def error(msg: => String, pos: SourcePosition = NoSourcePosition): Unit = {
-    // println("*** ERROR: " + msg) // !!! DEBUG
-    reporter.report(new Error(msg, pos))
-  }
+    else warning(msg.mapMsg(_ + "\n(This would be an error under strict mode)"), pos)
 
-  def explainError(msg: => MessageCreator, pos: SourcePosition = NoSourcePosition): Unit =
+  def error(msg: => Message, pos: SourcePosition = NoSourcePosition): Unit =
     reporter.report(msg.error(pos))
 
-  def errorOrMigrationWarning(msg: => String, pos: SourcePosition = NoSourcePosition): Unit =
+  def errorOrMigrationWarning(msg: => Message, pos: SourcePosition = NoSourcePosition): Unit =
     if (ctx.scala2Mode) migrationWarning(msg, pos) else error(msg, pos)
 
-  def restrictionError(msg: => String, pos: SourcePosition = NoSourcePosition): Unit =
-    error(s"Implementation restriction: $msg", pos)
+  def restrictionError(msg: => Message, pos: SourcePosition = NoSourcePosition): Unit =
+    error(msg.mapMsg(m => s"Implementation restriction: $m"), pos)
 
-  def incompleteInputError(msg: String, pos: SourcePosition = NoSourcePosition)(implicit ctx: Context): Unit =
-    reporter.incomplete(new Error(msg, pos))(ctx)
+  def incompleteInputError(msg: Message, pos: SourcePosition = NoSourcePosition)(implicit ctx: Context): Unit =
+    reporter.incomplete(msg.error(pos))(ctx)
 
   /** Log msg if settings.log contains the current phase.
    *  See [[config.CompilerCommand#explainAdvanced]] for the exact meaning of
@@ -184,7 +176,7 @@ trait Reporting { this: Context =>
 abstract class Reporter extends interfaces.ReporterResult {
 
   /** Report a diagnostic */
-  def doReport(d: Message)(implicit ctx: Context): Unit
+  def doReport(d: MessageContainer)(implicit ctx: Context): Unit
 
   /** Whether very long lines can be truncated.  This exists so important
    *  debugging information (like printing the classpath) is not rendered
@@ -199,7 +191,7 @@ abstract class Reporter extends interfaces.ReporterResult {
     finally _truncationOK = saved
   }
 
-  type ErrorHandler = Message => Context => Unit
+  type ErrorHandler = MessageContainer => Context => Unit
   private var incompleteHandler: ErrorHandler = d => c => report(d)(c)
   def withIncompleteHandler[T](handler: ErrorHandler)(op: => T): T = {
     val saved = incompleteHandler
@@ -228,7 +220,7 @@ abstract class Reporter extends interfaces.ReporterResult {
     override def default(key: String) = 0
   }
 
-  def report(d: Message)(implicit ctx: Context): Unit =
+  def report(d: MessageContainer)(implicit ctx: Context): Unit =
     if (!isHidden(d)) {
       doReport(d)(ctx.addMode(Mode.Printing))
       d match {
@@ -242,12 +234,11 @@ abstract class Reporter extends interfaces.ReporterResult {
       }
     }
 
-  def incomplete(d: Message)(implicit ctx: Context): Unit =
+  def incomplete(d: MessageContainer)(implicit ctx: Context): Unit =
     incompleteHandler(d)(ctx)
 
-
   /** Summary of warnings and errors */
-  def summary/*(implicit ctx: Context)*/: String = {
+  def summary: String = {
     val b = new mutable.ListBuffer[String]
     if (warningCount > 0)
       b += countString(warningCount, "warning") + " found"
@@ -275,7 +266,7 @@ abstract class Reporter extends interfaces.ReporterResult {
   }
 
   /** Should this diagnostic not be reported at all? */
-  def isHidden(m: Message)(implicit ctx: Context): Boolean = ctx.mode.is(Mode.Printing)
+  def isHidden(m: MessageContainer)(implicit ctx: Context): Boolean = ctx.mode.is(Mode.Printing)
 
   /** Does this reporter contain not yet reported errors or warnings? */
   def hasPending: Boolean = false

src/dotty/tools/dotc/reporting/StoreReporter.scala

@@ -6,17 +6,17 @@ import core.Contexts.Context
 import collection.mutable
 import Reporter.{Error, Warning}
 import config.Printers.typr
-import diagnostic.Message
+import diagnostic.MessageContainer
 import diagnostic.messages._
 
 /**
  * This class implements a Reporter that stores all messages
  */
 class StoreReporter(outer: Reporter) extends Reporter {
 
-  private var infos: mutable.ListBuffer[Message] = null
+  private var infos: mutable.ListBuffer[MessageContainer] = null
 
-  def doReport(m: Message)(implicit ctx: Context): Unit = {
+  def doReport(m: MessageContainer)(implicit ctx: Context): Unit = {
     typr.println(s">>>> StoredError: ${m.message}") // !!! DEBUG
     if (infos == null) infos = new mutable.ListBuffer
     infos += m

src/dotty/tools/dotc/reporting/ThrowingReporter.scala

@@ -4,7 +4,7 @@ package reporting
 
 import core.Contexts.Context
 import collection.mutable
-import diagnostic.Message
+import diagnostic.MessageContainer
 import diagnostic.messages.Error
 import Reporter._
 
@@ -13,7 +13,7 @@ import Reporter._
  * info to the underlying reporter.
  */
 class ThrowingReporter(reportInfo: Reporter) extends Reporter {
-  def doReport(m: Message)(implicit ctx: Context): Unit = m match {
+  def doReport(m: MessageContainer)(implicit ctx: Context): Unit = m match {
     case _: Error => throw m
     case _ => reportInfo.doReport(m)
   }

src/dotty/tools/dotc/reporting/UniqueMessagePositions.scala

@@ -5,7 +5,7 @@ package reporting
 import scala.collection.mutable
 import util.{SourcePosition, SourceFile}
 import core.Contexts.Context
-import diagnostic.Message
+import diagnostic.MessageContainer
 
 /**
  * This trait implements `isHidden` so that multiple messages per position
@@ -18,7 +18,7 @@ trait UniqueMessagePositions extends Reporter {
   /** Logs a position and returns true if it was already logged.
    *  @note  Two positions are considered identical for logging if they have the same point.
    */
-  override def isHidden(m: Message)(implicit ctx: Context): Boolean =
+  override def isHidden(m: MessageContainer)(implicit ctx: Context): Boolean =
     super.isHidden(m) || {
       m.pos.exists && {
         positions get (ctx.source, m.pos.point) match {