Merge pull request #1973 from JamesIry/SI-4602_2.10.x

SI-4602 Make fsc absolutize source file names

3 files changed, 75 insertions, 7 deletions

diff --git a/src/compiler/scala/tools/nsc/OfflineCompilerCommand.scala b/src/compiler/scala/tools/nsc/OfflineCompilerCommand.scala
index 8a3c531ff0..caf6ad14cf 100644
--- a/src/compiler/scala/tools/nsc/OfflineCompilerCommand.scala
+++ b/src/compiler/scala/tools/nsc/OfflineCompilerCommand.scala
@@ -33,7 +33,7 @@ class OfflineCompilerCommand(arguments: List[String], settings: FscSettings) ext
     }
     else {
       // Otherwise we're on the server and will use it to absolutize the paths.
-      settings.absolutize(currentDir.value)
+      settings.absolutize()
     }
   }
 
diff --git a/src/compiler/scala/tools/nsc/settings/FscSettings.scala b/src/compiler/scala/tools/nsc/settings/FscSettings.scala
index 06ebc20d3e..5c852ae07c 100644
--- a/src/compiler/scala/tools/nsc/settings/FscSettings.scala
+++ b/src/compiler/scala/tools/nsc/settings/FscSettings.scala
@@ -38,14 +38,25 @@ class FscSettings(error: String => Unit) extends Settings(error) {
   private def holdsPath = Set[Settings#Setting](
     d, dependencyfile, pluginsDir, Ygenjavap
   )
+  
+  override def processArguments(arguments: List[String], processAll: Boolean): (Boolean, List[String]) = {
+    val (r, args) = super.processArguments(arguments, processAll)
+    // we need to ensure the files specified with relative locations are absolutized based on the currentDir
+    (r, args map {a => absolutizePath(a)})
+  }
+  
+  /**
+   * Take an individual path and if it's not absolute turns it into an absolute path based on currentDir.
+   * If it's already absolute then it's left alone.
+   */
+  private[this] def absolutizePath(p: String) = (Path(currentDir.value) resolve Path(p)).normalize.path
 
-  /** All user set settings rewritten with absolute paths. */
-  def absolutize(root: Path) {
-    def rewrite(p: String) = (root resolve Path(p)).normalize.path
+  /** All user set settings rewritten with absolute paths based on currentDir */
+  def absolutize() {
     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 p: OutputSetting => p.outputDirs setSingleOutput AbstractFile.getDirectory(absolutizePath(p.value))
+      case p: PathSetting   => p.value = ClassPath.map(p.value, absolutizePath)
+      case p: StringSetting => if (holdsPath(p)) p.value = absolutizePath(p.value)
       case _                => ()
     }
   }
diff --git a/test/files/disabled/run/t4602.scala b/test/files/disabled/run/t4602.scala
new file mode 100644
index 0000000000..73ba231ccf
--- /dev/null
+++ b/test/files/disabled/run/t4602.scala
@@ -0,0 +1,57 @@
+import java.io.{File, FileOutputStream, BufferedOutputStream, FileWriter, ByteArrayOutputStream, PrintStream}
+import tools.nsc.{CompileClient, CompileServer}
+import java.util.concurrent.{CountDownLatch, TimeUnit}
+
+object Test extends App {
+  val startupLatch = new CountDownLatch(1)
+  // we have to explicitly launch our server because when the client launches a server it uses 
+  // the "scala" shell command meaning whatever version of scala (and whatever version of libraries)
+  // happens to be in the path gets used
+  val t = new Thread(new Runnable {
+    def run() = {
+      CompileServer.execute(() => startupLatch.countDown(), Array[String]())
+    }
+  })
+  t setDaemon true
+  t.start()
+  if (!startupLatch.await(2, TimeUnit.MINUTES))
+    sys error "Timeout waiting for server to start"
+
+  val baos = new ByteArrayOutputStream()
+  val ps = new PrintStream(baos) 
+
+  val outdir = scala.reflect.io.Directory(sys.props("partest.output"))
+  
+  val dirNameAndPath = (1 to 2).toList map {number =>
+    val name = s"Hello${number}"
+    val dir = outdir / number.toString
+    (dir, name, dir / s"${name}.scala")
+  }
+
+  dirNameAndPath foreach {case (dir, name, path) =>
+    dir.createDirectory()
+    val file = path.jfile
+    val out = new FileWriter(file)
+    try 
+      out.write(s"object ${name}\n")
+    finally 
+      out.close
+  }
+
+  val success = (scala.Console withOut ps) {
+    dirNameAndPath foreach {case (path, name, _) =>
+      CompileClient.process(Array("-verbose", "-current-dir", path.toString, s"${name}.scala"))
+    }
+
+    CompileClient.process(Array("-shutdown"))
+  }
+
+  // now make sure we got success and the correct normalized paths
+  val msg = baos.toString()
+
+  assert(success, s"got a failure. Full results were: \n${msg}")
+  dirNameAndPath foreach {case (_, _, path) => 
+    val expected = s"Input files after normalizing paths: ${path}"
+    assert(msg contains expected, s"could not find '${expected}' in output. Full results were: \n${msg}")
+  }
+}