Don't use a classloader to read .tasty files from jars

The previous commit tried to fix some weird caching behaviors by closing
the classloader used to read a .tasty file, but it turns out the JVM is
dumb and that breaks any other in-use classloader that uses the same
jar. Give up on the whole thing and work directly with the underlying
ZipArchive to find the .tasty file (this just required adding a "parent"
field to ZipArchive#Entry).

Author: smarter

compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala

@@ -774,16 +774,14 @@ class ClassfileParser(
         val attrLen = in.nextInt
         val bytes = in.nextBytes(attrLen)
         if (attrLen == 16) { // A tasty attribute with that has only a UUID (16 bytes) implies the existence of the .tasty file
-          val tastyBytes: Array[Byte] = classfile.underlyingSource match { // TODO: simplify when #3552 is fixed
-            case None =>
-              ctx.error("Could not load TASTY from .tasty for virtual file " + classfile)
-              Array.empty
-            case Some(jar: ZipArchive) => // We are in a jar
-              val cl = new URLClassLoader(Array(jar.jpath.toUri.toURL), /*parent =*/ null)
-              try {
-                val path = classfile.path.stripSuffix(".class") + ".tasty"
-                val stream = cl.getResourceAsStream(path)
-                if (stream != null) {
+          val tastyBytes: Array[Byte] = classfile match { // TODO: simplify when #3552 is fixed
+            case classfile: io.ZipArchive#Entry => // We are in a jar
+              val path = classfile.parent.lookupName(
+                classfile.name.stripSuffix(".class") + ".tasty", directory = false
+              )
+              if (path != null) {
+                val stream = path.input
+                try {
                   val tastyOutStream = new ByteArrayOutputStream()
                   val buffer = new Array[Byte](1024)
                   var read = stream.read(buffer, 0, buffer.length)
@@ -793,23 +791,25 @@ class ClassfileParser(
                   }
                   tastyOutStream.flush()
                   tastyOutStream.toByteArray
-                }
-                else {
-                  ctx.error(s"Could not find $path in $jar")
-                  Array.empty
+                } finally {
+                  stream.close()
                 }
               }
-              finally {
-                // If we don't close the classloader, spooky things happen (see
-                // scripted test source-dependencies/export-jars2).
-                cl.close()
+              else {
+                ctx.error(s"Could not find $path in ${classfile.underlyingSource}")
+                Array.empty
               }
             case _ =>
-              val plainFile = new PlainFile(io.File(classfile.jpath).changeExtension("tasty"))
-              if (plainFile.exists) plainFile.toByteArray
-              else {
-                ctx.error("Could not find " + plainFile)
+              if (classfile.jpath == null) {
+                ctx.error("Could not load TASTY from .tasty for virtual file " + classfile)
                 Array.empty
+              } else {
+                val plainFile = new PlainFile(io.File(classfile.jpath).changeExtension("tasty"))
+                if (plainFile.exists) plainFile.toByteArray
+                else {
+                  ctx.error("Could not find " + plainFile)
+                  Array.empty
+                }
               }
           }
           if (tastyBytes.nonEmpty) {

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

@@ -66,15 +66,15 @@ abstract class ZipArchive(override val jpath: JPath) extends AbstractFile with E
   def absolute: AbstractFile  = unsupported()
 
   /** ''Note:  This library is considered experimental and should not be used unless you know what you are doing.'' */
-  sealed abstract class Entry(path: String) extends VirtualFile(baseName(path), path) {
+  sealed abstract class Entry(path: String, val parent: Entry) extends VirtualFile(baseName(path), path) {
     // have to keep this name for compat with sbt's compiler-interface
     def getArchive: ZipFile = null
     override def underlyingSource: Option[ZipArchive] = Some(self)
     override def toString: String = self.path + "(" + path + ")"
   }
 
   /** ''Note:  This library is considered experimental and should not be used unless you know what you are doing.'' */
-  class DirEntry(path: String) extends Entry(path) {
+  class DirEntry(path: String, parent: Entry) extends Entry(path, parent) {
     val entries: mutable.HashMap[String, Entry] = mutable.HashMap()
 
     override def isDirectory: Boolean = true
@@ -98,7 +98,7 @@ abstract class ZipArchive(override val jpath: JPath) extends AbstractFile with E
       case Some(v) => v
       case None =>
         val parent = ensureDir(dirs, dirName(path), null)
-        val dir    = new DirEntry(path)
+        val dir    = new DirEntry(path, parent)
         parent.entries(baseName(path)) = dir
         dirs(path) = dir
         dir
@@ -120,8 +120,9 @@ final class FileZipArchive(jpath: JPath) extends ZipArchive(jpath) {
   private class LazyEntry(
     name: String,
     time: Long,
-    size: Int
-  ) extends Entry(name) {
+    size: Int,
+    parent: DirEntry
+  ) extends Entry(name, parent) {
     override def lastModified: Long = time // could be stale
     override def input: InputStream = {
       val zipFile  = openZipFile()
@@ -140,15 +141,16 @@ final class FileZipArchive(jpath: JPath) extends ZipArchive(jpath) {
   // faster than LazyEntry.
   private class LeakyEntry(
     zipFile: ZipFile,
-    zipEntry: ZipEntry
-  ) extends Entry(zipEntry.getName) {
+    zipEntry: ZipEntry,
+    parent: DirEntry
+  ) extends Entry(zipEntry.getName, parent) {
     override def lastModified: Long = zipEntry.getTime
     override def input: InputStream = zipFile.getInputStream(zipEntry)
     override def sizeOption: Option[Int] = Some(zipEntry.getSize.toInt)
   }
 
   @volatile lazy val (root, allDirs): (DirEntry, collection.Map[String, DirEntry]) = {
-    val root = new DirEntry("/")
+    val root = new DirEntry("/", null)
     val dirs = mutable.HashMap[String, DirEntry]("/" -> root)
     val zipFile = openZipFile()
     val entries = zipFile.entries()
@@ -163,10 +165,11 @@ final class FileZipArchive(jpath: JPath) extends ZipArchive(jpath) {
               new LazyEntry(
                 zipEntry.getName(),
                 zipEntry.getTime(),
-                zipEntry.getSize().toInt
+                zipEntry.getSize().toInt,
+                dir
               )
             else
-              new LeakyEntry(zipFile, zipEntry)
+              new LeakyEntry(zipFile, zipEntry, dir)
 
           dir.entries(f.name) = f
         }
@@ -195,15 +198,15 @@ final class FileZipArchive(jpath: JPath) extends ZipArchive(jpath) {
 
 final class ManifestResources(val url: URL) extends ZipArchive(null) {
   def iterator(): Iterator[AbstractFile] = {
-    val root     = new DirEntry("/")
+    val root     = new DirEntry("/", null)
     val dirs     = mutable.HashMap[String, DirEntry]("/" -> root)
     val manifest = new Manifest(input)
     val iter     = manifest.getEntries().keySet().iterator().asScala.filter(_.endsWith(".class")).map(new ZipEntry(_))
 
     for (zipEntry <- iter) {
       val dir = getDir(dirs, zipEntry)
       if (!zipEntry.isDirectory) {
-        val f = new Entry(zipEntry.getName) {
+        val f = new Entry(zipEntry.getName, dir) {
           override def lastModified = zipEntry.getTime()
           override def input        = resourceInputStream(path)
           override def sizeOption   = None