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

SI-9350 Command option -Xreporter

Author: adriaanm

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

@@ -1,47 +1,51 @@
 package scala
 package tools.nsc
 
-import scala.tools.nsc.reporters.ConsoleReporter
+import scala.tools.nsc.reporters.{ ConsoleReporter, Reporter }
 import Properties.{ versionMsg, residentPromptString }
 import scala.reflect.internal.util.FakePos
 
 abstract class Driver {
 
   val prompt = residentPromptString
 
-  var reporter: ConsoleReporter = _
+  var reporter: Reporter = _
   protected var command: CompilerCommand = _
   protected var settings: Settings = _
 
+  /** Forward errors to the (current) reporter. */
   protected def scalacError(msg: String): Unit = {
     reporter.error(FakePos("scalac"), msg + "\n  scalac -help  gives more information")
   }
 
+  /** True to continue compilation. */
   protected def processSettingsHook(): Boolean = {
-    if (settings.version) { reporter echo versionMsg ; false } else true
+    if (settings.version) { reporter echo versionMsg ; false }
+    else !reporter.hasErrors
   }
 
   protected def newCompiler(): Global
 
-  protected def doCompile(compiler: Global) {
+  protected def doCompile(compiler: Global): Unit = {
     if (command.files.isEmpty) {
       reporter.echo(command.usageMsg)
       reporter.echo(compiler.pluginOptionsHelp)
     } else {
       val run = new compiler.Run()
       run compile command.files
-      reporter.printSummary()
+      reporter.finish()
     }
   }
 
-  def process(args: Array[String]) {
+  def process(args: Array[String]): Boolean = {
     val ss   = new Settings(scalacError)
-    reporter = new ConsoleReporter(ss)
+    reporter = new ConsoleReporter(ss)    // for reporting early config errors, before compiler is constructed
     command  = new CompilerCommand(args.toList, ss)
     settings = command.settings
 
     if (processSettingsHook()) {
       val compiler = newCompiler()
+      reporter     = compiler.reporter    // adopt the configured reporter
       try {
         if (reporter.hasErrors)
           reporter.flush()
@@ -57,11 +61,9 @@ abstract class Driver {
             case _                => throw ex // unexpected error, tell the outside world.
           }
       }
-    }
+    } else if (reporter.hasErrors) reporter.flush()
+    !reporter.hasErrors
   }
 
-  def main(args: Array[String]) {
-    process(args)
-    sys.exit(if (reporter.hasErrors) 1 else 0)
-  }
+  def main(args: Array[String]): Unit = sys.exit(if (process(args)) 0 else 1)
 }

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

@@ -15,7 +15,7 @@ import io.{ SourceReader, AbstractFile, Path }
 import reporters.{ Reporter, ConsoleReporter }
 import util.{ ClassFileLookup, ClassPath, MergedClassPath, StatisticsInfo, returning }
 import scala.reflect.ClassTag
-import scala.reflect.internal.util.{ SourceFile, NoSourceFile, BatchSourceFile, ScriptSourceFile }
+import scala.reflect.internal.util.{ ScalaClassLoader, SourceFile, NoSourceFile, BatchSourceFile, ScriptSourceFile }
 import scala.reflect.internal.pickling.PickleBuffer
 import symtab.{ Flags, SymbolTable, SymbolTrackers }
 import symtab.classfile.Pickler
@@ -90,7 +90,7 @@ class Global(var currentSettings: Settings, var reporter: Reporter)
     this(new Settings(err => reporter.error(null, err)), reporter)
 
   def this(settings: Settings) =
-    this(settings, new ConsoleReporter(settings))
+    this(settings, Global.reporter(settings))
 
   def picklerPhase: Phase = if (currentRun.isDefined) currentRun.picklerPhase else NoPhase
 
@@ -1703,4 +1703,12 @@ class Global(var currentSettings: Settings, var reporter: Reporter)
 
 object Global {
   def apply(settings: Settings, reporter: Reporter): Global = new Global(settings, reporter)
+
+  def apply(settings: Settings): Global = new Global(settings, reporter(settings))
+
+  private def reporter(settings: Settings): Reporter = {
+    //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)
+  }
 }

src/compiler/scala/tools/nsc/Main.scala

@@ -17,7 +17,8 @@ class MainClass extends Driver with EvalLoop {
     new compiler.Run() compile command.files
   }
 
-  override def newCompiler(): Global = Global(settings, reporter)
+  override def newCompiler(): Global = Global(settings)
+
   override def doCompile(compiler: Global) {
     if (settings.resident) resident(compiler)
     else super.doCompile(compiler)

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

@@ -11,8 +11,7 @@ import java.io.{ BufferedReader, IOException, PrintWriter }
 import scala.reflect.internal.util._
 import StringOps._
 
-/**
- * This class implements a Reporter that displays messages on a text console.
+/** This class implements a Reporter that displays messages on a text console.
  */
 class ConsoleReporter(val settings: Settings, reader: BufferedReader, writer: PrintWriter) extends AbstractReporter {
   def this(settings: Settings) = this(settings, Console.in, new PrintWriter(Console.err, true))
@@ -85,5 +84,7 @@ class ConsoleReporter(val settings: Settings, reader: BufferedReader, writer: Pr
     }
   }
 
-  override def flush() { writer.flush() }
+  override def flush() = writer.flush()
+
+  override def finish() = printSummary()
 }

src/compiler/scala/tools/nsc/settings/ScalaSettings.scala

@@ -134,6 +134,7 @@ trait ScalaSettings extends AbsScalaSettings
   val Xshowobj           = StringSetting       ("-Xshow-object", "object", "Show internal representation of object.", "")
   val showPhases         = BooleanSetting      ("-Xshow-phases", "Print a synopsis of compiler phases.")
   val sourceReader       = StringSetting       ("-Xsource-reader", "classname", "Specify a custom method for reading source files.", "")
+  val reporter           = StringSetting       ("-Xreporter", "classname", "Specify a custom reporter for compiler messages.", "scala.tools.nsc.reporters.ConsoleReporter")
   val strictInference    = BooleanSetting      ("-Xstrict-inference", "Don't infer known-unsound types")
   val source             = ScalaVersionSetting ("-Xsource", "version", "Treat compiler input as Scala source for the specified version, see SI-8126.", initial = ScalaVersion("2.11"))
 

src/reflect/scala/reflect/internal/Reporting.scala

@@ -8,11 +8,11 @@ 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.
+ *  All forwarding methods should be marked final,
+ *  but some subclasses out of our reach stil override them.
  *
- * Eventually, this interface should be reduced to one method: `reporter`,
- * and clients should indirect themselves (reduce duplication of forwarders).
+ *  Eventually, this interface should be reduced to one method: `reporter`,
+ *  and clients should indirect themselves (reduce duplication of forwarders).
  */
 trait Reporting { self : Positions =>
   def reporter: Reporter
@@ -71,8 +71,8 @@ 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.
+ *  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
@@ -101,7 +101,10 @@ abstract class Reporter {
     resetCount(ERROR)
   }
 
-  def flush(): Unit = { }
+  def flush(): Unit = ()
+
+  /** Finish reporting: print summaries, release resources. */
+  def finish(): Unit = ()
 }
 
 // TODO: move into superclass once partest cuts tie on Severity

src/reflect/scala/reflect/internal/util/ScalaClassLoader.scala

@@ -11,7 +11,8 @@ import java.lang.reflect.{ Constructor, Modifier, Method }
 import java.io.{ File => JFile }
 import java.net.{ URLClassLoader => JURLClassLoader }
 import java.net.URL
-import scala.reflect.runtime.ReflectionUtils.unwrapHandler
+import scala.reflect.internal.FatalError
+import scala.reflect.runtime.ReflectionUtils.{ show, unwrapHandler }
 import ScalaClassLoader._
 import scala.util.control.Exception.{ catching }
 import scala.language.implicitConversions
@@ -46,6 +47,33 @@ trait ScalaClassLoader extends JClassLoader {
   def create(path: String): AnyRef =
     tryToInitializeClass[AnyRef](path).map(_.newInstance()).orNull
 
+  /** Create an instance with ctor args, or invoke errorFn before throwing. */
+  def create[T <: AnyRef : ClassTag](path: String, errorFn: String => Unit)(args: AnyRef*): T = {
+    def fail(msg: String) = error(msg, new IllegalArgumentException(msg))
+    def error(msg: String, e: Throwable) = { errorFn(msg) ; throw e }
+    try {
+      val clazz = Class.forName(path, /*initialize =*/ true, /*loader =*/ this)
+      if (classTag[T].runtimeClass isAssignableFrom clazz) {
+        val ctor = {
+          val maybes = clazz.getConstructors filter (c => c.getParameterCount == args.size &&
+            (c.getParameterTypes zip args).forall { case (k, a) => k isAssignableFrom a.getClass })
+          if (maybes.size == 1) maybes.head
+          else fail(s"Constructor must accept arg list (${args map (_.getClass.getName) mkString ", "}): ${path}")
+        }
+        (ctor.newInstance(args: _*)).asInstanceOf[T]
+      } else {
+        errorFn(s"""Loader for ${classTag[T]}:   [${show(classTag[T].runtimeClass.getClassLoader)}]
+                   |Loader for ${clazz.getName}: [${show(clazz.getClassLoader)}]""".stripMargin)
+        fail(s"Not a ${classTag[T]}: ${path}")
+      }
+    } catch {
+      case e: ClassNotFoundException =>
+        error(s"Class not found: ${path}", e)
+      case e @ (_: LinkageError | _: ReflectiveOperationException) =>
+        error(s"Unable to create instance: ${path}: ${e.toString}", e)
+    }
+  }
+
   /** The actual bytes for a class file, or an empty array if it can't be found. */
   def classBytes(className: String): Array[Byte] = classAsStream(className) match {
     case null   => Array()