SI-8503 -version is info setting

And the Scala runner exits with 0 for info settings.

Producing the version string is consolidated.

The compiler driver uses the default settings hook to
short-circuit on -version.  That's to avoid creating
the compiler; really it should check shouldStopWithInfo
first, as the runner does.

1 files changed, 63 insertions, 65 deletions

diff --git a/src/repl/scala/tools/nsc/MainGenericRunner.scala b/src/repl/scala/tools/nsc/MainGenericRunner.scala
index 43f0ea1256..34057ed341 100644
--- a/src/repl/scala/tools/nsc/MainGenericRunner.scala
+++ b/src/repl/scala/tools/nsc/MainGenericRunner.scala
@@ -8,7 +8,6 @@ package tools.nsc
 
 import io.{ File }
 import util.{ ClassPath, ScalaClassLoader }
-import Properties.{ versionString, copyrightString }
 import GenericRunnerCommand._
 
 object JarRunner extends CommonRunner {
@@ -28,79 +27,78 @@ object JarRunner extends CommonRunner {
 }
 
 /** An object that runs Scala code.  It has three possible
-  * sources for the code to run: pre-compiled code, a script file,
-  * or interactive entry.
-  */
+ *  sources for the code to run: pre-compiled code, a script file,
+ *  or interactive entry.
+ */
 class MainGenericRunner {
-  def errorFn(ex: Throwable): Boolean = {
-    ex.printStackTrace()
-    false
-  }
-  def errorFn(str: String): Boolean = {
-    Console.err println str
-    false
+  def errorFn(str: String, e: Option[Throwable] = None, isFailure: Boolean = true): Boolean = {
+    if (str.nonEmpty) Console.err println str
+    e foreach (_.printStackTrace())
+    !isFailure
   }
 
   def process(args: Array[String]): Boolean = {
     val command = new GenericRunnerCommand(args.toList, (x: String) => errorFn(x))
-    import command.{ settings, howToRun, thingToRun }
-    def sampleCompiler = new Global(settings)   // def so its not created unless needed
-
-    if (!command.ok)                      return errorFn("\n" + command.shortUsageMsg)
-    else if (settings.version)            return errorFn("Scala code runner %s -- %s".format(versionString, copyrightString))
-    else if (command.shouldStopWithInfo)  return errorFn(command getInfoMessage sampleCompiler)
-
-    def isE   = !settings.execute.isDefault
-    def dashe = settings.execute.value
-
-    def isI   = !settings.loadfiles.isDefault
-    def dashi = settings.loadfiles.value
-
-    // Deadlocks on startup under -i unless we disable async.
-    if (isI)
-      settings.Yreplsync.value = true
-
-    def combinedCode  = {
-      val files   = if (isI) dashi map (file => File(file).slurp()) else Nil
-      val str     = if (isE) List(dashe) else Nil
-
-      files ++ str mkString "\n\n"
-    }
-
-    def runTarget(): Either[Throwable, Boolean] = howToRun match {
-      case AsObject =>
-        ObjectRunner.runAndCatch(settings.classpathURLs, thingToRun, command.arguments)
-      case AsScript =>
-        ScriptRunner.runScriptAndCatch(settings, thingToRun, command.arguments)
-      case AsJar    =>
-        JarRunner.runJar(settings, thingToRun, command.arguments)
-      case Error =>
-        Right(false)
-      case _  =>
-        // We start the repl when no arguments are given.
-        Right(new interpreter.ILoop process settings)
+    import command.{ settings, howToRun, thingToRun, shortUsageMsg, shouldStopWithInfo }
+    def sampleCompiler = new Global(settings)   // def so it's not created unless needed
+
+    def run(): Boolean = {
+      def isE   = !settings.execute.isDefault
+      def dashe = settings.execute.value
+
+      def isI   = !settings.loadfiles.isDefault
+      def dashi = settings.loadfiles.value
+
+      // Deadlocks on startup under -i unless we disable async.
+      if (isI)
+        settings.Yreplsync.value = true
+
+      def combinedCode  = {
+        val files   = if (isI) dashi map (file => File(file).slurp()) else Nil
+        val str     = if (isE) List(dashe) else Nil
+
+        files ++ str mkString "\n\n"
+      }
+
+      def runTarget(): Either[Throwable, Boolean] = howToRun match {
+        case AsObject =>
+          ObjectRunner.runAndCatch(settings.classpathURLs, thingToRun, command.arguments)
+        case AsScript =>
+          ScriptRunner.runScriptAndCatch(settings, thingToRun, command.arguments)
+        case AsJar    =>
+          JarRunner.runJar(settings, thingToRun, command.arguments)
+        case Error =>
+          Right(false)
+        case _  =>
+          // We start the repl when no arguments are given.
+          Right(new interpreter.ILoop process settings)
+      }
+
+      /** If -e and -i were both given, we want to execute the -e code after the
+       *  -i files have been included, so they are read into strings and prepended to
+       *  the code given in -e.  The -i option is documented to only make sense
+       *  interactively so this is a pretty reasonable assumption.
+       *
+       *  This all needs a rewrite though.
+       */
+      if (isE) {
+        ScriptRunner.runCommand(settings, combinedCode, thingToRun +: command.arguments)
+      }
+      else runTarget() match {
+        case Left(ex) => errorFn("", Some(ex))  // there must be a useful message of hope to offer here
+        case Right(b) => b
+      }
     }
 
-    /** If -e and -i were both given, we want to execute the -e code after the
-     *  -i files have been included, so they are read into strings and prepended to
-     *  the code given in -e.  The -i option is documented to only make sense
-     *  interactively so this is a pretty reasonable assumption.
-     *
-     *  This all needs a rewrite though.
-     */
-    if (isE) {
-      ScriptRunner.runCommand(settings, combinedCode, thingToRun +: command.arguments)
-    }
-    else runTarget() match {
-      case Left(ex) => errorFn(ex)
-      case Right(b) => b
-    }
+    if (!command.ok)
+      errorFn(f"%n$shortUsageMsg")
+    else if (shouldStopWithInfo)
+      errorFn(command getInfoMessage sampleCompiler, isFailure = false)
+    else
+      run()
   }
 }
 
 object MainGenericRunner extends MainGenericRunner {
-  def main(args: Array[String]) {
-    if (!process(args))
-      sys.exit(1)
-  }
+  def main(args: Array[String]): Unit = if (!process(args)) sys.exit(1)
 }