Merge pull request scala#6635 from som-snytt/topic/nail-reporter

Prefer internal.Reporter

Author: lrytz

src/compiler/scala/reflect/macros/contexts/FrontEnds.scala

@@ -8,7 +8,8 @@ trait FrontEnds {
 
   def echo(pos: Position, msg: String): Unit = universe.reporter.echo(pos, msg)
 
-  def info(pos: Position, msg: String, force: Boolean): Unit = universe.reporter.info(pos, msg, force)
+  @deprecated("Use echo, info messages are always forced", since="2.13.0")
+  def info(pos: Position, msg: String, force: Boolean): Unit = universe.reporter.echo(pos, msg)
 
   def hasWarnings: Boolean = universe.reporter.hasErrors
 

src/compiler/scala/tools/nsc/CompileServer.scala

@@ -159,7 +159,7 @@ class StandardCompileServer(fixPort: Int = 0) extends SocketServer(fixPort) {
           throw ex
       }
     }
-    reporter.printSummary()
+    reporter.finish()
     if (isMemoryFullEnough()) {
       info("Nulling out compiler due to memory utilization.")
       clearCompiler()

src/compiler/scala/tools/nsc/Driver.scala

@@ -1,8 +1,9 @@
 package scala
 package tools.nsc
 
-import scala.tools.nsc.reporters.{ ConsoleReporter, Reporter }
+import scala.tools.nsc.reporters.DisplayReporter
 import Properties.{ versionMsg, residentPromptString }
+import scala.reflect.internal.Reporter
 import scala.reflect.internal.util.FakePos
 
 abstract class Driver {
@@ -39,7 +40,7 @@ abstract class Driver {
 
   def process(args: Array[String]): Boolean = {
     val ss   = new Settings(scalacError)
-    reporter = new ConsoleReporter(ss)    // for reporting early config errors, before compiler is constructed
+    reporter = DisplayReporter(ss)    // for reporting early config errors, before compiler is constructed
     command  = new CompilerCommand(args.toList, ss)
     settings = command.settings
 

src/compiler/scala/tools/nsc/Global.scala

@@ -13,9 +13,10 @@ import java.nio.charset.{Charset, CharsetDecoder, IllegalCharsetNameException, U
 
 import scala.collection.{immutable, mutable}
 import io.{AbstractFile, Path, SourceReader}
-import reporters.Reporter
 import util.{ClassPath, returning}
+import reporters.{Reporter => LegacyReporter}
 import scala.reflect.ClassTag
+import scala.reflect.internal.{Reporter => InternalReporter}
 import scala.reflect.internal.util.{BatchSourceFile, FreshNameCreator, NoSourceFile, ScalaClassLoader, ScriptSourceFile, SourceFile, StatisticsStatics}
 import scala.reflect.internal.pickling.PickleBuffer
 import symtab.{Flags, SymbolTable, SymbolTrackers}
@@ -34,7 +35,7 @@ import scala.tools.nsc.ast.{TreeGen => AstTreeGen}
 import scala.tools.nsc.classpath._
 import scala.tools.nsc.profile.Profiler
 
-class Global(var currentSettings: Settings, reporter0: Reporter)
+class Global(var currentSettings: Settings, reporter0: LegacyReporter)
     extends SymbolTable
     with CompilationUnits
     with Plugins
@@ -76,21 +77,16 @@ class Global(var currentSettings: Settings, reporter0: Reporter)
 
   override def settings = currentSettings
 
-  private[this] var currentReporter: Reporter = { reporter = reporter0 ; currentReporter }
+  private[this] var currentReporter: LegacyReporter = { reporter = reporter0 ; currentReporter }
 
-  def reporter: Reporter = currentReporter
-  def reporter_=(newReporter: Reporter): Unit =
-    currentReporter = newReporter match {
-      case _: reporters.ConsoleReporter | _: reporters.LimitingReporter => newReporter
-      case _ if settings.maxerrs.isSetByUser && settings.maxerrs.value < settings.maxerrs.default =>
-        new reporters.LimitingReporter(settings, newReporter)
-      case _ => newReporter
-    }
+  def reporter: LegacyReporter = currentReporter
+  // enforce maxerrs if necessary
+  def reporter_=(newReporter: LegacyReporter): Unit = currentReporter = LegacyReporter.limitedReporter(settings, newReporter)
 
   /** Switch to turn on detailed type logs */
   var printTypings = settings.Ytyperdebug.value
 
-  def this(reporter: Reporter) =
+  def this(reporter: LegacyReporter) =
     this(new Settings(err => reporter.error(null, err)), reporter)
 
   def this(settings: Settings) =
@@ -338,7 +334,7 @@ class Global(var currentSettings: Settings, reporter0: Reporter)
     }
 
     def loadReader(name: String): Option[SourceReader] = {
-      def ccon = Class.forName(name).getConstructor(classOf[CharsetDecoder], classOf[Reporter])
+      def ccon = Class.forName(name).getConstructor(classOf[CharsetDecoder], classOf[InternalReporter])
 
       try Some(ccon.newInstance(charset.newDecoder(), reporter).asInstanceOf[SourceReader])
       catch { case ex: Throwable =>
@@ -395,9 +391,10 @@ class Global(var currentSettings: Settings, reporter0: Reporter)
 
     /** Is current phase cancelled on this unit? */
     def cancelled(unit: CompilationUnit) = {
+      val isCanceled = reporter.cancelled
       // run the typer only if in `createJavadoc` mode
       val maxJavaPhase = if (createJavadoc) currentRun.typerPhase.id else currentRun.namerPhase.id
-      reporter.cancelled || unit.isJava && this.id > maxJavaPhase
+      isCanceled || unit.isJava && this.id > maxJavaPhase
     }
 
     final def withCurrentUnit(unit: CompilationUnit)(task: => Unit): Unit = {
@@ -1266,7 +1263,7 @@ class Global(var currentSettings: Settings, reporter0: Reporter)
     }
 
     // for sbt
-    def cancel(): Unit = { reporter.cancelled = true }
+    def cancel(): Unit = reporter.cancelled = true
 
     private def currentProgress   = (phasec * size) + unitc
     private def totalProgress     = (phaseDescriptors.size - 1) * size // -1: drops terminal phase
@@ -1656,14 +1653,16 @@ class Global(var currentSettings: Settings, reporter0: Reporter)
 }
 
 object Global {
-  def apply(settings: Settings, reporter: Reporter): Global = new Global(settings, reporter)
+  def apply(settings: Settings, reporter: LegacyReporter): Global = new Global(settings, reporter)
 
   def apply(settings: Settings): Global = new Global(settings, reporter(settings))
 
-  private def reporter(settings: Settings): Reporter = {
+  private def reporter(settings: Settings): LegacyReporter = {
     //val loader = ScalaClassLoader(getClass.getClassLoader)  // apply does not make delegate
     val loader = new ClassLoader(getClass.getClassLoader) with ScalaClassLoader
-    loader.create[Reporter](settings.reporter.value, settings.errorFn)(settings)
+    val res = loader.create[InternalReporter](settings.reporter.value, settings.errorFn)(settings)
+    if (res.isInstanceOf[LegacyReporter]) res.asInstanceOf[LegacyReporter]
+    else res: LegacyReporter  // adaptable
   }
   private object InitPhase extends Phase(null) {
     def name = "<init phase>"

src/compiler/scala/tools/nsc/Reporting.scala

@@ -97,6 +97,7 @@ trait Reporting extends scala.reflect.internal.Reporting { self: ast.Positions w
       val explain = (
         if (reportedFeature contains featureTrait) "" else
         s"""|
+            |----
             |This can be achieved by adding the import clause 'import $fqname'
             |or by setting the compiler option -language:$featureName.
             |See the Scaladoc for value $fqname for a discussion

src/compiler/scala/tools/nsc/ast/DocComments.scala

@@ -254,8 +254,8 @@ trait DocComments { self: Global =>
               val sectionTextBounds = extractSectionText(parent, section)
               cleanupSectionText(parent.substring(sectionTextBounds._1, sectionTextBounds._2))
             case None =>
-              reporter.info(sym.pos, "The \"" + getSectionHeader + "\" annotation of the " + sym +
-                  " comment contains @inheritdoc, but the corresponding section in the parent is not defined.", force = true)
+              reporter.echo(sym.pos, "The \"" + getSectionHeader + "\" annotation of the " + sym +
+                  " comment contains @inheritdoc, but the corresponding section in the parent is not defined.")
               "<invalid inheritdoc annotation>"
           }
 

src/compiler/scala/tools/nsc/io/SourceReader.scala

@@ -11,7 +11,7 @@ import java.io.{ FileInputStream, IOException }
 import java.nio.{ByteBuffer, CharBuffer}
 import java.nio.channels.{ ReadableByteChannel, Channels }
 import java.nio.charset.{CharsetDecoder, CoderResult}
-import scala.tools.nsc.reporters._
+import scala.reflect.internal.Reporter
 
 /** This class implements methods to read and decode source files. */
 class SourceReader(decoder: CharsetDecoder, reporter: Reporter) {

src/compiler/scala/tools/nsc/reporters/AbstractReporter.scala

@@ -10,72 +10,32 @@ import scala.collection.mutable
 import scala.tools.nsc.Settings
 import scala.reflect.internal.util.Position
 
-/** This reporter implements filtering by severity and position.
+/** This reporter uses filtering by severity and position,
+ *  including two-tiered INFO messaging,
+ *  and also handles prompting and debug output.
  */
-abstract class AbstractReporter extends Reporter {
+@deprecated("Use PositionFiltering", since="2.13")
+abstract class AbstractReporter extends Reporter with PositionFiltering {
   val settings: Settings
   def display(pos: Position, msg: String, severity: Severity): Unit
   def displayPrompt(): Unit
 
-  private val positions = mutable.Map[Position, Severity]() withDefaultValue INFO
-  private val messages  = mutable.Map[Position, List[String]]() withDefaultValue Nil
+  protected def noWarnings = settings.nowarnings.value
+  private def isVerbose    = settings.verbose.value
+  private def isPromptSet  = settings.prompt.value
+  private def isDebug      = settings.debug.value
 
-  override def reset(): Unit = {
-    super.reset()
-    positions.clear()
-    messages.clear()
-  }
-
-  private def isVerbose   = settings.verbose.value
-  private def noWarnings  = settings.nowarnings.value
-  private def isPromptSet = settings.prompt.value
-  private def isDebug     = settings.debug
+  protected def suppressed(pos: Position, msg: String, severity: Severity): Unit =
+    if (isPromptSet)  countAndDisplay(pos, msg, severity)
+    else if (isDebug) countAndDisplay(pos, "[ suppressed ] " + msg, severity)
 
-  protected def info0(pos: Position, msg: String, severity: Severity, force: Boolean): Unit = {
-    if (severity == INFO) {
-      if (isVerbose || force) {
-        severity.count += 1
-        display(pos, msg, severity)
-      }
-    }
-    else {
-      val hidden = testAndLog(pos, severity, msg)
-      if (severity == WARNING && noWarnings) ()
-      else {
-        if (!hidden || isPromptSet) {
-          severity.count += 1
-          display(pos, msg, severity)
-        }
-        else if (isDebug) {
-          severity.count += 1
-          display(pos, "[ suppressed ] " + msg, severity)
-        }
+  protected def info0(pos: Position, msg: String, severity: Severity, force: Boolean): Unit =
+    if (filter(pos, msg, severity) && (severity != INFO || (force || isVerbose)))
+      countAndDisplay(pos, msg, severity)
 
-        if (isPromptSet)
-          displayPrompt()
-      }
-    }
+  private def countAndDisplay(pos: Position, msg: String, severity: Severity): Unit = {
+    severity.count += 1
+    display(pos, msg, severity)
+    if (isPromptSet && severity != INFO) displayPrompt()
   }
-
-
-  /** 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.
-   */
-  private def testAndLog(pos: Position, severity: Severity, msg: String): Boolean =
-    pos != null && pos.isDefined && {
-      val fpos     = pos.focus
-      val suppress = positions(fpos) match {
-        case ERROR                    => true  // already error at position
-        case highest
-          if highest.id > severity.id => true  // already message higher than present severity
-        case `severity`               => messages(fpos) contains msg // already issued this exact message
-        case _                        => false // good to go
-      }
-
-      suppress || {
-        positions(fpos) = severity
-        messages(fpos) ::= msg
-        false
-      }
-    }
 }

src/compiler/scala/tools/nsc/reporters/ConsoleReporter.scala

@@ -15,82 +15,18 @@ import scala.tools.util.SystemExit
 
 /** This class implements a Reporter that displays messages on a text console.
  */
-class ConsoleReporter(val settings: Settings, reader: BufferedReader, writer: PrintWriter, echoWriter: PrintWriter) extends AbstractReporter {
+class ConsoleReporter(val settings: Settings, val reader: BufferedReader, val writer: PrintWriter, val echoWriter: PrintWriter) extends AbstractReporter with PrintReporter with SummaryReporter {
   def this(settings: Settings) = this(settings, Console.in, new PrintWriter(Console.err, true), new PrintWriter(Console.out, true))
-  def this(settings: Settings, reader: BufferedReader, writer: PrintWriter) =
-    this(settings, reader, writer, writer)
+  def this(settings: Settings, reader: BufferedReader, writer: PrintWriter) = this(settings, reader, writer, writer)
 
-  /** Whether a short file name should be displayed before errors */
-  var shortname: Boolean = false
-
-  /** maximal number of error messages to be printed */
-  @deprecated("configured by settings.maxerrs", since="2.12.2")
-  final val ERROR_LIMIT = 100
-
-  private def label(severity: Severity): String = severity match {
-    case ERROR   => "error"
-    case WARNING => "warning"
-    case INFO    => ""
-  }
-
-  protected def clabel(severity: Severity): String = label(severity) match {
-    case "" => ""
-    case s  => s"$s: "
-  }
-
-  /** Prints the message. */
-  def printMessage(msg: String): Unit = {
-    writer.println(trimTrailing(msg))
-    writer.flush()
-  }
-
-  /** Prints the message to the echoWriter, which is usually stdout. */
-  override def echo(msg: String): Unit = {
-    echoWriter.println(trimTrailing(msg))
-    echoWriter.flush()
-  }
-
-  /** Prints the message with the given position indication. */
-  def printMessage(posIn: Position, msg: String): Unit = printMessage(formatMessage(posIn, msg, shortname))
-
-  def print(pos: Position, msg: String, severity: Severity): Unit = printMessage(pos, s"${clabel(severity)}${msg}")
-
-  /** Prints the column marker of the given position. */
-  def printColumnMarker(pos: Position): Unit = if (pos.isDefined) printMessage(" " * (pos.column - 1) + "^")
-
-  /** Prints the number of warnings and errors if there are any. */
-  def printSummary(): Unit =
-    for (k <- List(WARNING, ERROR) if k.count > 0) printMessage(s"${countAs(k.count, label(k))} found")
-
-  def display(pos: Position, msg: String, severity: Severity): Unit = {
+  // limit errors and warnings; AbstractReporter counts them because of forced INFO special case
+  override def display(pos: Position, msg: String, severity: Severity): Unit = {
     // the count includes the current message
     val ok = severity match {
       case ERROR   => ERROR.count   <= settings.maxerrs.value
       case WARNING => WARNING.count <= settings.maxwarns.value
-      case _     => true
+      case _       => true
     }
-    if (ok) print(pos, msg, severity)
+    if (ok) super.display(pos, msg, severity)
   }
-
-  def displayPrompt(): Unit = {
-    writer.println()
-    writer.print("a)bort, s)tack, r)esume: ")
-    writer.flush()
-    if (reader != null) {
-      reader.read match {
-        case 'a' | 'A' =>
-          new Throwable().printStackTrace(writer)
-          throw SystemExit(1)
-        case 's' | 'S' =>
-          new Throwable().printStackTrace(writer)
-          writer.println()
-          writer.flush()
-        case _ =>
-      }
-    }
-  }
-
-  override def flush() = writer.flush()
-
-  override def finish() = printSummary()
 }