removes front ends from scala-reflect.jar

It was an interesting idea to give macro developers control over front ends,
but it hasn't given any visible results.

To the contrast, front ends have proven useful for toolboxes to easily control
what errors get printed where.

Therefore I'm moving front ends to scala-compiler.jar to clean up the API.
Yay for scaladoc-driven development!

5 files changed, 142 insertions, 91 deletions

diff --git a/src/compiler/scala/tools/reflect/FrontEnd.scala b/src/compiler/scala/tools/reflect/FrontEnd.scala
new file mode 100644
index 0000000000..f0d3d5973d
--- /dev/null
+++ b/src/compiler/scala/tools/reflect/FrontEnd.scala
@@ -0,0 +1,50 @@
+package scala.tools
+package reflect
+
+import scala.reflect.internal.util.Position
+
+trait FrontEnd {
+  object severity extends Enumeration
+  class Severity(val id: Int) extends severity.Value {
+    var count: Int = 0
+    override def toString() = this match {
+      case INFO => "INFO"
+      case WARNING => "WARNING"
+      case ERROR => "ERROR"
+      case _ => "<unknown>"
+    }
+  }
+  val INFO    = new Severity(0)
+  val WARNING = new Severity(1)
+  val ERROR   = new Severity(2)
+
+  def hasErrors   = ERROR.count > 0
+  def hasWarnings = WARNING.count > 0
+
+  case class Info(val pos: Position, val msg: String, val severity: Severity)
+  val infos = new scala.collection.mutable.LinkedHashSet[Info]
+
+  /** Handles incoming info */
+  def log(pos: Position, msg: String, severity: Severity) {
+    infos += new Info(pos, msg, severity)
+    severity.count += 1
+    display(infos.last)
+  }
+
+  /** Displays incoming info */
+  def display(info: Info): Unit
+
+  /** Services a request to drop into interactive mode */
+  def interactive(): Unit
+
+  /** Refreshes the UI */
+  def flush(): Unit = {}
+
+  /** Resets the reporter */
+  def reset(): Unit = {
+    INFO.count = 0
+    WARNING.count = 0
+    ERROR.count = 0
+    infos.clear()
+  }
+}
diff --git a/src/compiler/scala/tools/reflect/FrontEnds.scala b/src/compiler/scala/tools/reflect/FrontEnds.scala
deleted file mode 100644
index d0c3c1c774..0000000000
--- a/src/compiler/scala/tools/reflect/FrontEnds.scala
+++ /dev/null
@@ -1,88 +0,0 @@
-package scala.tools
-package reflect
-
-import scala.tools.nsc.reporters._
-import scala.tools.nsc.Settings
-import scala.reflect.ClassTag
-
-trait FrontEnds extends scala.reflect.api.FrontEnds {
-
-  type Position = scala.reflect.internal.util.Position
-
-  def mkConsoleFrontEnd(minSeverity: Int = 1): FrontEnd = {
-    val settings = new Settings()
-    if (minSeverity <= 0) settings.verbose.value = true
-    if (minSeverity > 1) settings.nowarn.value = true
-    wrapReporter(new ConsoleReporter(settings))
-  }
-
-  abstract class FrontEndToReporterProxy(val frontEnd: FrontEnd) extends AbstractReporter {
-    import frontEnd.{Severity => ApiSeverity}
-    val API_INFO = frontEnd.INFO
-    val API_WARNING = frontEnd.WARNING
-    val API_ERROR = frontEnd.ERROR
-
-    type NscSeverity = Severity
-    val NSC_INFO = INFO
-    val NSC_WARNING = WARNING
-    val NSC_ERROR = ERROR
-
-    def display(pos: Position, msg: String, nscSeverity: NscSeverity): Unit =
-      frontEnd.log(pos, msg, nscSeverity match {
-        case NSC_INFO => API_INFO
-        case NSC_WARNING => API_WARNING
-        case NSC_ERROR => API_ERROR
-      })
-
-    def displayPrompt(): Unit =
-      frontEnd.interactive()
-
-    override def flush(): Unit = {
-      super.flush()
-      frontEnd.flush()
-    }
-
-    override def reset(): Unit = {
-      super.reset()
-      frontEnd.reset()
-    }
-  }
-
-  def wrapFrontEnd(frontEnd: FrontEnd): Reporter = new FrontEndToReporterProxy(frontEnd) {
-    val settings = new Settings()
-    settings.verbose.value = true
-    settings.nowarn.value = false
-  }
-
-  class ReporterToFrontEndProxy(val reporter: Reporter) extends FrontEnd {
-    val API_INFO = INFO
-    val API_WARNING = WARNING
-    val API_ERROR = ERROR
-
-    override def hasErrors   = reporter.hasErrors
-    override def hasWarnings = reporter.hasWarnings
-
-    def display(info: Info): Unit = info.severity match {
-      case API_INFO => reporter.info(info.pos, info.msg, false)
-      case API_WARNING => reporter.warning(info.pos, info.msg)
-      case API_ERROR => reporter.error(info.pos, info.msg)
-    }
-
-    def interactive(): Unit = reporter match {
-      case reporter: AbstractReporter => reporter.displayPrompt()
-      case _ => // do nothing
-    }
-
-    override def flush(): Unit = {
-      super.flush()
-      reporter.flush()
-    }
-
-    override def reset(): Unit = {
-      super.reset()
-      reporter.reset()
-    }
-  }
-
-  def wrapReporter(reporter: Reporter): FrontEnd = new ReporterToFrontEndProxy(reporter)
-}
diff --git a/src/compiler/scala/tools/reflect/ToolBox.scala b/src/compiler/scala/tools/reflect/ToolBox.scala
index f627699597..ab814b617d 100644
--- a/src/compiler/scala/tools/reflect/ToolBox.scala
+++ b/src/compiler/scala/tools/reflect/ToolBox.scala
@@ -15,6 +15,9 @@ trait ToolBox[U <: scala.reflect.api.Universe] {
    *
    *  Accumulates and displays warnings and errors, can drop to interactive mode (if supported).
    *  The latter can be useful to study the typechecker or to debug complex macros.
+   *
+   *  [[scala.tools.reflect]] provides two predefined front ends that can be created using
+   *  [[scala.tools.reflect.mkSilentFrontEnd]] and [[scala.tools.reflect.mkConsoleFrontEnd]].
    */
   def frontEnd: FrontEnd
 
diff --git a/src/compiler/scala/tools/reflect/ToolBoxFactory.scala b/src/compiler/scala/tools/reflect/ToolBoxFactory.scala
index 17d69cf94b..95135b84e0 100644
--- a/src/compiler/scala/tools/reflect/ToolBoxFactory.scala
+++ b/src/compiler/scala/tools/reflect/ToolBoxFactory.scala
@@ -334,7 +334,7 @@ abstract class ToolBoxFactory[U <: JavaUniverse](val u: U) { factorySelf =>
         val errorFn: String => Unit = msg => frontEnd.log(scala.reflect.internal.util.NoPosition, msg, frontEnd.ERROR)
         val command = new CompilerCommand(arguments.toList, errorFn)
         command.settings.outputDirs setSingleOutput virtualDirectory
-        val instance = new ToolBoxGlobal(command.settings, new FrontEndToReporterProxy(frontEnd) { val settings = command.settings })
+        val instance = new ToolBoxGlobal(command.settings, frontEndToReporter(frontEnd, command.settings))
         if (frontEnd.hasErrors) {
           var msg = "reflective compilation has failed: cannot initialize the compiler: " + EOL + EOL
           msg += frontEnd.infos map (_.msg) mkString EOL
diff --git a/src/compiler/scala/tools/reflect/package.scala b/src/compiler/scala/tools/reflect/package.scala
index 901071d91a..8a1e3628e2 100644
--- a/src/compiler/scala/tools/reflect/package.scala
+++ b/src/compiler/scala/tools/reflect/package.scala
@@ -6,9 +6,12 @@
 package scala.tools
 
 import scala.reflect.api.JavaUniverse
+import scala.reflect.internal.util.Position
 import scala.language.implicitConversions
+import scala.tools.nsc.reporters._
+import scala.tools.nsc.Settings
 
-package object reflect extends FrontEnds {
+package object reflect {
   // [todo: can we generalize this?
   import scala.reflect.runtime.{universe => ru}
   implicit def ToolBox(mirror0: ru.Mirror): ToolBoxFactory[ru.type] =
@@ -17,9 +20,92 @@ package object reflect extends FrontEnds {
     }
 
   // todo. replace this with an implicit class, once the pesky warning is gone
+  // we don't provide `Eval` for trees, because it's unclear where to get an evaluation mirror from
   implicit def Eval[T](expr: JavaUniverse # Expr[T]): Eval[T] = new Eval[T](expr)
 
-  // we don't provide `Eval` for trees, because it's unclear where to get an evaluation mirror from
+  /** Creates a UI-less reporter that simply accumulates all the messages
+   */
+  def mkSilentFrontEnd(): FrontEnd = new FrontEnd {
+    def display(info: Info) {}
+    def interactive() {}
+  }
+
+  /** Creates a reporter that prints messages to the console according to the settings.
+   *
+   *  ``minSeverity'' determines minimum severity of the messages to be printed.
+   *  0 stands for INFO, 1 stands for WARNING and 2 stands for ERROR.
+   */
+  // todo. untangle warningsAsErrors from Reporters. I don't feel like moving this flag here!
+  def mkConsoleFrontEnd(minSeverity: Int = 1): FrontEnd = {
+    val settings = new Settings()
+    if (minSeverity <= 0) settings.verbose.value = true
+    if (minSeverity > 1) settings.nowarn.value = true
+    reporterToFrontEnd(new ConsoleReporter(settings))
+  }
+
+  private[reflect] def reporterToFrontEnd(reporter: Reporter): FrontEnd = new FrontEnd {
+    val API_INFO = INFO
+    val API_WARNING = WARNING
+    val API_ERROR = ERROR
+
+    override def hasErrors   = reporter.hasErrors
+    override def hasWarnings = reporter.hasWarnings
+
+    def display(info: Info): Unit = info.severity match {
+      case API_INFO => reporter.info(info.pos, info.msg, false)
+      case API_WARNING => reporter.warning(info.pos, info.msg)
+      case API_ERROR => reporter.error(info.pos, info.msg)
+    }
+
+    def interactive(): Unit = reporter match {
+      case reporter: AbstractReporter => reporter.displayPrompt()
+      case _ => // do nothing
+    }
+
+    override def flush(): Unit = {
+      super.flush()
+      reporter.flush()
+    }
+
+    override def reset(): Unit = {
+      super.reset()
+      reporter.reset()
+    }
+  }
+
+  private[reflect] def frontEndToReporter(frontEnd: FrontEnd, settings0: Settings): Reporter = new AbstractReporter {
+    val settings = settings0
+
+    import frontEnd.{Severity => ApiSeverity}
+    val API_INFO = frontEnd.INFO
+    val API_WARNING = frontEnd.WARNING
+    val API_ERROR = frontEnd.ERROR
+
+    type NscSeverity = Severity
+    val NSC_INFO = INFO
+    val NSC_WARNING = WARNING
+    val NSC_ERROR = ERROR
+
+    def display(pos: Position, msg: String, nscSeverity: NscSeverity): Unit =
+      frontEnd.log(pos, msg, nscSeverity match {
+        case NSC_INFO => API_INFO
+        case NSC_WARNING => API_WARNING
+        case NSC_ERROR => API_ERROR
+      })
+
+    def displayPrompt(): Unit =
+      frontEnd.interactive()
+
+    override def flush(): Unit = {
+      super.flush()
+      frontEnd.flush()
+    }
+
+    override def reset(): Unit = {
+      super.reset()
+      frontEnd.reset()
+    }
+  }
 }
 
 package reflect {