Trying to get fsc doing the right thing with re...

Trying to get fsc doing the right thing with respect to absolute and
relative paths. My knowledge of the problem had heretofore been second
hand, and my understanding of it incomplete. The real problem I have
determined is that there are a bunch of different things which go wrong
if relative paths start being resolved from a different base, each of
which needs custom handling.

  classpath-style options, e.g. fsc -cp ../foo.jar
  path-style options, e.g. fsc -d ../mydir
  file arguments, e.g. fsc ../foo.scala

So it was more work than I had realized, or I probably wouldn't have
even touched it. But now it seems to be working as one would want. I
also poured some readability onto the fsc help output.

Closes #4395, no review, but community input would be great.

6 files changed, 115 insertions, 50 deletions

diff --git a/src/compiler/scala/tools/nsc/CompileClient.scala b/src/compiler/scala/tools/nsc/CompileClient.scala
index 9987eb0204..fd4f777890 100644
--- a/src/compiler/scala/tools/nsc/CompileClient.scala
+++ b/src/compiler/scala/tools/nsc/CompileClient.scala
@@ -16,18 +16,21 @@ import sys.SystemProperties.preferIPv4Stack
 class StandardCompileClient extends HasCompileSocket with CompileOutputCommon {
   lazy val compileSocket: CompileSocket = CompileSocket
 
-  val versionMsg  = "Fast " + Properties.versionMsg
-  var verbose = false
+  val versionMsg = "Fast " + Properties.versionMsg
+  var verbose    = false
 
   def process(args: Array[String]): Int = {
-    val fscArgs = args.toList
-    val settings = new FscSettings
-    val command  = new CompilerCommand(fscArgs, settings)
-    verbose = settings.verbose.value
-    val shutdown = settings.shutdown.value
-    val vmArgs = settings.jvmargs.unparse ++ settings.defines.unparse ++ (
-      if (settings.preferIPv4.value) List("-D%s=true".format(preferIPv4Stack.key)) else Nil
-    )
+    // Trying to get out in front of the log messages in case we're
+    // going from verbose to not verbose.
+    verbose = (args contains "-verbose")
+
+    val settings     = new FscSettings(Console.println)
+    val command      = new OfflineCompilerCommand(args.toList, settings)
+    val shutdown     = settings.shutdown.value
+    val extraVmArgs  = if (settings.preferIPv4.value) List("-D%s=true".format(preferIPv4Stack.key)) else Nil
+
+    val vmArgs  = settings.jvmargs.unparse ++ settings.defines.unparse ++ extraVmArgs
+    val fscArgs = args.toList ++ command.extraFscArgs
 
     if (settings.version.value) {
       Console println versionMsg
@@ -35,7 +38,8 @@ class StandardCompileClient extends HasCompileSocket with CompileOutputCommon {
     }
 
     info(versionMsg)
-    info(fscArgs.mkString("[Given arguments: ", " ", "]"))
+    info(args.mkString("[Given arguments: ", " ", "]"))
+    info(fscArgs.mkString("[Transformed arguments: ", " ", "]"))
     info(vmArgs.mkString("[VM arguments: ", " ", "]"))
 
     val socket =
diff --git a/src/compiler/scala/tools/nsc/CompileServer.scala b/src/compiler/scala/tools/nsc/CompileServer.scala
index a34be6226b..866975b414 100644
--- a/src/compiler/scala/tools/nsc/CompileServer.scala
+++ b/src/compiler/scala/tools/nsc/CompileServer.scala
@@ -21,7 +21,9 @@ import settings.FscSettings
  */
 class StandardCompileServer extends SocketServer {
   lazy val compileSocket: CompileSocket = CompileSocket
+
   private var compiler: Global = null
+  private def clearCompiler() = compiler = null
 
   var reporter: ConsoleReporter = _
   var shutdown = false
@@ -58,7 +60,7 @@ class StandardCompileServer extends SocketServer {
     (totalMemory - freeMemory).toDouble / maxMemory.toDouble > MaxCharge
   }
 
-  protected def newOfflineCompilerCommand(arguments: List[String], settings: Settings) =
+  protected def newOfflineCompilerCommand(arguments: List[String], settings: FscSettings): OfflineCompilerCommand =
     new OfflineCompilerCommand(arguments, settings)
 
   /** Problematically, Settings are only considered equal if every setting
@@ -69,7 +71,7 @@ class StandardCompileServer extends SocketServer {
    *  and which do not interestingly influence compilation products.
    */
   def unequalSettings(s1: Settings, s2: Settings): Set[Settings#Setting] = {
-    val ignoreSettings = Set("-d", "-encoding", "-verbose")
+    val ignoreSettings = Set("-d", "-encoding", "-currentDir")
     def trim (s: Settings): Set[Settings#Setting] = (
       s.userSetSettings.toSet[Settings#Setting] filterNot (ss => ignoreSettings exists (ss respondsTo _))
     )
@@ -80,7 +82,6 @@ class StandardCompileServer extends SocketServer {
   }
 
   def session() {
-    printMemoryStats()
     val password        = compileSocket getPassword port
     val guessedPassword = in.readLine()
     val input           = in.readLine()
@@ -92,29 +93,34 @@ class StandardCompileServer extends SocketServer {
     if (input == null || password != guessedPassword)
       return
 
-    val args     = input.split("\0", -1).toList
-    val settings = new FscSettings(fscError)
-    val command  = newOfflineCompilerCommand(args, settings)
+    val args        = input.split("\0", -1).toList
+    val newSettings = new FscSettings(fscError)
+    this.verbose    = newSettings.verbose.value
+    val command     = newOfflineCompilerCommand(args, newSettings)
+
+    info("Settings after normalizing paths: " + newSettings)
+    printMemoryStats()
 
     // Update the idle timeout if given
-    if (!settings.idleMins.isDefault) {
-      val mins = settings.idleMins.value
+    if (!newSettings.idleMins.isDefault) {
+      val mins = newSettings.idleMins.value
       if (mins == 0) echo("Disabling idle timeout on compile server.")
       else echo("Setting idle timeout to " + mins + " minutes.")
 
       this.idleMinutes = mins
     }
-    if (settings.shutdown.value) {
+    if (newSettings.shutdown.value) {
       shutdown = true
       return out.println("[Compile server exited]")
     }
-    if (settings.reset.value) {
-      compiler = null
-      return out.println("[Compile server was reset]")
+    if (newSettings.reset.value) {
+      clearCompiler()
+      out.println("[Compile server was reset]")
+      if (command.files.isEmpty)
+        return
     }
-    this.verbose = settings.verbose.value
 
-    reporter = new ConsoleReporter(command.settings, in, out) {
+    reporter = new ConsoleReporter(newSettings, in, out) {
       // disable prompts, so that compile server cannot block
       override def displayPrompt = ()
     }
@@ -124,7 +130,7 @@ class StandardCompileServer extends SocketServer {
         info("[Compiler version: " + Properties.versionString + ".]")
         return false
       }
-      val unequal = unequalSettings(command.settings, compiler.settings)
+      val unequal = unequalSettings(newSettings, compiler.settings)
       if (unequal.nonEmpty) {
         info("[Replacing compiler with new instance because settings are unequal.]")
         info("[Asymmetric settings: " + unequal.mkString(", ") + "]")
@@ -133,24 +139,26 @@ class StandardCompileServer extends SocketServer {
     }
 
     if (command.shouldStopWithInfo)
-      reporter.info(null, command.getInfoMessage(newGlobal(command.settings, reporter)), true)
+      reporter.info(null, command.getInfoMessage(newGlobal(newSettings, reporter)), true)
     else if (command.files.isEmpty)
       reporter.info(null, command.usageMsg, true)
     else {
       if (isCompilerReusable) {
-        compiler.settings = command.settings
+        info("[Reusing existing Global instance.]")
+        compiler.settings = newSettings
         compiler.reporter = reporter
       }
       else {
-        compiler = newGlobal(command.settings, reporter)
+        compiler = newGlobal(newSettings, reporter)
       }
       val c = compiler
       try new c.Run() compile command.files
       catch {
         case ex @ FatalError(msg) =>
           reporter.error(null, "fatal error: " + msg)
-          compiler = null
+          clearCompiler()
         case ex =>
+          warn("Compile server encountered fatal condition: " + ex)
           shutdown = true
           throw ex
       }
@@ -158,7 +166,7 @@ class StandardCompileServer extends SocketServer {
     reporter.printSummary()
     if (isMemoryFullEnough) {
       info("Nulling out compiler due to memory utilization.")
-      compiler = null
+      clearCompiler()
     }
   }
 }
diff --git a/src/compiler/scala/tools/nsc/CompilerCommand.scala b/src/compiler/scala/tools/nsc/CompilerCommand.scala
index 1c0fd8b9de..f2c217e290 100644
--- a/src/compiler/scala/tools/nsc/CompilerCommand.scala
+++ b/src/compiler/scala/tools/nsc/CompilerCommand.scala
@@ -46,22 +46,30 @@ class CompilerCommand(arguments: List[String], val settings: Settings) {
     |
   """.stripMargin.trim + "\n\n"
 
+  val shortUsage = "Usage: %s <options> <source files>" format cmdName
+  def createUsagePreface(shouldExplain: Boolean) =
+    if (shouldExplain) shortUsage + "\n" + explainAdvanced else ""
+
   /** Creates a help message for a subset of options based on cond */
-  def createUsageMsg(label: String, shouldExplain: Boolean, cond: Setting => Boolean): String = {
+  def createUsageMsg(cond: Setting => Boolean): String = {
     def helpStr(s: Setting) = format(s.helpSyntax) + "  " + s.helpDescription
-
-    val usage         = "Usage: %s <options> <source files>\n" format cmdName
-    val explain       = if (shouldExplain) explainAdvanced else ""
-    val prefix        = label + " options include:\n  "
-
     // Separating out any debugging options from others for easier reading
     val (debug, rest) = (settings.visibleSettings filter cond).toList sortBy (_.name) partition (_.isForDebug)
 
-    (rest map helpStr).mkString(usage + explain + prefix, "\n  ", "\n") + (
+    (rest map helpStr).mkString("", "\n  ", "\n") + (
       if (debug.isEmpty) ""
       else (debug map helpStr).mkString("\nAdditional debug settings:\n  ", "\n  ", "\n")
     )
   }
+  def createUsageMsg(label: String, shouldExplain: Boolean, cond: Setting => Boolean): String = {
+    val prefix = List(
+      Some(shortUsage),
+      Some(explainAdvanced) filter (_ => shouldExplain),
+      Some(label + " options include:\n  ")
+    ).flatten mkString "\n"
+
+    prefix + createUsageMsg(cond)
+  }
 
   /** Messages explaining usage and options */
   def usageMsg    = createUsageMsg("where possible standard", false, _.isStandard)
diff --git a/src/compiler/scala/tools/nsc/OfflineCompilerCommand.scala b/src/compiler/scala/tools/nsc/OfflineCompilerCommand.scala
index 786bcb1eb5..ef974da965 100644
--- a/src/compiler/scala/tools/nsc/OfflineCompilerCommand.scala
+++ b/src/compiler/scala/tools/nsc/OfflineCompilerCommand.scala
@@ -5,10 +5,38 @@
 
 package scala.tools.nsc
 
+import settings.FscSettings
+import io.Directory
+
 /** A compiler command for the offline compiler.
  *
  * @author Martin Odersky and Lex Spoon
  */
-class OfflineCompilerCommand(arguments: List[String], settings: Settings) extends CompilerCommand(arguments, settings) {
+class OfflineCompilerCommand(arguments: List[String], settings: FscSettings) extends CompilerCommand(arguments, settings) {
+  import settings.currentDir
+  def extraFscArgs = List(currentDir.name, currentDir.value)
+
+  locally {
+    // if -current-dir is unset, we're on the client and need to obtain it.
+    if (currentDir.isDefault) {
+      // Prefer env variable PWD to system property user.dir because the former
+      // deals better with paths not rooted at / (filesystem mounts.)
+      val baseDirectory = System.getenv("PWD") match {
+        case null   => Directory.Current getOrElse Directory("/")
+        case dir    => Directory(dir)
+      }
+      currentDir.value = baseDirectory.path
+    }
+    else {
+      // Otherwise we're on the server and will use it to absolutize the paths.
+      settings.absolutize(currentDir.value)
+    }
+  }
+
   override def cmdName = "fsc"
+  override def usageMsg = (
+    createUsageMsg("where possible fsc", false, x => x.isStandard && settings.isFscSpecific(x.name)) +
+    "\nStandard scalac options also available:\n  " +
+    createUsageMsg(x => x.isStandard && !settings.isFscSpecific(x.name))
+  )
 }
diff --git a/src/compiler/scala/tools/nsc/settings/FscSettings.scala b/src/compiler/scala/tools/nsc/settings/FscSettings.scala
index a219148b16..bb62750026 100644
--- a/src/compiler/scala/tools/nsc/settings/FscSettings.scala
+++ b/src/compiler/scala/tools/nsc/settings/FscSettings.scala
@@ -8,28 +8,45 @@ package nsc
 package settings
 
 import util.ClassPath
+import io.{ Directory, Path, AbstractFile }
 
 class FscSettings(error: String => Unit) extends Settings(error) {
   outer =>
 
-  def this() = this(Console.println)
+  locally {
+    disable(prompt)
+    disable(resident)
+  }
 
+  val currentDir   = StringSetting ("-current-dir", "path", "Base directory for resolving relative paths", "").internalOnly()
   val reset        = BooleanSetting("-reset",    "Reset compile server caches")
   val shutdown     = BooleanSetting("-shutdown", "Shutdown compile server")
   val server       = StringSetting ("-server",   "hostname:portnumber", "Specify compile server socket", "")
-  val preferIPv4   = BooleanSetting("-ipv4", "Use IPv4 rather than IPv6 for the server socket")
-  val absClasspath = BooleanSetting("-absolute-cp", "Make classpath elements absolute paths before sending to server") .
-      withPostSetHook (_ => absolutizeClasspath())
+  val preferIPv4   = BooleanSetting("-ipv4",     "Use IPv4 rather than IPv6 for the server socket")
   val idleMins     = IntSetting    ("-max-idle", "Set idle timeout in minutes for fsc (use 0 for no timeout)",
                                               30, Some(0, Int.MaxValue), (_: String) => None)
 
-  disable(prompt)
-  disable(resident)
+  // For improved help output, separating fsc options from the others.
+  def fscSpecific = Set[Settings#Setting](
+    currentDir, reset, shutdown, server, preferIPv4, idleMins
+  )
+  val isFscSpecific: String => Boolean = fscSpecific map (_.name)
+
+  /** If a setting (other than a PathSetting) represents a path or paths.
+   *  For use in absolutization.
+   */
+  private def holdsPath = Set[Settings#Setting](
+    d, dependencyfile, pluginsDir, Ygenjavap
+  )
 
-  // Make the classpath absolute: for going from client to server.
-  private def absolutizeClasspath() {
-    userSetSettings collect {
-      case x: PathSetting => x.value = ClassPath.makeAbsolute(x.value)
+  /** All user set settings rewritten with absolute paths. */
+  def absolutize(root: Path) {
+    def rewrite(p: String) = (root resolve Path(p)).normalize.path
+    userSetSettings foreach {
+      case p: OutputSetting => p.outputDirs setSingleOutput AbstractFile.getDirectory(rewrite(p.value))
+      case p: PathSetting   => p.value = ClassPath.map(p.value, rewrite)
+      case p: StringSetting => if (holdsPath(p)) p.value = rewrite(p.value)
+      case _                => ()
     }
   }
 }
diff --git a/src/compiler/scala/tools/nsc/settings/MutableSettings.scala b/src/compiler/scala/tools/nsc/settings/MutableSettings.scala
index b485d4725a..12b9ef7154 100644
--- a/src/compiler/scala/tools/nsc/settings/MutableSettings.scala
+++ b/src/compiler/scala/tools/nsc/settings/MutableSettings.scala
@@ -479,7 +479,7 @@ class MutableSettings(val errorFn: String => Unit) extends AbsSettings with Scal
 
   /** Set the output directory. */
   class OutputSetting private[nsc](
-    outputDirs: OutputDirs,
+    private[nsc] val outputDirs: OutputDirs,
     default: String)
     extends StringSetting("-d", "directory", "Specify where to place generated class files", default) {
       value = default