add todo, address comments

Author: bishabosha

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

@@ -426,29 +426,28 @@ class DependencyRecorder {
 
   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")
-      })
+  /**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(pf: PlainFile): 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
+  def clear(): Unit =
+    _usedNames.clear()
+    _classDependencies.clear()
+    _siblingClassfiles.clear()
+    lastOwner = NoSymbol
+    lastDepSource = NoSymbol
+    _responsibleForImports = NoSymbol
 
   /** Handles dependency on given symbol by trying to figure out if represents a term
    *  that is coming from either source code (not necessarily compiled in this compilation
@@ -461,32 +460,34 @@ class DependencyRecorder {
     def binaryDependency(path: Path, binaryClassName: String) =
       cb.binaryDependency(path, binaryClassName, fromClassName, sourceFile, dep.context)
 
-    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(if convertTasty then pf.siblingClass else pf.jpath, binaryClassName)
-        case _ =>
-          internalError(s"Ignoring dependency $depFile of unknown class ${depFile.getClass}}", dep.fromClass.srcPos)
-      }
-    }
-
-    val depFile = dep.toClass.associatedFile
+    val depClass = dep.toClass
+    val depFile = depClass.associatedFile
     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.hasTastyExtension then
-        processExternalDependency(depFile, dep.toClass.binaryClassName, convertTasty = true)
-      else if depFile.hasClassExtension then
-        processExternalDependency(depFile, dep.toClass.binaryClassName, convertTasty = false)
+      val isTasty = depFile.hasTastyExtension
+
+      def processExternalDependency() = {
+        val binaryClassName = depClass.binaryClassName
+        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(if isTasty then siblingClass(pf) else pf.jpath, binaryClassName)
+          case _ =>
+            internalError(s"Ignoring dependency $depFile of unknown class ${depFile.getClass}}", dep.fromClass.srcPos)
+        }
+      }
+
+      if isTasty || depFile.hasClassExtension then
+        processExternalDependency()
       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.
-        val toClassName = classNameAsString(dep.toClass)
+        val toClassName = classNameAsString(depClass)
         cb.classDependency(toClassName, fromClassName, dep.context)
     }
   }

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

@@ -97,8 +97,10 @@ abstract class AbstractFile extends Iterable[AbstractFile] {
   /** Returns the path of this abstract file in a canonical form. */
   def canonicalPath: String = if (jpath == null) path else jpath.normalize.toString
 
-  /** Checks extension case insensitively. */
+  /** Checks extension case insensitively. TODO: change to enum */
   def hasExtension(other: String): Boolean = extension == other.toLowerCase
+
+  /** Returns the extension of this abstract file. TODO: store as an enum to avoid costly comparisons */
   val extension: String = Path.extension(name)
 
   /** The absolute file, if this is a relative file. */

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

@@ -113,11 +113,6 @@ 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()