Move the ClassPath cache to an explicit GlobalCache

Author: mbovel

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

@@ -70,6 +70,8 @@ class Driver {
 
   protected def command: CompilerCommand = ScalacCommand
 
+  protected def globalCache: GlobalCache = GlobalCache()
+
   /** Setup context with initialized settings from CLI arguments, then check if there are any settings that
    *  would change the default behaviour of the compiler.
    *
@@ -81,6 +83,7 @@ class Driver {
     val ictx = rootCtx.fresh
     val summary = command.distill(args, ictx.settings)(ictx.settingsState)(using ictx)
     ictx.setSettings(summary.sstate)
+    ictx.setGlobalCache(globalCache)
     MacroClassLoader.init(ictx)
     Positioned.init(using ictx)
 

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

@@ -0,0 +1,52 @@
+package dotty.tools.dotc
+
+import java.nio.file.Files
+import java.nio.file.attribute.BasicFileAttributes
+import java.nio.file.attribute.FileTime
+
+import dotty.tools.dotc.core.Contexts.Context
+import dotty.tools.io.{AbstractFile, ClassPath}
+
+/** Global cache that can be shared across [[Driver]] instances.
+ *
+ *  This class is thread-safe.
+ */
+final class GlobalCache():
+  import GlobalCache.FileBasedCache
+
+  private val classPathCache = FileBasedCache[ClassPath]()
+
+  def getOrCreateClassPath(key: AbstractFile, createValue: => ClassPath)(using Context): ClassPath =
+    classPathCache.getOrCreate(key.file.nn.toPath, () => createValue)
+
+object GlobalCache:
+
+  /** A cache for values associated with files on disk, that invalidates
+   *  the cached value when the file is modified.
+   *
+   *  See https://github.com/scala/bug/issues/10295 for some context on the
+   *  invalidation strategy.
+   *
+   *  Moved from [[ZipAndJarFileLookupFactory]] in December 2025.
+   *
+   *  @author @allanrenucci
+   */
+  private class FileBasedCache[T]:
+    private case class Stamp(lastModified: FileTime, fileKey: Object)
+    private val cache = collection.mutable.Map.empty[java.nio.file.Path, (Stamp, T)]
+
+    def getOrCreate(path: java.nio.file.Path, create: () => T): T =
+      cache.synchronized:
+        val attrs = Files.readAttributes(path, classOf[BasicFileAttributes])
+        val lastModified = attrs.lastModifiedTime()
+        // null on some platforms, but that's okay, we just use the last
+        // modified timestamp as our stamp in that case
+        val fileKey = attrs.fileKey()
+        val stamp = Stamp(lastModified, fileKey)
+        cache.get(path) match
+          case Some((cachedStamp, cached)) if cachedStamp == stamp =>
+            cached
+          case _ =>
+            val value = create()
+            cache.put(path, (stamp, value))
+            value

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

@@ -22,17 +22,12 @@ import FileUtils.*
  * when there are a lot of projects having a lot of common dependencies.
  */
 sealed trait ZipAndJarFileLookupFactory {
-  private val cache = new FileBasedCache[ClassPath]
-
   def create(zipFile: AbstractFile)(using Context): ClassPath =
     val release = Option(ctx.settings.javaOutputVersion.value).filter(_.nonEmpty)
     if (ctx.settings.YdisableFlatCpCaching.value || zipFile.file == null) createForZipFile(zipFile, release)
-    else createUsingCache(zipFile, release)
+    else ctx.globalCache.getOrCreateClassPath(zipFile, createForZipFile(zipFile, release))
 
   protected def createForZipFile(zipFile: AbstractFile, release: Option[String]): ClassPath
-
-  private def createUsingCache(zipFile: AbstractFile, release: Option[String]): ClassPath =
-    cache.getOrCreate(zipFile.file.toPath, () => createForZipFile(zipFile, release))
 }
 
 /**
@@ -172,29 +167,3 @@ object ZipAndJarSourcePathFactory extends ZipAndJarFileLookupFactory {
 
   override protected def createForZipFile(zipFile: AbstractFile, release: Option[String]): ClassPath = ZipArchiveSourcePath(zipFile.file)
 }
-
-final class FileBasedCache[T] {
-  private case class Stamp(lastModified: FileTime, fileKey: Object)
-  private val cache = collection.mutable.Map.empty[java.nio.file.Path, (Stamp, T)]
-
-  def getOrCreate(path: java.nio.file.Path, create: () => T): T = cache.synchronized {
-    val attrs = Files.readAttributes(path, classOf[BasicFileAttributes])
-    val lastModified = attrs.lastModifiedTime()
-    // only null on some platforms, but that's okay, we just use the last modified timestamp as our stamp
-    val fileKey = attrs.fileKey()
-    val stamp = Stamp(lastModified, fileKey)
-    cache.get(path) match {
-      case Some((cachedStamp, cached)) if cachedStamp == stamp => cached
-      case _ =>
-        val value = create()
-        cache.put(path, (stamp, value))
-        value
-    }
-  }
-
-  def clear(): Unit = cache.synchronized {
-    // TODO support closing
-    // cache.valuesIterator.foreach(_.close())
-    cache.clear()
-  }
-}

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

@@ -57,8 +57,9 @@ object Contexts {
   private val (importInfoLoc,        store9) = store8.newLocation[ImportInfo | Null]()
   private val (typeAssignerLoc,     store10) = store9.newLocation[TypeAssigner](TypeAssigner)
   private val (progressCallbackLoc, store11) = store10.newLocation[ProgressCallback | Null]()
+  private val (globalCacheLoc,      store12) = store11.newLocation[GlobalCache]()
 
-  private val initialStore = store11
+  private val initialStore = store12
 
   /** The current context */
   inline def ctx(using ctx: Context): Context = ctx
@@ -189,6 +190,8 @@ object Contexts {
       val local = progressCallback
       if local != null then op(local)
 
+    def globalCache: GlobalCache = store(globalCacheLoc)
+
     /** The current plain printer */
     def printerFn: Context => Printer = store(printerFnLoc)
 
@@ -712,6 +715,7 @@ object Contexts {
     def setCompilerCallback(callback: CompilerCallback): this.type = updateStore(compilerCallbackLoc, callback)
     def setIncCallback(callback: IncrementalCallback): this.type = updateStore(incCallbackLoc, callback)
     def setProgressCallback(callback: ProgressCallback): this.type = updateStore(progressCallbackLoc, callback)
+    def setGlobalCache(globalCache: GlobalCache): this.type = updateStore(globalCacheLoc, globalCache)
     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)

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

@@ -5,6 +5,8 @@
 
 package dotty.tools.xsbt;
 
+import dotty.tools.dotc.GlobalCache;
+
 import xsbti.AnalysisCallback;
 import xsbti.Logger;
 import xsbti.Reporter;
@@ -15,10 +17,12 @@
 import xsbti.compile.Output;
 
 public final class CompilerBridge implements CompilerInterface2 {
+  private final GlobalCache globalCache = new GlobalCache();
+
   @Override
   public void run(VirtualFile[] sources, DependencyChanges changes, String[] options, Output output,
     AnalysisCallback callback, Reporter delegate, CompileProgress progress, Logger log) {
-    CompilerBridgeDriver driver = new CompilerBridgeDriver(options, output);
+    CompilerBridgeDriver driver = new CompilerBridgeDriver(options, output, globalCache);
     driver.run(sources, callback, log, delegate, progress);
   }
 }

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

@@ -7,6 +7,7 @@
 
 import dotty.tools.dotc.Compiler;
 import dotty.tools.dotc.Driver;
+import dotty.tools.dotc.GlobalCache;
 import dotty.tools.dotc.ScalacCommand;
 import dotty.tools.dotc.config.Properties;
 import dotty.tools.dotc.core.Contexts;
@@ -35,8 +36,9 @@
 public class CompilerBridgeDriver extends Driver {
   private final String[] scalacOptions;
   private final String[] args;
+  private final GlobalCache globalCache;
 
-  public CompilerBridgeDriver(String[] scalacOptions, Output output) {
+  public CompilerBridgeDriver(String[] scalacOptions, Output output, GlobalCache globalCache) {
     super();
     this.scalacOptions = scalacOptions;
 
@@ -47,6 +49,12 @@ public CompilerBridgeDriver(String[] scalacOptions, Output output) {
     System.arraycopy(scalacOptions, 0, args, 0, scalacOptions.length);
     args[scalacOptions.length] = "-d";
     args[scalacOptions.length + 1] = output.getSingleOutputAsPath().get().toAbsolutePath().toString();
+
+    this.globalCache = globalCache;
+  }
+
+  public CompilerBridgeDriver(String[] scalacOptions, Output output) {
+    this(scalacOptions, output, new GlobalCache());
   }
 
   private static final String StopInfoError =
@@ -61,6 +69,11 @@ public boolean sourcesRequired() {
     return false;
   }
 
+  @Override
+  public GlobalCache globalCache() {
+    return this.globalCache;
+  }
+
   private static VirtualFile asVirtualFile(SourceFile sourceFile, DelegatingReporter reporter,
       HashMap<AbstractFile, VirtualFile> lookup) {
     return lookup.computeIfAbsent(sourceFile.file(), path -> {