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 {
@@ -50,37 +52,53 @@ class GenBCode extends Phase {
   def outputDir(implicit ctx: Context): AbstractFile = {
     val path = ctx.settings.outputDir.value
     if (path.isDirectory) new PlainDirectory(Directory(path))
-    else new PlainFile(path)
+    else jarOutput(path)
   }
 
-  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
+    }
+  }
+
+  private[this] var jarFs: java.nio.file.FileSystem = _
+  private def jarOutput(path: Path) = {
+    assert(path.extension == "jar")
+
+    path.delete()
+
+    val env = Map("create" -> "true").asJava
+    val jar = java.net.URI.create("jar:file:" + path.toAbsolute.path)
+    jarFs = java.nio.file.FileSystems.newFileSystem(jar, env)
+
+    new JarFilePath(jarFs, jarFs.getRootDirectories.iterator().next())
+  }
+
+  private class JarFilePath(jarFs: FileSystem, path: JPath) extends PlainDirectory(new Directory(path)) {
+    override def name = "<jar-file>"
+    override def file = throw new UnsupportedOperationException
+    override def fileNamed(name: String): AbstractFile = new PlainNioFile(pathTo(name))
+    override def subdirectoryNamed(name: String): AbstractFile = {
+      val subPath = pathTo(name)
+      if (!Files.exists(subPath)) Files.createDirectory(subPath)
+      new JarFilePath(jarFs, subPath)
+    }
+    private def pathTo(name: String) = {
+      val absolutePath = if (path.toString == "/") name else path.resolve(name).toString
+      jarFs.getPath(absolutePath)
     }
   }
 }
 
-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 = _
 

doc-tool/src/dotty/tools/dottydoc/staticsite/Site.scala

@@ -409,7 +409,7 @@ case class Site(
   }
 
   private def toSourceFile(f: JFile): SourceFile =
-    SourceFile(AbstractFile.getFile(new File(f)), Source.fromFile(f).toArray)
+    SourceFile(AbstractFile.getFile(new File(f.toPath)), Source.fromFile(f).toArray)
 
   private def collectFiles(dir: JFile, includes: String => Boolean): Array[JFile] =
     dir