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.

7 files changed, 93 insertions, 88 deletions

diff --git a/src/compiler/scala/tools/nsc/CompilerCommand.scala b/src/compiler/scala/tools/nsc/CompilerCommand.scala
index bab0768ca9..a1d0d52dcf 100644
--- a/src/compiler/scala/tools/nsc/CompilerCommand.scala
+++ b/src/compiler/scala/tools/nsc/CompilerCommand.scala
@@ -20,9 +20,12 @@ class CompilerCommand(arguments: List[String], val settings: Settings) {
   def ok    = processArgumentsResult._1
   def files = processArgumentsResult._2
 
-  /** The name of the command */
+  /** The name of the command. */
   def cmdName = "scalac"
 
+  /** A descriptive alias for version and help messages. */
+  def cmdDesc = "compiler"
+
   private def explainAdvanced = "\n" + """
     |-- Notes on option parsing --
     |Boolean settings are always false unless set.
@@ -85,7 +88,11 @@ class CompilerCommand(arguments: List[String], val settings: Settings) {
 
   def getInfoMessage(global: Global): String = {
     import settings._
-    if (help)               usageMsg + global.pluginOptionsHelp
+    import Properties.{ versionString, copyrightString } //versionFor
+    def versionFor(command: String) = f"Scala $command $versionString -- $copyrightString"
+
+    if (version)            versionFor(cmdDesc)
+    else if (help)          usageMsg + global.pluginOptionsHelp
     else if (Xhelp)         xusageMsg
     else if (Yhelp)         yusageMsg
     else if (showPlugins)   global.pluginDescriptions
diff --git a/src/compiler/scala/tools/nsc/Driver.scala b/src/compiler/scala/tools/nsc/Driver.scala
index 3ac27a42e8..6befa76b3f 100644
--- a/src/compiler/scala/tools/nsc/Driver.scala
+++ b/src/compiler/scala/tools/nsc/Driver.scala
@@ -2,26 +2,24 @@ package scala
 package tools.nsc
 
 import scala.tools.nsc.reporters.ConsoleReporter
-import Properties.{ versionString, copyrightString, residentPromptString }
+import Properties.{ versionMsg, residentPromptString }
 import scala.reflect.internal.util.FakePos
 
 abstract class Driver {
 
   val prompt = residentPromptString
 
-  val versionMsg = "Scala compiler " +
-    versionString + " -- " +
-    copyrightString
-
   var reporter: ConsoleReporter = _
   protected var command: CompilerCommand = _
   protected var settings: Settings = _
 
-  protected def scalacError(msg: String) {
+  protected def scalacError(msg: String): Unit = {
     reporter.error(FakePos("scalac"), msg + "\n  scalac -help  gives more information")
   }
 
-  protected def processSettingsHook(): Boolean = true
+  protected def processSettingsHook(): Boolean = {
+    if (settings.version) { reporter echo versionMsg ; false } else true
+  }
 
   protected def newCompiler(): Global
 
@@ -37,14 +35,12 @@ abstract class Driver {
   }
 
   def process(args: Array[String]) {
-    val ss       = new Settings(scalacError)
-    reporter     = new ConsoleReporter(ss)
+    val ss   = new Settings(scalacError)
+    reporter = new ConsoleReporter(ss)
     command  = new CompilerCommand(args.toList, ss)
     settings = command.settings
 
-    if (settings.version) {
-      reporter.echo(versionMsg)
-    } else if (processSettingsHook()) {
+    if (processSettingsHook()) {
       val compiler = newCompiler()
       try {
         if (reporter.hasErrors)
@@ -68,5 +64,4 @@ abstract class Driver {
     process(args)
     sys.exit(if (reporter.hasErrors) 1 else 0)
   }
-
 }
diff --git a/src/compiler/scala/tools/nsc/GenericRunnerCommand.scala b/src/compiler/scala/tools/nsc/GenericRunnerCommand.scala
index 253f18dec6..dbdeec809f 100644
--- a/src/compiler/scala/tools/nsc/GenericRunnerCommand.scala
+++ b/src/compiler/scala/tools/nsc/GenericRunnerCommand.scala
@@ -19,9 +19,10 @@ extends CompilerCommand(args, settings) {
   def this(args: List[String]) =
     this(args, str => Console.println("Error: " + str))
 
-  /** name of the associated compiler command */
   override def cmdName = "scala"
-  def compCmdName = "scalac"
+  override def cmdDesc = "code runner"
+
+  def compCmdName = "scalac"  // super.cmdName
 
   // change CompilerCommand behavior
   override def shouldProcessArguments: Boolean = false
diff --git a/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala b/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala
index 20ccc30ff6..d22dcacad6 100644
--- a/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala
+++ b/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala
@@ -42,7 +42,7 @@ trait ScalaSettings extends AbsScalaSettings
   def optimiseSettings = List[BooleanSetting](inline, inlineHandlers, Xcloselim, Xdce, YconstOptimization)
 
   /** If any of these settings is enabled, the compiler should print a message and exit.  */
-  def infoSettings = List[Setting](help, Xhelp, Yhelp, showPlugins, showPhases, genPhaseGraph)
+  def infoSettings = List[Setting](version, help, Xhelp, Yhelp, showPlugins, showPhases, genPhaseGraph)
 
   /** Is an info setting set? */
   def isInfo = infoSettings exists (_.isSetByUser)
diff --git a/src/interactive/scala/tools/nsc/interactive/Main.scala b/src/interactive/scala/tools/nsc/interactive/Main.scala
index c838606f02..7796c65670 100644
--- a/src/interactive/scala/tools/nsc/interactive/Main.scala
+++ b/src/interactive/scala/tools/nsc/interactive/Main.scala
@@ -12,7 +12,7 @@ package interactive
  */
 object Main extends nsc.MainClass {
   override def processSettingsHook(): Boolean = {
-    if (this.settings.Yidedebug) {
+    def run(): Unit = {
       this.settings.Xprintpos.value = true
       this.settings.Yrangepos.value = true
       val compiler = new interactive.Global(this.settings, this.reporter)
@@ -27,8 +27,9 @@ object Main extends nsc.MainClass {
         case None => reporter.reset() // Causes other compiler errors to be ignored
       }
       askShutdown
-      false
     }
-    else true
+    super.processSettingsHook() && (
+      if (this.settings.Yidedebug) { run() ; false } else true
+    )
   }
 }
diff --git a/src/library/scala/util/Properties.scala b/src/library/scala/util/Properties.scala
index d597feb898..2daa4de9a6 100644
--- a/src/library/scala/util/Properties.scala
+++ b/src/library/scala/util/Properties.scala
@@ -155,9 +155,12 @@ private[scala] trait PropertiesTrait {
   // This is looking for javac, tools.jar, etc.
   // Tries JDK_HOME first, then the more common but likely jre JAVA_HOME,
   // and finally the system property based javaHome.
-  def jdkHome              = envOrElse("JDK_HOME", envOrElse("JAVA_HOME", javaHome))
+  def jdkHome               = envOrElse("JDK_HOME", envOrElse("JAVA_HOME", javaHome))
 
-  def versionMsg            = "Scala %s %s -- %s".format(propCategory, versionString, copyrightString)
+  // private[scala] for 2.12
+  private[this] def versionFor(command: String) = f"Scala $command $versionString -- $copyrightString"
+
+  def versionMsg            = versionFor(propCategory)
   def scalaCmd              = if (isWin) "scala.bat" else "scala"
   def scalacCmd             = if (isWin) "scalac.bat" else "scalac"
 
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)
 }