Link directly to a JAR

Author: nicolasstucki

compiler/src/dotty/tools/dotc/CompilationUnit.scala

@@ -1,8 +1,6 @@
 package dotty.tools
 package dotc
 
-import dotty.tools.dotc.core.Types.Type
-import dotty.tools.dotc.core.tasty.{TastyUnpickler, TastyBuffer, TastyPickler}
 import util.SourceFile
 import ast.{tpd, untpd}
 import dotty.tools.dotc.ast.tpd.{ Tree, TreeTraverser }
@@ -28,7 +26,8 @@ object CompilationUnit {
 
   /** Make a compilation unit for top class `clsd` with the contends of the `unpickled` */
   def mkCompilationUnit(clsd: ClassDenotation, unpickled: Tree, forceTrees: Boolean)(implicit ctx: Context): CompilationUnit = {
-    val unit1 = new CompilationUnit(new SourceFile(clsd.symbol.sourceFile, Seq()))
+    val file = Option(clsd.symbol.sourceFile).getOrElse(clsd.symbol.associatedFile)
+    val unit1 = new CompilationUnit(new SourceFile(file, Seq()))
     unit1.tpdTree = unpickled
     if (forceTrees)
       force.traverse(unit1.tpdTree)

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/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/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

@@ -1005,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 */
@@ -1078,7 +1082,7 @@ trait ParallelTesting extends RunnerOrchestration { self =>
       callingMethod,
       Array(sourceFile),
       flags,
-      createOutputDirsForFile(sourceFile, parent, outDir)
+      createOutputDirsForFile(sourceFile, parent, outDir, flags)
     )
     new CompilationTest(target)
   }
@@ -1158,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)
@@ -1179,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

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

dist/bin/dotl

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+
+dotc -tasty -Xlink-optimise $@

project/Build.scala

@@ -522,9 +522,11 @@ object Build {
           case (beforeCp, rest) => beforeCp ++ rest
         }
 
-        (runMain in Compile).toTask(
-          s" dotty.tools.dotc.Main " + fullArgs.mkString(" ")
-        )
+        val main =
+          if (fullArgs.contains("-Xlink-optimise")) "dotty.tools.dotc.FromTasty"
+          else "dotty.tools.dotc.Main"
+
+        (runMain in Compile).toTask((main +: fullArgs).mkString(" ", " ", ""))
       }.evaluated,
       dotc := run.evaluated,