Add a default no-op GlobalCache

Author: mbovel

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

@@ -5,48 +5,58 @@ import java.nio.file.attribute.BasicFileAttributes
 import java.nio.file.attribute.FileTime
 
 import dotty.tools.dotc.core.Contexts.Context
+import dotty.tools.dotc.core.Decorators.em
+import dotty.tools.dotc.report
 import dotty.tools.io.{AbstractFile, ClassPath}
 
+trait GlobalCache:
+  def getOrCreateClassPath(key: AbstractFile, createValue: => ClassPath)(using Context): ClassPath
+
 /** Global cache that can be shared across [[Driver]] instances.
  *
  *  This class is thread-safe.
  */
-final class GlobalCache():
-  import GlobalCache.FileBasedCache
-
+private final class GlobalCacheImpl() extends GlobalCache:
   private val classPathCache = FileBasedCache[ClassPath]()
 
   def getOrCreateClassPath(key: AbstractFile, createValue: => ClassPath)(using Context): ClassPath =
     classPathCache.getOrCreate(key.file.nn.toPath, () => createValue)
 
 object GlobalCache:
+  def apply(): GlobalCache =
+    GlobalCacheImpl()
 
-  /** 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
+  object NoGlobalCache extends GlobalCache:
+    def getOrCreateClassPath(key: AbstractFile, createValue: => ClassPath)(using Context): ClassPath =
+      report.configurationWarning(em"Not GlobalCache set")
+      createValue
+
+/** 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/core/Contexts.scala

@@ -779,6 +779,7 @@ object Contexts {
           .updated(notNullInfosLoc, Nil)
           .updated(compilationUnitLoc, NoCompilationUnit)
           .updated(profilerLoc, Profiler.NoOp)
+          .updated(globalCacheLoc, GlobalCache.NoGlobalCache)
       c._searchHistory = new SearchRoot
       c._gadtState = GadtState(GadtConstraint.empty)
       c

compiler/test/dotty/tools/DottyTest.scala

@@ -12,14 +12,16 @@ import dotc.core.Symbols._
 import Types._, Symbols._, Decorators._
 import dotc.core.Decorators._
 import dotc.ast.tpd
-import dotc.Compiler
+import dotc.{Compiler, GlobalCache}
 
 import dotc.core.Phases.Phase
 
 trait DottyTest extends ContextEscapeDetection {
 
   dotc.parsing.Scanners // initialize keywords
 
+  private val globalCache: GlobalCache = GlobalCache()
+
   implicit var ctx: Context = initialCtx
 
   protected def initialCtx: FreshContext = {
@@ -42,6 +44,7 @@ trait DottyTest extends ContextEscapeDetection {
     fc.setSetting(fc.settings.classpath, TestConfiguration.basicClasspath)
     fc.setSetting(fc.settings.language, List("experimental.erasedDefinitions").asInstanceOf)
     fc.setProperty(ContextDoc, new ContextDocstrings)
+    fc.setGlobalCache(globalCache)
   }
 
   protected def defaultCompiler: Compiler = new Compiler()

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

@@ -17,7 +17,7 @@
 import xsbti.compile.Output;
 
 public final class CompilerBridge implements CompilerInterface2 {
-  private final GlobalCache globalCache = new GlobalCache();
+  private final GlobalCache globalCache = GlobalCache.apply();
 
   @Override
   public void run(VirtualFile[] sources, DependencyChanges changes, String[] options, Output output,

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

@@ -54,7 +54,7 @@ public CompilerBridgeDriver(String[] scalacOptions, Output output, GlobalCache g
   }
 
   public CompilerBridgeDriver(String[] scalacOptions, Output output) {
-    this(scalacOptions, output, new GlobalCache());
+    this(scalacOptions, output, GlobalCache.apply());
   }
 
   private static final String StopInfoError =