Support -d with .jar paths

Author: nicolasstucki

compiler/src/dotty/tools/backend/jvm/GenBCode.scala

@@ -34,7 +34,7 @@ import dotty.tools.dotc.util.{DotClass, Positions}
 import tpd._
 import StdNames._
 
-import dotty.tools.io.{AbstractFile, Directory, PlainDirectory}
+import dotty.tools.io._
 
 class GenBCode extends Phase {
   def phaseName: String = "genBCode"
@@ -47,27 +47,36 @@ class GenBCode extends Phase {
     superCallsMap.put(sym, old + calls)
   }
 
-  def outputDir(implicit ctx: Context): AbstractFile =
-    new PlainDirectory(ctx.settings.outputDir.value)
+  def outputDir(implicit ctx: Context): AbstractFile = {
+    val path = ctx.settings.outputDir.value
+    if (path.isDirectory) new PlainDirectory(Directory(path))
+    else new PlainFile(path)
+  }
 
-  private[this] var classFileOutput: AbstractFile = _
+  private[this] var classOutput: AbstractFile = _
 
   def run(implicit ctx: Context): Unit = {
     new GenBCodePipeline(entryPoints.toList,
-        new DottyBackendInterface(classFileOutput, superCallsMap.toMap)(ctx))(ctx).run(ctx.compilationUnit.tpdTree)
+        new DottyBackendInterface(classOutput, superCallsMap.toMap)(ctx))(ctx).run(ctx.compilationUnit.tpdTree)
     entryPoints.clear()
   }
 
   override def runOn(units: List[CompilationUnit])(implicit ctx: Context) = {
-    val out = outputDir
-    lazy val tmp = out.subdirectoryNamed("tmp-" + System.currentTimeMillis().toHexString)
-    classFileOutput = if (ctx.settings.XlinkOptimise.value) tmp else out
-    val res = super.runOn(units)
-    if (ctx.settings.XlinkOptimise.value) {
-      Jar.create(new File(out.fileNamed("linked.jar").file), new Directory(classFileOutput.file), mainClass = "")
-      tmp.delete()
+    val output = outputDir
+    if (output.isDirectory) {
+      classOutput = output
+      val res = super.runOn(units)
+      classOutput = null
+      res
+    } else {
+      assert(output.hasExtension("jar"))
+      classOutput = new PlainDirectory(Path(Path(output.file).parent + "/tmp-jar-" + System.currentTimeMillis().toHexString).createDirectory())
+      val res = super.runOn(units)
+      Jar.create(new File(ctx.settings.outputDir.value.jfile), new Directory(classOutput.file), mainClass = "")
+      classOutput.delete()
+      classOutput = null
+      res
     }
-    res
   }
 }
 

compiler/src/dotty/tools/dotc/config/ScalaSettings.scala

@@ -18,7 +18,7 @@ class ScalaSettings extends Settings.SettingGroup {
   val javaextdirs = PathSetting("-javaextdirs", "Override java extdirs classpath.", Defaults.javaExtDirs)
   val sourcepath = PathSetting("-sourcepath", "Specify location(s) of source files.", "") // Defaults.scalaSourcePath
   val classpath = PathSetting("-classpath", "Specify where to find user class files.", defaultClasspath) withAbbreviation "-cp"
-  val outputDir = DirectorySetting("-d", "directory|jar", "destination for generated classfiles.", Directory(Path(".")))
+  val outputDir = DirectoryJarSetting("-d", "directory|jar", "destination for generated classfiles.", Directory(Path(".")))
   val priorityclasspath = PathSetting("-priorityclasspath", "class path that takes precedence over all other paths (or testing only)", "")
 
   /** Other settings */

compiler/src/dotty/tools/dotc/config/Settings.scala

@@ -22,7 +22,7 @@ object Settings {
   val ListTag = ClassTag(classOf[List[_]])
   val VersionTag = ClassTag(classOf[ScalaVersion])
   val OptionTag = ClassTag(classOf[Option[_]])
-  val DirectoryTag = ClassTag(classOf[Directory])
+  val DirectoryJarTag = ClassTag(classOf[Path])
 
   class SettingsState(initialValues: Seq[Any]) {
     private[this] var values = ArrayBuffer(initialValues: _*)
@@ -161,9 +161,10 @@ object Settings {
             case Success(v) => update(v, args)
             case Failure(ex) => fail(ex.getMessage, args)
           }
-        case (DirectoryTag, arg :: args) =>
+        case (DirectoryJarTag, arg :: args) =>
           val path = Path(arg)
           if (path.isDirectory) update(Directory(path), args)
+          else if (path.extension == "jar") update(path, args)
           else fail(s"'$arg' does not exist or is not a directory", args)
         case (_, Nil) =>
           missingArg
@@ -286,7 +287,7 @@ object Settings {
     def OptionSetting[T: ClassTag](name: String, descr: String): Setting[Option[T]] =
       publish(Setting(name, descr, None, propertyClass = Some(implicitly[ClassTag[T]].runtimeClass)))
 
-    def DirectorySetting(name: String, helpArg: String, descr: String, default: Directory): Setting[Directory] =
+    def DirectoryJarSetting(name: String, helpArg: String, descr: String, default: Directory): Setting[Path] =
       publish(Setting(name, descr, default, helpArg))
   }
 }

compiler/src/dotty/tools/dotc/transform/LinkAll.scala

@@ -34,7 +34,7 @@ class LinkAll extends Phase {
       }
     }
 
-    if (ctx.settings.XlinkOptimise.value) allUnits(Set.empty, units.toSet, Set.empty)
+    if (doLink) allUnits(Set.empty, units.toSet, Set.empty)
     else units
   }
 
@@ -62,6 +62,16 @@ class LinkAll extends Phase {
       else acc + topClass
     }
   }
+
+  private def doLink(implicit ctx: Context): Boolean = {
+    val link = ctx.settings.XlinkOptimise
+    if (link.value) {
+      val out = ctx.settings.outputDir
+      if (out.value.extension != "jar")
+        ctx.error("With " + link.name + " the output directory " + out.name + " should be a .jar\n" + out.value)
+      true
+    } else false
+  }
 }
 
 object LinkAll {

compiler/src/dotty/tools/repl/ReplDriver.scala

@@ -108,8 +108,11 @@ class ReplDriver(settings: Array[String],
     val outDir: AbstractFile = {
       if (rootCtx.settings.outputDir.isDefault(rootCtx))
         new VirtualDirectory("(memory)", None)
-      else
-        new PlainDirectory(rootCtx.settings.outputDir.value(rootCtx))
+      else {
+        val path = rootCtx.settings.outputDir.value(rootCtx)
+        assert(path.isDirectory)
+        new PlainDirectory(Directory(path))
+      }
     }
     compiler = new ReplCompiler(outDir)
     rendering = new Rendering(compiler, classLoader)

compiler/test/dotty/tools/dotc/JarOutputTests.scala

@@ -0,0 +1,24 @@
+package dotty
+package tools
+package dotc
+
+import java.io.{File => JFile}
+
+import org.junit.Assert._
+import org.junit.Test
+import vulpix.TestConfiguration.mkClassPath
+
+class JarOutputTests {
+
+  @Test def jarOutput: Unit = {
+    val classPath = mkClassPath(Jars.dottyTestDeps)
+    val source = "../tests/neg/nolib/Foo.scala"
+    val out = new JFile("../out/jaredFoo.jar")
+    if (out.exists()) out.delete()
+    val options = Array("-classpath", classPath, "-d", out.toString, source)
+    val reporter = Main.process(options)
+    assertEquals(0, reporter.errorCount)
+    assertTrue(out.exists())
+  }
+
+}

compiler/test/dotty/tools/dotc/MissingCoreLibTests.scala

@@ -12,7 +12,7 @@ class MissingCoreLibTests {
   @Test def missingDottyLib: Unit = {
     val classPath = mkClassPath(Jars.dottyCompiler :: Jars.dottyInterfaces :: Jars.dottyExtras) // missing Jars.dottyLib
     val source = "../tests/neg/nolib/Foo.scala"
-    val options = Array("-classpath", classPath, source)
+    val options = Array("-classpath", classPath, "-d", "../out/", source)
     val reporter = Main.process(options)
     assertEquals(1, reporter.errorCount)
     val errorMessage = reporter.allErrors.head.message

compiler/test/dotty/tools/vulpix/ParallelTesting.scala

@@ -52,10 +52,7 @@ trait ParallelTesting extends RunnerOrchestration { self =>
     def outDir: JFile
     def flags: TestFlags
 
-    def runClassPath: String = {
-      val out = outDir.getAbsolutePath + (if (flags.isLinkedOptimised) "/linked.jar" else "")
-      out + ":" + flags.runClassPath
-    }
+    def runClassPath: String = outDir.getAbsolutePath + ":" + flags.runClassPath
 
     def title: String = self match {
       case self: JointCompilationSource =>
@@ -1008,18 +1005,22 @@ trait ParallelTesting extends RunnerOrchestration { self =>
   }
 
   /** Create out directory for directory `d` */
-  private def createOutputDirsForDir(d: JFile, sourceDir: JFile, outDir: String): JFile = {
+  private def createOutputDirsForDir(d: JFile, sourceDir: JFile, outDir: String, flags: TestFlags): JFile = {
     val targetDir = new JFile(outDir + s"${sourceDir.getName}/${d.getName}")
     targetDir.mkdirs()
-    targetDir
+    jaredIfNeeded(targetDir, flags)
   }
 
   /** Create out directory for `file` */
-  private def createOutputDirsForFile(file: JFile, sourceDir: JFile, outDir: String): JFile = {
+  private def createOutputDirsForFile(file: JFile, sourceDir: JFile, outDir: String, flags: TestFlags): JFile = {
     val uniqueSubdir = file.getName.substring(0, file.getName.lastIndexOf('.'))
     val targetDir = new JFile(outDir + s"${sourceDir.getName}/$uniqueSubdir")
     targetDir.mkdirs()
-    targetDir
+    jaredIfNeeded(targetDir, flags)
+  }
+
+  private def jaredIfNeeded(targetDir: JFile, flags: TestFlags): JFile = {
+    new JFile(targetDir + (if (flags.isLinkTest) "/linked.jar" else ""))
   }
 
   /** Make sure that directory string is as expected */
@@ -1081,7 +1082,7 @@ trait ParallelTesting extends RunnerOrchestration { self =>
       callingMethod,
       Array(sourceFile),
       flags,
-      createOutputDirsForFile(sourceFile, parent, outDir)
+      createOutputDirsForFile(sourceFile, parent, outDir, flags)
     )
     new CompilationTest(target)
   }
@@ -1161,9 +1162,11 @@ trait ParallelTesting extends RunnerOrchestration { self =>
 
     val (dirs, files) = compilationTargets(sourceDir)
 
+    def createOutputDirsFor(f: JFile): JFile = createOutputDirsForFile(f, sourceDir, outDir, flags)
+
     val targets =
-      files.map(f => JointCompilationSource(callingMethod, Array(f), flags, createOutputDirsForFile(f, sourceDir, outDir))) ++
-      dirs.map(dir => SeparateCompilationSource(callingMethod, dir, flags, createOutputDirsForDir(dir, sourceDir, outDir)))
+      files.map(f => JointCompilationSource(callingMethod, Array(f), flags, createOutputDirsForFile(f, sourceDir, outDir, flags))) ++
+      dirs.map(dir => SeparateCompilationSource(callingMethod, dir, flags, createOutputDirsForDir(dir, sourceDir, outDir, flags)))
 
     // Create a CompilationTest and let the user decide whether to execute a pos or a neg test
     new CompilationTest(targets)
@@ -1182,7 +1185,7 @@ trait ParallelTesting extends RunnerOrchestration { self =>
     val (_, files) = compilationTargets(sourceDir)
 
     val targets = files.map { file =>
-      JointCompilationSource(callingMethod, Array(file), flags, createOutputDirsForFile(file, sourceDir, outDir))
+      JointCompilationSource(callingMethod, Array(file), flags, createOutputDirsForFile(file, sourceDir, outDir, flags))
     }
 
     // Create a CompilationTest and let the user decide whether to execute a pos or a neg test

compiler/test/dotty/tools/vulpix/TestFlags.scala

@@ -13,7 +13,7 @@ final case class TestFlags(
 
   def all: Array[String] = Array("-classpath", defaultClassPath) ++ options
 
-  def isLinkedOptimised: Boolean = options.contains("-Xlink-optimise")
+  def isLinkTest: Boolean = options.contains("-Xlink-optimise")
 }
 
 object TestFlags {