Use java.nio.file.FileSystems to write to jar directly

Author: nicolasstucki

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

@@ -7,6 +7,7 @@ import dotty.tools.dotc.core.Phases.Phase
 import dotty.tools.dotc.core.Names.TypeName
 
 import scala.collection.mutable
+import scala.collection.JavaConverters._
 import scala.tools.asm.{ClassVisitor, CustomAttr, FieldVisitor, MethodVisitor}
 import scala.tools.nsc.backend.jvm._
 import dotty.tools.dotc
@@ -26,14 +27,15 @@ import Denotations._
 import Phases._
 import java.lang.AssertionError
 import java.io.{DataOutputStream, File => JFile}
-import dotty.tools.io.{Jar, File, Directory}
+import java.nio.file.{Files, FileSystem, FileSystems, Path => JPath}
+
+import dotty.tools.io.{Directory, File, Jar}
 
 import scala.tools.asm
 import scala.tools.asm.tree._
 import dotty.tools.dotc.util.{DotClass, Positions}
 import tpd._
 import StdNames._
-
 import dotty.tools.io._
 
 class GenBCode extends Phase {
@@ -47,40 +49,36 @@ class GenBCode extends Phase {
     superCallsMap.put(sym, old + calls)
   }
 
+  private[this] var jarFS: JarFS = _
+
   def outputDir(implicit ctx: Context): AbstractFile = {
     val path = ctx.settings.outputDir.value
     if (path.isDirectory) new PlainDirectory(Directory(path))
-    else new PlainFile(path)
+    else {
+      if (jarFS == null) {
+        path.delete()
+        jarFS = JarFS.create(path)
+      }
+      jarFS.getRoot()
+    }
   }
 
-  private[this] var classOutput: AbstractFile = _
-
   def run(implicit ctx: Context): Unit = {
     new GenBCodePipeline(entryPoints.toList,
-        new DottyBackendInterface(classOutput, superCallsMap.toMap)(ctx))(ctx).run(ctx.compilationUnit.tpdTree)
+        new DottyBackendInterface(outputDir, superCallsMap.toMap)(ctx))(ctx).run(ctx.compilationUnit.tpdTree)
     entryPoints.clear()
   }
 
   override def runOn(units: List[CompilationUnit])(implicit ctx: Context) = {
-    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
+    try super.runOn(units)
+    finally if (jarFS ne null) {
+      try { jarFS.close() } catch { case _: Throwable => }
+      jarFS = null
     }
   }
 }
 
-class GenBCodePipeline(val entryPoints: List[Symbol], val int: DottyBackendInterface)(implicit val ctx: Context) extends BCodeSyncAndTry{
+class GenBCodePipeline(val entryPoints: List[Symbol], val int: DottyBackendInterface)(implicit val ctx: Context) extends BCodeSyncAndTry {
 
   var tree: Tree = _
 

compiler/src/dotty/tools/io/JarFS.scala

@@ -0,0 +1,51 @@
+package dotty.tools
+package io
+
+import java.nio.file.{FileSystem, FileSystems}
+import java.nio.file.Files
+
+import java.util.jar._
+
+import scala.collection.JavaConverters._
+
+class JarFS private (private[this] var jarFS: FileSystem) {
+
+  def getRoot(): AbstractFile = {
+    val root = jarFS.getRootDirectories.iterator().next()
+    new JarFS.JarDirectory(root)(jarFS)
+  }
+
+  def close() = {
+    jarFS.close()
+    jarFS = null
+  }
+}
+
+object JarFS {
+
+  def create(path: Path): JarFS = {
+    assert(path.extension == "jar")
+    val env = Map("create" -> "true").asJava
+    val jarUri = java.net.URI.create("jar:file:" + path.toAbsolute.path)
+    new JarFS(FileSystems.newFileSystem(jarUri, env))
+  }
+
+  private class JarDirectory(path: JPath)(jarFS: FileSystem) extends PlainDirectory(new Directory(path)) {
+    override def name = "<jar-dir>"
+    override def file = throw new UnsupportedOperationException
+    override def fileNamed(name: String): AbstractFile = new JarFile(pathTo(name))
+    override def subdirectoryNamed(name: String): AbstractFile = new JarDirectory(pathTo(name))(jarFS)
+    private def pathTo(name: String): JPath =
+      jarFS.getPath(if (path.toString == "/") name else path.resolve(name).toString)
+  }
+
+  private class JarFile(path: JPath) extends PlainFile(new File(path)) {
+    override def name = "<jar-file>"
+    override def file = throw new UnsupportedOperationException
+    override def output = {
+      if (path.getParent ne null)
+        Files.createDirectories(path.getParent)
+      Files.newOutputStream(path)
+    }
+  }
+}