Link directly to a JAR

Author: nicolasstucki

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

@@ -26,6 +26,7 @@ import Denotations._
 import Phases._
 import java.lang.AssertionError
 import java.io.{DataOutputStream, File => JFile}
+import dotty.tools.io.{Jar, File, Directory}
 
 import scala.tools.asm
 import scala.tools.asm.tree._
@@ -49,11 +50,25 @@ class GenBCode extends Phase {
   def outputDir(implicit ctx: Context): AbstractFile =
     new PlainDirectory(ctx.settings.outputDir.value)
 
+  private[this] var classFileOutput: AbstractFile = _
+
   def run(implicit ctx: Context): Unit = {
     new GenBCodePipeline(entryPoints.toList,
-        new DottyBackendInterface(outputDir, superCallsMap.toMap)(ctx))(ctx).run(ctx.compilationUnit.tpdTree)
+        new DottyBackendInterface(classFileOutput, 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()
+    }
+    res
+  }
 }
 
 class GenBCodePipeline(val entryPoints: List[Symbol], val int: DottyBackendInterface)(implicit val ctx: Context) extends BCodeSyncAndTry{

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

@@ -2,6 +2,8 @@ package dotty
 package tools
 package dotc
 
+import dotty.tools.io.Jar
+
 import java.io.{File => JFile}
 import java.nio.file.{Files, Path, Paths}
 
@@ -56,11 +58,11 @@ class LinkOptimiseTests extends ParallelTesting {
       for (check <- new JFile(sourceDir).listFiles().filter(_.toString.endsWith(checkExt))) {
         val outDir = {
           def path(str: String) = str.substring(linkDir.length, str.length - checkExt.length)
-          defaultOutputDir + testName + path(check.toString) + "/"
+          defaultOutputDir + testName + path(check.toString) + "/linked.jar"
         }
         val expectedClasses = scala.io.Source.fromFile(check).getLines().toSet
-        val actualClasses = Files.walk(Paths.get(outDir)).iterator().asScala.collect {
-          case f if f.toString.endsWith(".class") => f.toString.substring(outDir.length, f.toString.length - ".class".length)
+        val actualClasses = new Jar(outDir).iterator.collect {
+          case f if f.toString.endsWith(".class") => f.toString.substring(0, f.toString.length - ".class".length)
         }.toSet
         assertEquals(check.toString, expectedClasses, actualClasses)
       }

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

@@ -52,7 +52,10 @@ trait ParallelTesting extends RunnerOrchestration { self =>
     def outDir: JFile
     def flags: TestFlags
 
-    def runClassPath: String = outDir.getAbsolutePath + ":" + flags.runClassPath
+    def runClassPath: String = {
+      val out = outDir.getAbsolutePath + (if (flags.isLinkedOptimised) "/linked.jar" else "")
+      out + ":" + flags.runClassPath
+    }
 
     def title: String = self match {
       case self: JointCompilationSource =>

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

@@ -12,6 +12,8 @@ final case class TestFlags(
     TestFlags(defaultClassPath, runClassPath, options diff flags)
 
   def all: Array[String] = Array("-classpath", defaultClassPath) ++ options
+
+  def isLinkedOptimised: Boolean = options.contains("-Xlink-optimise")
 }
 
 object TestFlags {