Move reporting logic into Reporting trait

Move code from Global/SymbolTable to separate Reporting traits to
start carving out an interface in scala.reflect.internal.Reporting,
with internals in scala.tools.nsc. Reporting is mixed into the cake.
It contains a nested class PerRunReporting.

Should do the same for debugging/logging.

The idea is that CompilationUnit and Global forward all reporting
to Reporter. The Reporting trait contains these forwarders, and
PerRunReporting, which accumulates warning state during a run.

In the process, I slightly changed the behavior of `globalError`
in reflect.internal.SymbolTable: it used to abort, weirdly.
I assume that was dummy behavior to avoid introducing an abstract method.
It's immediately overridden in Global, and I couldn't find any other subclasses,
so I don't think the behavior in SymbolTable was ever observed.

Provide necessary hooks for scala.reflect.macros.Parsers#parse.
See scala/reflect/macros/contexts/Parsers.scala's parse method,
which overrides the reporter to detect when parsing goes wrong.
This should be refactored, but that goes beyond the scope of this PR.

Don't pop empty macro context stack.
(Ran into this while reworking -Xfatal-warnings logic.)

Fix -Xfatal-warnings behavior (and check files): it wasn't meant to
influence warning reporting, except for emitting one final error;
if necessary to fail the compile (when warnings but no errors were reported).
Warnings should stay warnings.

This was refactored in fbbbb22946, but we soon seem to have relapsed.
An hour of gitfu did not lead to where it went wrong. Must've been a merge.

3 files changed, 37 insertions, 15 deletions

diff --git a/src/reflect/scala/reflect/internal/Positions.scala b/src/reflect/scala/reflect/internal/Positions.scala
index 01fba1efc1..c16d8778d9 100644
--- a/src/reflect/scala/reflect/internal/Positions.scala
+++ b/src/reflect/scala/reflect/internal/Positions.scala
@@ -23,13 +23,10 @@ import scala.collection.mutable.ListBuffer
  *   Otherwise, the singleton consisting of the node itself.
  */
 trait Positions extends api.Positions { self: SymbolTable =>
-
   type Position = scala.reflect.internal.util.Position
   val NoPosition = scala.reflect.internal.util.NoPosition
   implicit val PositionTag = ClassTag[Position](classOf[Position])
 
-  def inform(msg: String): Unit
-
   def useOffsetPositions: Boolean = true
 
   /** A position that wraps a set of trees.
@@ -100,7 +97,7 @@ trait Positions extends api.Positions { self: SymbolTable =>
       inform("\nWhile validating #" + tree.id)
       inform(treeStatus(tree))
       inform("\nChildren:")
-      tree.children map (t => "  " + treeStatus(t, tree)) foreach inform
+      tree.children foreach (t => inform("  " + treeStatus(t, tree)))
       inform("=======")
       throw new ValidateException(msg)
     }
@@ -109,7 +106,7 @@ trait Positions extends api.Positions { self: SymbolTable =>
 
       if (!tree.isEmpty && tree.canHaveAttrs) {
         if (settings.Yposdebug && (settings.verbose || settings.Yrangepos))
-          println("[%10s] %s".format("validate", treeStatus(tree, encltree)))
+          inform("[%10s] %s".format("validate", treeStatus(tree, encltree)))
 
         if (!tree.pos.isDefined)
           positionError("Unpositioned tree #"+tree.id) {
@@ -176,7 +173,7 @@ trait Positions extends api.Positions { self: SymbolTable =>
     case r :: rs1 =>
       assert(!t.pos.isTransparent)
       if (r.isFree && (r.pos includes t.pos)) {
-//      println("subdividing "+r+"/"+t.pos)
+//      inform("subdividing "+r+"/"+t.pos)
         maybeFree(t.pos.end, r.pos.end) ::: List(Range(t.pos, t)) ::: maybeFree(r.pos.start, t.pos.start) ::: rs1
       } else {
         if (!r.isFree && (r.pos overlaps t.pos)) conflicting += r.tree
@@ -225,7 +222,7 @@ trait Positions extends api.Positions { self: SymbolTable =>
     }
   } catch {
     case ex: Exception =>
-      println("error while set children pos "+pos+" of "+trees)
+      inform("error while set children pos "+pos+" of "+trees)
       throw ex
   }
 
diff --git a/src/reflect/scala/reflect/internal/Reporting.scala b/src/reflect/scala/reflect/internal/Reporting.scala
new file mode 100644
index 0000000000..e88e765750
--- /dev/null
+++ b/src/reflect/scala/reflect/internal/Reporting.scala
@@ -0,0 +1,32 @@
+/* NSC -- new Scala compiler
+ * Copyright 2005-2014 LAMP/EPFL, Typesafe Inc.
+ * @author  Adriaan Moors
+ */
+
+package scala
+package reflect
+package internal
+
+trait Reporting { self : Positions =>
+  def inform(msg: String): Unit      = inform(NoPosition, msg)
+  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)
+  def globalError(msg: String): Unit = globalError(NoPosition, msg)
+
+  def abort(msg: String): Nothing = {
+    val augmented = supplementErrorMessage(msg)
+    // Needs to call error to make sure the compile fails.
+    globalError(augmented)
+    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)
+
+  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
diff --git a/src/reflect/scala/reflect/internal/SymbolTable.scala b/src/reflect/scala/reflect/internal/SymbolTable.scala
index c76dedbff4..ed5c68fe82 100644
--- a/src/reflect/scala/reflect/internal/SymbolTable.scala
+++ b/src/reflect/scala/reflect/internal/SymbolTable.scala
@@ -46,16 +46,12 @@ abstract class SymbolTable extends macros.Universe
                               with pickling.Translations
                               with FreshNames
                               with Internals
+                              with Reporting
 {
 
   val gen = new InternalTreeGen { val global: SymbolTable.this.type = SymbolTable.this }
 
   def log(msg: => AnyRef): Unit
-  def deprecationWarning(pos: Position, msg: String): Unit = warning(msg)
-  def warning(msg: String): Unit     = Console.err.println(msg)
-  def inform(msg: String): Unit      = Console.err.println(msg)
-  def globalError(msg: String): Unit = abort(msg)
-  def abort(msg: String): Nothing    = throw new FatalError(supplementErrorMessage(msg))
 
   protected def elapsedMessage(msg: String, start: Long) =
     msg + " in " + (TimeUnit.NANOSECONDS.toMillis(System.nanoTime()) - start) + "ms"
@@ -82,9 +78,6 @@ abstract class SymbolTable extends macros.Universe
   /** Prints a stack trace if -Ydebug or equivalent was given, otherwise does nothing. */
   def debugStack(t: Throwable): Unit  = devWarning(throwableAsString(t))
 
-  /** Overridden when we know more about what was happening during a failure. */
-  def supplementErrorMessage(msg: String): String = msg
-
   private[scala] def printCaller[T](msg: String)(result: T) = {
     Console.err.println("%s: %s\nCalled from: %s".format(msg, result,
       (new Throwable).getStackTrace.drop(2).take(50).mkString("\n")))