only use hashmap lookup to map to virtualfile

[Cherry-picked 5fde72c]

Author: bishabosha

compiler/src/dotty/tools/backend/jvm/CodeGen.scala

@@ -30,6 +30,7 @@ import scala.tools.asm
 import scala.tools.asm.tree._
 import tpd._
 import dotty.tools.io.AbstractFile
+import dotty.tools.dotc.util
 import dotty.tools.dotc.util.NoSourcePosition
 
 
@@ -106,7 +107,7 @@ class CodeGen(val int: DottyBackendInterface, val primitives: DottyPrimitives)(
   }
 
   // Creates a callback that will be evaluated in PostProcessor after creating a file
-  private def onFileCreated(cls: ClassNode, claszSymbol: Symbol, sourceFile: interfaces.SourceFile): AbstractFile => Unit = clsFile => {
+  private def onFileCreated(cls: ClassNode, claszSymbol: Symbol, sourceFile: util.SourceFile): AbstractFile => Unit = clsFile => {
     val (fullClassName, isLocal) = atPhase(sbtExtractDependenciesPhase) {
       (ExtractDependencies.classNameAsString(claszSymbol), claszSymbol.isLocal)
     }

compiler/src/dotty/tools/dotc/CompilationUnit.scala

@@ -115,7 +115,7 @@ object CompilationUnit {
   /** Make a compilation unit for top class `clsd` with the contents of the `unpickled` tree */
   def apply(clsd: ClassDenotation, unpickled: Tree, forceTrees: Boolean)(using Context): CompilationUnit =
     val file = clsd.symbol.associatedFile.nn
-    apply(ctx.getEmptySource(file), unpickled, forceTrees)
+    apply(SourceFile(file, Array.empty[Char]), unpickled, forceTrees)
 
   /** Make a compilation unit, given picked bytes and unpickled tree */
   def apply(source: SourceFile, unpickled: Tree, forceTrees: Boolean)(using Context): CompilationUnit = {

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

@@ -53,9 +53,8 @@ object Contexts {
   private val (notNullInfosLoc,      store8) = store7.newLocation[List[NotNullInfo]]()
   private val (importInfoLoc,        store9) = store8.newLocation[ImportInfo | Null]()
   private val (typeAssignerLoc,     store10) = store9.newLocation[TypeAssigner](TypeAssigner)
-  private val (zincInitialFilesLoc, store11) = store10.newLocation[util.ReadOnlySet[AbstractFile] | Null]()
 
-  private val initialStore = store11
+  private val initialStore = store10
 
   /** The current context */
   inline def ctx(using ctx: Context): Context = ctx
@@ -167,7 +166,6 @@ object Contexts {
 
     /** The Zinc callback implementation if we are run from Zinc, null otherwise */
     def incCallback: IncrementalCallback | Null = store(incCallbackLoc)
-    def zincInitialFiles: util.ReadOnlySet[AbstractFile] | Null = store(zincInitialFilesLoc)
 
     /** Run `op` if there exists an incremental callback */
     inline def withIncCallback(inline op: IncrementalCallback => Unit): Unit =
@@ -246,27 +244,9 @@ object Contexts {
     /** Sourcefile corresponding to given abstract file, memoized */
     def getSource(file: AbstractFile, codec: => Codec = Codec(settings.encoding.value)) = {
       util.Stats.record("Context.getSource")
-      computeCachedSource(file)(SourceFile(_, codec))
+      base.sources.getOrElseUpdate(file, SourceFile(file, codec))
     }
 
-    /** empty Sourcefile associated to given abstract file, memoized */
-    def getEmptySource(file: AbstractFile) = {
-      util.Stats.record("Context.getEmptySource")
-      computeCachedSource(file)(SourceFile(_, Array.empty[Char]))
-    }
-
-    private inline def computeCachedSource(file: AbstractFile)(inline mkSource: AbstractFile => SourceFile): SourceFile =
-      base.sources.getOrElseUpdate(file, {
-        val zincSources = zincInitialFiles
-        val cachedFile =
-          if zincSources != null then zincSources.lookup(file) match
-            case null => file
-            case cached: AbstractFile => cached
-          else
-            file
-        mkSource(cachedFile)
-      })
-
     /** SourceFile with given path name, memoized */
     def getSource(path: TermName): SourceFile = getFile(path) match
       case NoAbstractFile => NoSource
@@ -695,7 +675,6 @@ object Contexts {
 
     def setCompilerCallback(callback: CompilerCallback): this.type = updateStore(compilerCallbackLoc, callback)
     def setIncCallback(callback: IncrementalCallback): this.type = updateStore(incCallbackLoc, callback)
-    def setZincInitialFiles(zincInitialFiles: util.ReadOnlySet[AbstractFile]): this.type = updateStore(zincInitialFilesLoc, zincInitialFiles)
     def setPrinterFn(printer: Context => Printer): this.type = updateStore(printerFnLoc, printer)
     def setSettings(settingsState: SettingsState): this.type = updateStore(settingsStateLoc, settingsState)
     def setRun(run: Run | Null): this.type = updateStore(runLoc, run)

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

@@ -91,19 +91,16 @@ class ExtractDependencies extends Phase {
       } finally pw.close()
     }
 
-    if (ctx.incrementalEnabled) {
-      ctx.withIncCallback: cb =>
-        collector.usedNames.foreach {
-          case (clazz, usedNames) =>
-            val className = classNameAsString(clazz)
-            usedNames.names.foreach {
-              case (usedName, scopes) =>
-                cb.usedName(className, usedName.toString, scopes)
-            }
-        }
-
+    ctx.withIncCallback: cb =>
+      collector.usedNames.foreach {
+        case (clazz, usedNames) =>
+          val className = classNameAsString(clazz)
+          usedNames.names.foreach {
+            case (usedName, scopes) =>
+              cb.usedName(className, usedName.toString, scopes)
+          }
+      }
       collector.dependencies.foreach(recordDependency)
-    }
   }
 
   /*

compiler/src/dotty/tools/dotc/sbt/interfaces/IncrementalCallback.java

@@ -1,6 +1,6 @@
 package dotty.tools.dotc.sbt.interfaces;
 
-import dotty.tools.dotc.interfaces.SourceFile;
+import dotty.tools.dotc.util.SourceFile;
 
 import java.util.EnumSet;
 import java.nio.file.Path;

sbt-bridge/src/dotty/tools/xsbt/AbstractZincFile.java

@@ -1,6 +1,6 @@
 package dotty.tools.xsbt;
 
-import dotty.tools.dotc.interfaces.SourceFile;
+import dotty.tools.dotc.util.SourceFile;
 
 public class BasicPathBasedFile extends PlaceholderVirtualFile implements xsbti.PathBasedFile {
 
@@ -9,7 +9,7 @@ public BasicPathBasedFile(SourceFile sourceFile) {
   }
 
   public java.nio.file.Path toPath() {
-    return sourceFile.jfile().get().toPath();
+    return sourceFile.file().jpath();
   }
 
 }

sbt-bridge/src/dotty/tools/xsbt/BasicPathBasedFile.java

@@ -56,15 +56,16 @@ public boolean sourcesRequired() {
   }
 
   private static VirtualFile asVirtualFile(SourceFile sourceFile, DelegatingReporter reporter,
-      Map<String, VirtualFile> placeholders) {
-    if (sourceFile.file() instanceof AbstractZincFile) {
-      return ((AbstractZincFile) sourceFile.file()).underlying();
+      HashMap<AbstractFile, VirtualFile> lookup, Map<AbstractFile, VirtualFile> placeholders) {
+    VirtualFile maybeCached = lookup.get(sourceFile.file());
+    if (maybeCached != null) {
+      return maybeCached;
     } else {
       return fallbackVirtualFile(reporter, sourceFile, placeholders);
     }
   }
 
-  private static void reportMissingFile(DelegatingReporter reporter, dotty.tools.dotc.interfaces.SourceFile sourceFile) {
+  private static void reportMissingFile(DelegatingReporter reporter, SourceFile sourceFile) {
     String underline = String.join("", Collections.nCopies(sourceFile.path().length(), "^"));
     String message =
       sourceFile.path() + ": Missing virtual file\n" +
@@ -74,12 +75,11 @@ private static void reportMissingFile(DelegatingReporter reporter, dotty.tools.d
     reporter.reportBasicWarning(message);
   }
 
-  private static VirtualFile fallbackVirtualFile(DelegatingReporter reporter,
-      dotty.tools.dotc.interfaces.SourceFile sourceFile,
-      Map<String, VirtualFile> placeholders) {
-    return placeholders.computeIfAbsent(sourceFile.path(), path -> {
+  private static VirtualFile fallbackVirtualFile(DelegatingReporter reporter, SourceFile sourceFile,
+      Map<AbstractFile, VirtualFile> placeholders) {
+    return placeholders.computeIfAbsent(sourceFile.file(), path -> {
       reportMissingFile(reporter, sourceFile);
-      if (sourceFile.jfile().isPresent())
+      if (sourceFile.file().jpath() != null)
         return new BasicPathBasedFile(sourceFile);
       else
         return new PlaceholderVirtualFile(sourceFile);
@@ -92,35 +92,30 @@ synchronized public void run(VirtualFile[] sources, AnalysisCallback callback, L
     Arrays.sort(sortedSources, (x0, x1) -> x0.id().compareTo(x1.id()));
 
     ListBuffer<AbstractFile> sourcesBuffer = new ListBuffer<>();
-    dotty.tools.dotc.util.HashSet<AbstractFile> sourcesSet = new dotty.tools.dotc.util.HashSet<>(8, 2);
+    HashMap<AbstractFile, VirtualFile> lookup = new HashMap<>(sources.length, 0.25f);
 
     for (int i = 0; i < sources.length; i++) {
       VirtualFile source = sortedSources[i];
       AbstractFile abstractFile = asDottyFile(source);
       sourcesBuffer.append(abstractFile);
-      sourcesSet.put(abstractFile);
+      lookup.put(abstractFile, source);
     }
 
-    HashMap<String, VirtualFile> placeholders = new HashMap<>();
+    HashMap<AbstractFile, VirtualFile> placeholders = new HashMap<>();
 
     DelegatingReporter reporter = new DelegatingReporter(delegate, (self, sourceFile) ->
-      asVirtualFile(sourceFile, self, placeholders).id());
+      asVirtualFile(sourceFile, self, lookup, placeholders).id());
 
-    IncrementalCallback incCallback = new IncrementalCallback(callback, sourceFile -> {
-      if (sourceFile instanceof SourceFile) {
-        return asVirtualFile(((SourceFile) sourceFile), reporter, placeholders);
-      } else {
-        return fallbackVirtualFile(reporter, sourceFile, placeholders);
-      }
-    });
+    IncrementalCallback incCallback = new IncrementalCallback(callback, sourceFile ->
+      asVirtualFile(sourceFile, reporter, lookup, placeholders)
+    );
 
     try {
       log.debug(this::infoOnCachedCompiler);
 
       Contexts.Context initialCtx = initCtx()
         .fresh()
         .setReporter(reporter)
-        .setZincInitialFiles(sourcesSet)
         .setIncCallback(incCallback);
 
       Contexts.Context context = setup(args, initialCtx).map(t -> t._2).getOrElse(() -> initialCtx);

sbt-bridge/src/dotty/tools/xsbt/CompilerBridgeDriver.java

@@ -1,6 +1,6 @@
 package dotty.tools.xsbt;
 
-import dotty.tools.dotc.interfaces.SourceFile;
+import dotty.tools.dotc.util.SourceFile;
 import java.util.function.Function;
 
 public final class IncrementalCallback implements dotty.tools.dotc.sbt.interfaces.IncrementalCallback {

sbt-bridge/src/dotty/tools/xsbt/IncrementalCallback.java

@@ -1,6 +1,6 @@
 package dotty.tools.xsbt;
 
-import dotty.tools.dotc.interfaces.SourceFile;
+import dotty.tools.dotc.util.SourceFile;
 import java.util.function.Function;
 import java.util.Optional;
 
@@ -16,7 +16,7 @@ public OldIncrementalCallback(xsbti.AnalysisCallback delegate) {
   }
 
   private static File asJavaFile(SourceFile sourceFile) {
-    File jfileOrNull = sourceFile.jfile().orElse(null);
+    File jfileOrNull = sourceFile.file().file();
     if (jfileOrNull != null) return jfileOrNull;
     throw new IllegalArgumentException("SourceFile " + sourceFile + " is not backed by a java.io.File");
   }