Add a compiler option to write .sig files to disk

Refactor `ClassfileWriters` to share code with this new output
type.

Take advantage of this in PipelineMain.

```
$  tail sandbox/{test,client}.scala
==> sandbox/test.scala <==
package p1.p2

case class Test()

==> sandbox/client.scala <==
package p3

class Client {
  new p1.p2.Test()
}

$  qscalac -Youtline -Ypickle-java -Ypickle-write /tmp/out -Ystop-after:pickler -d /tmp/out sandbox/test.scala

$  find /tmp/out
/tmp/out
/tmp/out/p1
/tmp/out/p1/p2
/tmp/out/p1/p2/Test.sig

$  qscalac -cp /tmp/out -d /tmp/out sandbox/client.scala

$  find /tmp/out
/tmp/out
/tmp/out/p3
/tmp/out/p3/Client.class
/tmp/out/p1
/tmp/out/p1/p2
/tmp/out/p1/p2/Test.sig
```

Author: retronym

src/compiler/scala/tools/nsc/PipelineMain.scala

@@ -17,6 +17,7 @@ import java.lang.Thread.UncaughtExceptionHandler
 import java.nio.file.attribute.FileTime
 import java.nio.file.{Files, Path, Paths}
 import java.time.Instant
+import java.util.concurrent.ConcurrentHashMap
 import java.util.{Collections, Locale}
 import java.util.concurrent.atomic.{AtomicBoolean, AtomicInteger}
 
@@ -44,10 +45,13 @@ class PipelineMainClass(argFiles: Seq[Path], pipelineSettings: PipelineMain.Pipe
     val root = file.getRoot
     // An empty component on Unix, just the drive letter on Windows
     val validRootPathComponent = root.toString.replaceAllLiterally("/", "").replaceAllLiterally(":", "")
-    changeExtension(pickleCache.resolve(validRootPathComponent).resolve(root.relativize(file)).normalize(), newExtension)
+    val result = changeExtension(pickleCache.resolve(validRootPathComponent).resolve(root.relativize(file)).normalize(), newExtension)
+    if (useJars) Files.createDirectories(result.getParent)
+    strippedAndExportedClassPath.put(file.toRealPath().normalize(), result)
+    result
   }
 
-  private val strippedAndExportedClassPath = mutable.HashMap[Path, Path]()
+  private val strippedAndExportedClassPath = new ConcurrentHashMap[Path, Path]().asScala
 
   /** Forward errors to the (current) reporter. */
   protected def scalacError(msg: String): Unit = {
@@ -73,51 +77,6 @@ class PipelineMainClass(argFiles: Seq[Path], pipelineSettings: PipelineMain.Pipe
     p.getParent.resolve(changedFileName)
   }
 
-  def registerPickleClassPath[G <: Global](output: Path, data: mutable.AnyRefMap[G#Symbol, PickleBuffer]): Unit = {
-    val jarPath = cachePath(output)
-    val root = RootPath(jarPath, writable = true)
-    Files.createDirectories(root.root)
-
-    val dirs = mutable.Map[G#Symbol, Path]()
-    def packageDir(packSymbol: G#Symbol): Path = {
-      if (packSymbol.isEmptyPackageClass) root.root
-      else if (dirs.contains(packSymbol)) dirs(packSymbol)
-      else if (packSymbol.owner.isRoot) {
-        val subDir = root.root.resolve(packSymbol.encodedName)
-        Files.createDirectories(subDir)
-        dirs.put(packSymbol, subDir)
-        subDir
-      } else {
-        val base = packageDir(packSymbol.owner)
-        val subDir = base.resolve(packSymbol.encodedName)
-        Files.createDirectories(subDir)
-        dirs.put(packSymbol, subDir)
-        subDir
-      }
-    }
-    val written = new java.util.IdentityHashMap[AnyRef, Unit]()
-    try {
-      for ((symbol, pickle) <- data) {
-        if (!written.containsKey(pickle)) {
-          val base = packageDir(symbol.owner)
-          val primary = base.resolve(symbol.encodedName + ".sig")
-          val writer = new BufferedOutputStream(Files.newOutputStream(primary))
-          try {
-            writer.write(pickle.bytes, 0, pickle.writeIndex)
-          } finally {
-            writer.close()
-          }
-          written.put(pickle, ())
-        }
-      }
-    } finally {
-      root.close()
-    }
-    Files.setLastModifiedTime(jarPath, FileTime.from(Instant.now()))
-    strippedAndExportedClassPath.put(output.toRealPath().normalize(), jarPath)
-  }
-
-
   def writeDotFile(logDir: Path, dependsOn: mutable.LinkedHashMap[Task, List[Dependency]]): Unit = {
     val builder = new java.lang.StringBuilder()
     builder.append("digraph projects {\n")
@@ -375,7 +334,6 @@ class PipelineMainClass(argFiles: Seq[Path], pipelineSettings: PipelineMain.Pipe
       if (p.outlineTimer.durationMicros > 0d) {
         val desc = if (strategy == OutlineTypePipeline) "outline-type" else "parser-to-pickler"
         events += durationEvent(p.label, desc, p.outlineTimer)
-        events += durationEvent(p.label, "pickle-export", p.pickleExportTimer)
       }
       for ((g, ix) <- p.groups.zipWithIndex) {
         if (g.timer.durationMicros > 0d)
@@ -453,7 +411,6 @@ class PipelineMainClass(argFiles: Seq[Path], pipelineSettings: PipelineMain.Pipe
     val isGrouped = groups.size > 1
 
     val outlineTimer = new Timer()
-    val pickleExportTimer = new Timer
     val javaTimer = new Timer()
 
     var outlineCriticalPathMs = 0d
@@ -491,14 +448,11 @@ class PipelineMainClass(argFiles: Seq[Path], pipelineSettings: PipelineMain.Pipe
         command.settings.Youtline.value = true
         command.settings.stopAfter.value = List("pickler")
         command.settings.Ymacroexpand.value = command.settings.MacroExpand.None
+        command.settings.YpickleWrite.value = cachePath(command.settings.outputDirs.getSingleOutput.get.file.toPath).toAbsolutePath.toString
         val run1 = new compiler.Run()
         run1 compile files
         outlineTimer.stop()
         log(f"scalac outline: done ${outlineTimer.durationMs}%.0f ms")
-        pickleExportTimer.start()
-        registerPickleClassPath(command.settings.outputDirs.getSingleOutput.get.file.toPath, run1.symData)
-        pickleExportTimer.stop()
-        log(f"scalac: exported pickles ${pickleExportTimer.durationMs}%.0f ms")
         reporter.finish()
         if (reporter.hasErrors) {
           log("scalac outline: failed")
@@ -518,6 +472,7 @@ class PipelineMainClass(argFiles: Seq[Path], pipelineSettings: PipelineMain.Pipe
       command.settings.Youtline.value = false
       command.settings.stopAfter.value = Nil
       command.settings.Ymacroexpand.value = command.settings.MacroExpand.Normal
+      command.settings.YpickleWrite.value = ""
 
       val groupCount = groups.size
       for ((group, ix) <- groups.zipWithIndex) {
@@ -552,18 +507,14 @@ class PipelineMainClass(argFiles: Seq[Path], pipelineSettings: PipelineMain.Pipe
       assert(groups.size == 1)
       val group = groups.head
       log("scalac: start")
+      command.settings.YpickleWrite.value = cachePath(command.settings.outputDirs.getSingleOutput.get.file.toPath).toString
       outlineTimer.start()
       try {
         val run2 = new compiler.Run() {
-
           override def advancePhase(): Unit = {
             if (compiler.phase == this.picklerPhase) {
               outlineTimer.stop()
               log(f"scalac outline: done ${outlineTimer.durationMs}%.0f ms")
-              pickleExportTimer.start()
-              registerPickleClassPath(command.settings.outputDirs.getSingleOutput.get.file.toPath, symData)
-              pickleExportTimer.stop()
-              log(f"scalac: exported pickles ${pickleExportTimer.durationMs}%.0f ms")
               outlineDone.complete(Success(()))
               group.timer.start()
             }