revert context cache, use local cache, always give classfile

Author: bishabosha

compiler/src/dotty/tools/dotc/classpath/FileUtils.scala

@@ -17,14 +17,14 @@ object FileUtils {
   extension (file: AbstractFile) {
     def isPackage: Boolean = file.isDirectory && mayBeValidPackage(file.name)
 
-    def isClass: Boolean = !file.isDirectory && file.hasExtension("class") && !file.name.endsWith("$class.class")
+    def isClass: Boolean = !file.isDirectory && hasClassExtension && !file.name.endsWith("$class.class")
       // FIXME: drop last condition when we stop being compatible with Scala 2.11
 
-    def isClassExtension: Boolean = file.hasExtension("class")
+    def hasClassExtension: Boolean = file.hasExtension("class")
 
-    def isTastyExtension: Boolean = file.hasExtension("tasty")
+    def hasTastyExtension: Boolean = file.hasExtension("tasty")
 
-    def isTasty: Boolean = !file.isDirectory && file.hasExtension("tasty")
+    def isTasty: Boolean = !file.isDirectory && hasTastyExtension
 
     def isScalaBinary: Boolean = file.isClass || file.isTasty
 

compiler/src/dotty/tools/dotc/core/Contexts.scala

@@ -272,16 +272,6 @@ object Contexts {
     /** AbstractFile with given path, memoized */
     def getFile(name: String): AbstractFile = getFile(name.toTermName)
 
-    def getSiblingClassfile(tastyFile: AbstractFile): AbstractFile =
-      base.siblingClassfiles.getOrElseUpdate(tastyFile, {
-        val className = tastyFile.name.stripSuffix(".tasty")
-        val classfile0 = tastyFile.resolveSibling(className + ".class")
-        if classfile0 == null then
-          NoAbstractFile
-        else
-          classfile0
-      })
-
     private var related: SimpleIdentityMap[Phase | SourceFile, Context] | Null = null
 
     private def lookup(key: Phase | SourceFile): Context | Null =
@@ -958,7 +948,6 @@ object Contexts {
     /** Sources and Files that were loaded */
     val sources: util.HashMap[AbstractFile, SourceFile] = util.HashMap[AbstractFile, SourceFile]()
     val files: util.HashMap[TermName, AbstractFile] = util.HashMap()
-    val siblingClassfiles: util.HashMap[AbstractFile, AbstractFile] = util.HashMap()
 
     // Types state
     /** A table for hash consing unique types */
@@ -1063,7 +1052,6 @@ object Contexts {
       errorTypeMsg.clear()
       sources.clear()
       files.clear()
-      siblingClassfiles.clear()
       comparers.clear()  // forces re-evaluation of top and bottom classes in TypeComparer
 
     // Test that access is single threaded

compiler/src/dotty/tools/dotc/core/SymbolLoaders.scala

@@ -432,9 +432,10 @@ class TastyLoader(val tastyFile: AbstractFile) extends SymbolLoader {
 
 
   private def checkTastyUUID(tastyFile: AbstractFile, tastyBytes: Array[Byte])(using Context): Unit =
-    import dotty.tools.io.NoAbstractFile
-    val classfile = ctx.getSiblingClassfile(tastyFile)
-    if classfile != NoAbstractFile then
+    val classfile =
+      val className = tastyFile.name.stripSuffix(".tasty")
+      tastyFile.resolveSibling(className + ".class")
+    if classfile != null then
       val tastyUUID = new TastyHeaderUnpickler(tastyBytes).readHeader()
       new ClassfileTastyUUIDParser(classfile)(ctx).checkTastyUUID(tastyUUID)
     else

compiler/src/dotty/tools/dotc/sbt/ExtractDependencies.scala

@@ -8,7 +8,7 @@ import java.nio.file.Path
 import java.util.{Arrays, EnumSet}
 
 import dotty.tools.dotc.ast.tpd
-import dotty.tools.dotc.classpath.FileUtils.{isTasty, isClassExtension, isTastyExtension}
+import dotty.tools.dotc.classpath.FileUtils.{isTasty, hasClassExtension, hasTastyExtension}
 import dotty.tools.dotc.core.Contexts._
 import dotty.tools.dotc.core.Decorators._
 import dotty.tools.dotc.core.Flags._
@@ -424,10 +424,28 @@ class DependencyRecorder {
       classDependencies.foreach(recordClassDependency(cb, _))
     clear()
 
+  private val _siblingClassfiles = new mutable.HashMap[PlainFile, Path]
+
+  extension (pf: PlainFile)
+    /**Constructs a sibling class to the `jpath`.
+     * Does not validate if it exists as a real file.
+     * The way this works is that by the end of compilation analysis,
+     * there should be a corresponding NonLocalClass sent to zinc with the same class file name.
+     *
+     * FIXME: we still need a way to resolve the correct classfile when we split tasty and classes between
+     * different outputs (e.g. stdlib-bootstrapped).
+     */
+    private def siblingClass: Path =
+      _siblingClassfiles.getOrElseUpdate(pf, {
+        val jpath = pf.jpath
+        jpath.getParent.resolve(jpath.getFileName.toString.stripSuffix(".tasty") + ".class")
+      })
+
    /** Clear all state. */
    def clear(): Unit =
      _usedNames.clear()
      _classDependencies.clear()
+     _siblingClassfiles.clear()
      lastOwner = NoSymbol
      lastDepSource = NoSymbol
      _responsibleForImports = NoSymbol
@@ -440,18 +458,18 @@ class DependencyRecorder {
     val fromClassName = classNameAsString(dep.fromClass)
     val sourceFile = ctx.compilationUnit.source
 
-    def binaryDependency(file: Path, binaryClassName: String) =
-      cb.binaryDependency(file, binaryClassName, fromClassName, sourceFile, dep.context)
+    def binaryDependency(path: Path, binaryClassName: String) =
+      cb.binaryDependency(path, binaryClassName, fromClassName, sourceFile, dep.context)
 
-    def processExternalDependency(depFile: AbstractFile, binaryClassName: String) = {
+    def processExternalDependency(depFile: AbstractFile, binaryClassName: String, convertTasty: Boolean) = {
       depFile match {
         case ze: ZipArchive#Entry => // The dependency comes from a JAR
           ze.underlyingSource match
             case Some(zip) if zip.jpath != null =>
               binaryDependency(zip.jpath, binaryClassName)
             case _ =>
         case pf: PlainFile => // The dependency comes from a class file, Zinc handles JRT filesystem
-          binaryDependency(pf.jpath, binaryClassName)
+          binaryDependency(if convertTasty then pf.siblingClass else pf.jpath, binaryClassName)
         case _ =>
           internalError(s"Ignoring dependency $depFile of unknown class ${depFile.getClass}}", dep.fromClass.srcPos)
       }
@@ -461,15 +479,10 @@ class DependencyRecorder {
     if depFile != null then {
       // Cannot ignore inheritance relationship coming from the same source (see sbt/zinc#417)
       def allowLocal = dep.context == DependencyByInheritance || dep.context == LocalDependencyByInheritance
-      if depFile.isTastyExtension then
-        val depClassFile = ctx.getSiblingClassfile(depFile)
-        if depClassFile != NoAbstractFile then
-          // did not find associated class file, e.g. for a TASTy-only classpath.
-          // The file that Zinc recieves with binaryDependency is used to lookup any either any
-          // generated non-local classes or produced xsbti.API associated with the file.
-          processExternalDependency(depClassFile, dep.toClass.binaryClassName)
-      else if depFile.isClassExtension then
-        processExternalDependency(depFile, dep.toClass.binaryClassName)
+      if depFile.hasTastyExtension then
+        processExternalDependency(depFile, dep.toClass.binaryClassName, convertTasty = true)
+      else if depFile.hasClassExtension then
+        processExternalDependency(depFile, dep.toClass.binaryClassName, convertTasty = false)
       else if allowLocal || depFile != sourceFile.file then
         // We cannot ignore dependencies coming from the same source file because
         // the dependency info needs to propagate. See source-dependencies/trait-trait-211.

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

@@ -113,6 +113,11 @@ class PlainFile(val givenPath: Path) extends AbstractFile {
       null
   }
 
+  final def fakeSibling(name: String): AbstractFile = {
+    val child = givenPath.parent / name
+    new PlainFile(child)
+  }
+
   /** Does this abstract file denote an existing file? */
   def create(): Unit = if (!exists) givenPath.createFile()