Uniformly route reporting through reporter.

Sharpen interfaces, reduce footprint of Reporting trait.
Ideally, all reporting should indirect through reporter,
and the `Reporting` trait itself should be restricted to
a single method that retrieves the current `reporter`.

Pull up some more reporting to reflect.internal.
Would like to do more, but need to move partest to the
reflect.internal interface first.
(Its `errorCount` relies on `ERROR.count` in `tools.nsc.Reporter`.)

2 files changed, 68 insertions, 7 deletions

diff --git a/src/reflect/scala/reflect/internal/Reporting.scala b/src/reflect/scala/reflect/internal/Reporting.scala
index e88e765750..baeed1357d 100644
--- a/src/reflect/scala/reflect/internal/Reporting.scala
+++ b/src/reflect/scala/reflect/internal/Reporting.scala
@@ -7,11 +7,20 @@ package scala
 package reflect
 package internal
 
+/** Provides delegates to the reporter doing the actual work.
+ * All forwarding methods should be marked final,
+ * but some subclasses out of our reach stil override them.
+ */
 trait Reporting { self : Positions =>
+  def reporter: Reporter
+
+  @deprecatedOverriding("This forwards to the corresponding method in reporter -- override reporter instead", "2.11.2")
   def inform(msg: String): Unit      = inform(NoPosition, msg)
+  @deprecatedOverriding("This forwards to the corresponding method in reporter -- override reporter instead", "2.11.2")
   def warning(msg: String): Unit     = warning(NoPosition, msg)
   // globalError(msg: String) used to abort -- not sure that was a good idea, so I made it more regular
   // (couldn't find any uses that relied on old behavior)
+  @deprecatedOverriding("This forwards to the corresponding method in reporter -- override reporter instead", "2.11.2")
   def globalError(msg: String): Unit = globalError(NoPosition, msg)
 
   def abort(msg: String): Nothing = {
@@ -21,12 +30,60 @@ trait Reporting { self : Positions =>
     throw new FatalError(augmented)
   }
 
-  def inform(pos: Position, msg: String)      = Console.out.println(msg)
-  def warning(pos: Position, msg: String)     = Console.err.println(msg)
-  def globalError(pos: Position, msg: String) = Console.err.println(msg)
+  @deprecatedOverriding("This forwards to the corresponding method in reporter -- override reporter instead", "2.11.2")
+  def inform(pos: Position, msg: String)      = reporter.echo(pos, msg)
+  @deprecatedOverriding("This forwards to the corresponding method in reporter -- override reporter instead", "2.11.2")
+  def warning(pos: Position, msg: String)     = reporter.warning(pos, msg)
+  @deprecatedOverriding("This forwards to the corresponding method in reporter -- override reporter instead", "2.11.2")
+  def globalError(pos: Position, msg: String) = reporter.error(pos, msg)
 
   def deprecationWarning(pos: Position, msg: String): Unit = warning(msg)
 
   /** Overridden when we know more about what was happening during a failure. */
   def supplementErrorMessage(msg: String): String = msg
-}
\ No newline at end of file
+}
+
+import util.Position
+
+/** Report information, warnings and errors.
+ *
+ * This describes the (future) external interface for issuing information, warnings and errors.
+ * Currently, scala.tools.nsc.Reporter is used by sbt/ide/partest.
+ */
+abstract class Reporter {
+  protected def info0(pos: Position, msg: String, severity: Severity, force: Boolean): Unit
+
+  def echo(pos: Position, msg: String): Unit    = info0(pos, msg, INFO, force = true)
+  def warning(pos: Position, msg: String): Unit = info0(pos, msg, WARNING, force = false)
+  def error(pos: Position, msg: String): Unit   = info0(pos, msg, ERROR, force = false)
+
+  type Severity
+  val INFO: Severity
+  val WARNING: Severity
+  val ERROR: Severity
+
+  def count(severity: Severity): Int
+  def resetCount(severity: Severity): Unit
+
+  def hasErrors: Boolean   = count(ERROR) > 0
+  def hasWarnings: Boolean = count(WARNING) > 0
+
+  def reset(): Unit = {
+    resetCount(INFO)
+    resetCount(WARNING)
+    resetCount(ERROR)
+  }
+
+  def flush(): Unit = { }
+}
+
+// TODO: move into superclass once partest cuts tie on Severity
+abstract class ReporterImpl extends Reporter {
+  class Severity(val id: Int)(name: String) { var count: Int = 0 ; override def toString = name}
+  object INFO    extends Severity(0)("INFO")
+  object WARNING extends Severity(1)("WARNING")
+  object ERROR   extends Severity(2)("ERROR")
+
+  def count(severity: Severity): Int       = severity.count
+  def resetCount(severity: Severity): Unit = severity.count = 0
+}
diff --git a/src/reflect/scala/reflect/runtime/JavaUniverse.scala b/src/reflect/scala/reflect/runtime/JavaUniverse.scala
index b5446694ed..d846ef2cdd 100644
--- a/src/reflect/scala/reflect/runtime/JavaUniverse.scala
+++ b/src/reflect/scala/reflect/runtime/JavaUniverse.scala
@@ -14,15 +14,19 @@ import scala.reflect.api.{TreeCreator, TypeCreator, Universe}
  *  @contentDiagram hideNodes "*Api" "*Extractor"
  */
 class JavaUniverse extends InternalSymbolTable with JavaUniverseForce with ReflectSetup with RuntimeSymbolTable { self =>
-
-  override def inform(msg: String): Unit = log(msg)
   def picklerPhase = SomePhase
   def erasurePhase = SomePhase
   lazy val settings = new Settings
-  private val isLogging = sys.props contains "scala.debug.reflect"
 
+  private val isLogging = sys.props contains "scala.debug.reflect"
   def log(msg: => AnyRef): Unit = if (isLogging) Console.err.println("[reflect] " + msg)
 
+  // TODO: why put output under isLogging? Calls to inform are already conditional on debug/verbose/...
+  import scala.reflect.internal.{Reporter, ReporterImpl}
+  override def reporter: Reporter = new ReporterImpl {
+    protected def info0(pos: Position, msg: String, severity: Severity, force: Boolean): Unit = log(msg)
+  }
+
   type TreeCopier = InternalTreeCopierOps
   implicit val TreeCopierTag: ClassTag[TreeCopier] = ClassTag[TreeCopier](classOf[TreeCopier])
   def newStrictTreeCopier: TreeCopier = new StrictTreeCopier