[Dependency Scanner] Rename 'GlobalModuleDependenciesCache' -> 'SwiftDependencyScanningService'

Author: artemcm

include/swift/AST/ModuleDependencies.h

@@ -492,14 +492,13 @@ using ModuleDependenciesKindRefMap =
                        llvm::StringMap<const ModuleDependencyInfo *>,
                        ModuleDependencyKindHash>;
 
-// MARK: GlobalModuleDependenciesCache
-/// A cache describing the set of module dependencies that has been queried
-/// thus far. This cache records/stores the actual Dependency values and can be
-/// preserved across different scanning actions (e.g. in
-/// `DependencyScanningTool`). It is not to be queried directly, but is rather
+// MARK: SwiftDependencyScanningService
+/// A carrier of state shared among possibly multiple invocations of the dependency
+/// scanner. Acts as a global cache of discovered module dependencies and
+/// filesystem state. It is not to be queried directly, but is rather
 /// meant to be wrapped in an instance of `ModuleDependenciesCache`, responsible
 /// for recording new dependencies and answering cache queries in a given scan.
-class GlobalModuleDependenciesCache {
+class SwiftDependencyScanningService {
   /// Global cache contents specific to a specific scanner invocation context
   struct ContextSpecificGlobalCacheState {
     /// All cached module dependencies, in the order in which they were
@@ -522,6 +521,7 @@ class GlobalModuleDependenciesCache {
   /// All cached Swift source module dependencies, in the order in which they
   /// were encountered
   std::vector<ModuleDependencyID> AllSourceModules;
+
   /// Dependencies for all Swift source-based modules discovered. Each one is
   /// the main module of a prior invocation of the scanner.
   ModuleNameToDependencyMap SwiftSourceModuleDependenciesMap;
@@ -534,6 +534,7 @@ class GlobalModuleDependenciesCache {
 
   /// The current context hash configuration
   Optional<std::string> CurrentContextHash;
+
   /// The context hashes used by scanners using this cache, in the order in
   /// which they were used
   std::vector<std::string> AllContextHashes;
@@ -545,11 +546,17 @@ class GlobalModuleDependenciesCache {
   getDependenciesMap(ModuleDependencyKind kind) const;
 
 public:
-  GlobalModuleDependenciesCache();
-  GlobalModuleDependenciesCache(const GlobalModuleDependenciesCache &) = delete;
-  GlobalModuleDependenciesCache &
-  operator=(const GlobalModuleDependenciesCache &) = delete;
-  virtual ~GlobalModuleDependenciesCache() {}
+  SwiftDependencyScanningService();
+  SwiftDependencyScanningService(const SwiftDependencyScanningService &) = delete;
+  SwiftDependencyScanningService &
+  operator=(const SwiftDependencyScanningService &) = delete;
+  virtual ~SwiftDependencyScanningService() {}
+
+  /// Query the service's filesystem cache
+  clang::tooling::dependencies::DependencyScanningFilesystemSharedCache &getSharedCache() {
+    assert(SharedFilesystemCache && "Expected a shared cache");
+    return *SharedFilesystemCache;
+  }
 
   /// Query the service's filesystem cache
   clang::tooling::dependencies::DependencyScanningFilesystemSharedCache &
@@ -567,6 +574,7 @@ class GlobalModuleDependenciesCache {
   friend class ModuleDependenciesCache;
   friend class ModuleDependenciesCacheDeserializer;
   friend class ModuleDependenciesCacheSerializer;
+  friend class DependencyScanningTool;
 
   /// Configure the current state of the cache to respond to queries
   /// for the specified scanning context hash.
@@ -627,13 +635,13 @@ class GlobalModuleDependenciesCache {
 
 // MARK: ModuleDependenciesCache
 /// This "local" dependencies cache persists only for the duration of a given
-/// scanning action, and wraps an instance of a `GlobalModuleDependenciesCache`
+/// scanning action, and wraps an instance of a `SwiftDependencyScanningService`
 /// which may carry cached scanning information from prior scanning actions.
 /// This cache maintains a store of references to all dependencies found within
 /// the current scanning action (with their values stored in the global Cache).
 class ModuleDependenciesCache {
 private:
-  GlobalModuleDependenciesCache &globalCache;
+  SwiftDependencyScanningService &globalScanningService;
 
   /// References to data in `globalCache` for Swift dependencies and
   /// `clangModuleDependencies` for Clang dependencies accimulated during
@@ -671,7 +679,7 @@ class ModuleDependenciesCache {
                             Optional<ModuleDependencyKind> kind) const;
 
 public:
-  ModuleDependenciesCache(GlobalModuleDependenciesCache &globalCache,
+  ModuleDependenciesCache(SwiftDependencyScanningService &globalScanningService,
                           std::string mainScanModuleName,
                           std::string scanningContextHash);
   ModuleDependenciesCache(const ModuleDependenciesCache &) = delete;
@@ -706,7 +714,7 @@ class ModuleDependenciesCache {
                           ModuleDependencyInfo dependencies);
 
   const std::vector<ModuleDependencyID> &getAllSourceModules() const {
-    return globalCache.getAllSourceModules();
+    return globalScanningService.getAllSourceModules();
   }
 
   StringRef getMainModuleName() const {

include/swift/DependencyScan/DependencyScanningTool.h

@@ -85,7 +85,7 @@ class DependencyScanningTool {
 
   /// Writes the current `SharedCache` instance to a specified FileSystem path.
   void serializeCache(llvm::StringRef path);
-  /// Loads an instance of a `GlobalModuleDependenciesCache` to serve as the `SharedCache`
+  /// Loads an instance of a `SwiftDependencyScanningService` to serve as the `SharedCache`
   /// from a specified FileSystem path.
   bool loadCache(llvm::StringRef path);
   /// Discard the tool's current `SharedCache` and start anew.
@@ -108,7 +108,7 @@ class DependencyScanningTool {
 
   /// Shared cache of module dependencies, re-used by individual full-scan queries
   /// during the lifetime of this Tool.
-  std::unique_ptr<GlobalModuleDependenciesCache> SharedCache;
+  std::unique_ptr<SwiftDependencyScanningService> ScanningService;
 
   /// Shared cache of compiler instances created during batch scanning, corresponding to
   /// command-line options specified in the batch scan input entry.

include/swift/DependencyScan/ScanDependencies.h

@@ -27,13 +27,13 @@ namespace swift {
 class CompilerInvocation;
 class CompilerInstance;
 class ModuleDependenciesCache;
-class GlobalModuleDependenciesCache;
+class SwiftDependencyScanningService;
 
 namespace dependencies {
 
 using CompilerArgInstanceCacheMap =
     llvm::StringMap<std::tuple<std::unique_ptr<CompilerInstance>,
-                               std::unique_ptr<GlobalModuleDependenciesCache>,
+                               std::unique_ptr<SwiftDependencyScanningService>,
                                std::unique_ptr<ModuleDependenciesCache>>>;
 
 struct BatchScanInput {

include/swift/DependencyScan/SerializedModuleDependencyCacheFormat.h

@@ -23,7 +23,7 @@ class MemoryBuffer;
 namespace swift {
 
 class DiagnosticEngine;
-class GlobalModuleDependenciesCache;
+class SwiftDependencyScanningService;
 
 namespace dependencies {
 namespace module_dependency_cache_serialization {
@@ -174,23 +174,23 @@ using ClangModuleDetailsLayout =
 /// Tries to read the dependency graph from the given buffer.
 /// Returns \c true if there was an error.
 bool readInterModuleDependenciesCache(llvm::MemoryBuffer &buffer,
-                                      GlobalModuleDependenciesCache &cache);
+                                      SwiftDependencyScanningService &cache);
 
 /// Tries to read the dependency graph from the given path name.
 /// Returns true if there was an error.
 bool readInterModuleDependenciesCache(llvm::StringRef path,
-                                      GlobalModuleDependenciesCache &cache);
+                                      SwiftDependencyScanningService &cache);
 
 /// Tries to write the dependency graph to the given path name.
 /// Returns true if there was an error.
 bool writeInterModuleDependenciesCache(DiagnosticEngine &diags,
                                        llvm::StringRef path,
-                                       const GlobalModuleDependenciesCache &cache);
+                                       const SwiftDependencyScanningService &cache);
 
 /// Tries to write out the given dependency cache with the given
 /// bitstream writer.
 void writeInterModuleDependenciesCache(llvm::BitstreamWriter &Out,
-                                       const GlobalModuleDependenciesCache &cache);
+                                       const SwiftDependencyScanningService &cache);
 
 } // end namespace module_dependency_cache_serialization
 } // end namespace dependencies

include/swift/Frontend/Frontend.h

@@ -495,6 +495,9 @@ class CompilerInstance {
   llvm::vfs::FileSystem &getFileSystem() const {
     return *SourceMgr.getFileSystem();
   }
+  void setFileSystem(llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> FS) {
+    SourceMgr.setFileSystem(FS);
+  }
 
   ASTContext &getASTContext() { return *Context; }
   const ASTContext &getASTContext() const { return *Context; }

lib/AST/ModuleDependencies.cpp

@@ -226,7 +226,7 @@ void ModuleDependencyInfo::addBridgingModuleDependency(
   }
 }
 
-GlobalModuleDependenciesCache::GlobalModuleDependenciesCache()
+SwiftDependencyScanningService::SwiftDependencyScanningService()
   : ClangScanningService(clang::tooling::dependencies::ScanningMode::DependencyDirectivesScan,
                          clang::tooling::dependencies::ScanningOutputFormat::Full,
                          clang::CASOptions(),
@@ -237,7 +237,7 @@ GlobalModuleDependenciesCache::GlobalModuleDependenciesCache()
     SharedFilesystemCache.emplace();
 }
 
-void GlobalModuleDependenciesCache::overlaySharedFilesystemCacheForCompilation(CompilerInstance &Instance) {
+void SwiftDependencyScanningService::overlaySharedFilesystemCacheForCompilation(CompilerInstance &Instance) {
  auto existingFS = Instance.getSourceMgr().getFileSystem();
  llvm::IntrusiveRefCntPtr<
      clang::tooling::dependencies::DependencyScanningWorkerFilesystem>
@@ -247,15 +247,15 @@ void GlobalModuleDependenciesCache::overlaySharedFilesystemCacheForCompilation(C
  Instance.getSourceMgr().setFileSystem(depFS);
 }
 
-GlobalModuleDependenciesCache::ContextSpecificGlobalCacheState *
-GlobalModuleDependenciesCache::getCurrentCache() const {
+SwiftDependencyScanningService::ContextSpecificGlobalCacheState *
+SwiftDependencyScanningService::getCurrentCache() const {
   assert(CurrentContextHash.has_value() &&
          "Global Module Dependencies Cache not configured with Triple.");
   return getCacheForScanningContextHash(CurrentContextHash.value());
 }
 
-GlobalModuleDependenciesCache::ContextSpecificGlobalCacheState *
-GlobalModuleDependenciesCache::getCacheForScanningContextHash(StringRef scanningContextHash) const {
+SwiftDependencyScanningService::ContextSpecificGlobalCacheState *
+SwiftDependencyScanningService::getCacheForScanningContextHash(StringRef scanningContextHash) const {
   auto contextSpecificCache = ContextSpecificCacheMap.find(scanningContextHash);
   assert(contextSpecificCache != ContextSpecificCacheMap.end() &&
          "Global Module Dependencies Cache not configured with context-specific "
@@ -264,7 +264,7 @@ GlobalModuleDependenciesCache::getCacheForScanningContextHash(StringRef scanning
 }
 
 const ModuleNameToDependencyMap &
-GlobalModuleDependenciesCache::getDependenciesMap(
+SwiftDependencyScanningService::getDependenciesMap(
     ModuleDependencyKind kind) const {
   auto contextSpecificCache = getCurrentCache();
   auto it = contextSpecificCache->ModuleDependenciesMap.find(kind);
@@ -274,7 +274,7 @@ GlobalModuleDependenciesCache::getDependenciesMap(
 }
 
 ModuleNameToDependencyMap &
-GlobalModuleDependenciesCache::getDependenciesMap(
+SwiftDependencyScanningService::getDependenciesMap(
     ModuleDependencyKind kind) {
   auto contextSpecificCache = getCurrentCache();
   auto it = contextSpecificCache->ModuleDependenciesMap.find(kind);
@@ -283,7 +283,7 @@ GlobalModuleDependenciesCache::getDependenciesMap(
   return it->second;
 }
 
-void GlobalModuleDependenciesCache::configureForContextHash(std::string scanningContextHash) {
+void SwiftDependencyScanningService::configureForContextHash(std::string scanningContextHash) {
   auto knownContext = ContextSpecificCacheMap.find(scanningContextHash);
   if (knownContext != ContextSpecificCacheMap.end()) {
     // Set the current context and leave the rest as-is
@@ -303,7 +303,7 @@ void GlobalModuleDependenciesCache::configureForContextHash(std::string scanning
   }
 }
 
-Optional<ModuleDependencyInfo> GlobalModuleDependenciesCache::findDependencies(
+Optional<ModuleDependencyInfo> SwiftDependencyScanningService::findDependencies(
     StringRef moduleName, Optional<ModuleDependencyKind> kind) const {
   if (!kind) {
     for (auto kind = ModuleDependencyKind::FirstKind;
@@ -329,7 +329,7 @@ Optional<ModuleDependencyInfo> GlobalModuleDependenciesCache::findDependencies(
 }
 
 Optional<ModuleDependencyInfo>
-GlobalModuleDependenciesCache::findSourceModuleDependency(
+SwiftDependencyScanningService::findSourceModuleDependency(
     StringRef moduleName) const {
   auto known = SwiftSourceModuleDependenciesMap.find(moduleName);
   if (known != SwiftSourceModuleDependenciesMap.end())
@@ -338,7 +338,7 @@ GlobalModuleDependenciesCache::findSourceModuleDependency(
     return None;
 }
 
-bool GlobalModuleDependenciesCache::hasDependencies(
+bool SwiftDependencyScanningService::hasDependencies(
     StringRef moduleName, Optional<ModuleDependencyKind> kind) const {
   assert(kind != ModuleDependencyKind::Clang &&
          "Attempting to query Clang dependency in persistent Dependency "
@@ -372,7 +372,7 @@ static std::string modulePathForVerification(const ModuleDependencyInfo &module)
   return existingModulePath;
 }
 
-const ModuleDependencyInfo *GlobalModuleDependenciesCache::recordDependencies(
+const ModuleDependencyInfo *SwiftDependencyScanningService::recordDependencies(
     StringRef moduleName, ModuleDependencyInfo dependencies) {
   auto kind = dependencies.getKind();
   assert(kind != ModuleDependencyKind::Clang &&
@@ -397,7 +397,7 @@ const ModuleDependencyInfo *GlobalModuleDependenciesCache::recordDependencies(
   return &(map[moduleName]);
 }
 
-const ModuleDependencyInfo *GlobalModuleDependenciesCache::updateDependencies(
+const ModuleDependencyInfo *SwiftDependencyScanningService::updateDependencies(
     ModuleDependencyID moduleID, ModuleDependencyInfo dependencies) {
   auto kind = dependencies.getKind();
   assert(kind != ModuleDependencyKind::Clang &&
@@ -437,14 +437,13 @@ ModuleDependenciesCache::getDependencyReferencesMap(
 }
 
 ModuleDependenciesCache::ModuleDependenciesCache(
-    GlobalModuleDependenciesCache &globalCache,
+    SwiftDependencyScanningService &globalScanningService,
     std::string mainScanModuleName,
-    std::string scannerContextHash)
-    : globalCache(globalCache),
+    std::string scanningContextHash)
+    : globalScanningService(globalScanningService),
       mainScanModuleName(mainScanModuleName),
-      scannerContextHash(scannerContextHash),
-      clangScanningTool(globalCache.ClangScanningService) {
-  globalCache.configureForContextHash(scannerContextHash);
+      clangScanningTool(globalScanningService.ClangScanningService) {
+  globalScanningService.configureForContextHash(scannerContextHash);
   for (auto kind = ModuleDependencyKind::FirstKind;
        kind != ModuleDependencyKind::LastKind; ++kind) {
     ModuleDependenciesMap.insert(
@@ -481,7 +480,7 @@ ModuleDependenciesCache::findDependencies(
   if (localResult.has_value())
     return *(localResult.value());
   else
-    return globalCache.findDependencies(moduleName, kind);
+    return globalScanningService.findDependencies(moduleName, kind);
 }
 
 bool ModuleDependenciesCache::hasDependenciesLocalOnly(StringRef moduleName,
@@ -523,7 +522,7 @@ void ModuleDependenciesCache::recordDependencies(
 
   } else
     recordedDependencies =
-        globalCache.recordDependencies(moduleName, dependencies);
+        globalScanningService.recordDependencies(moduleName, dependencies);
 
   auto &map = getDependencyReferencesMap(dependenciesKind);
   assert(map.count(moduleName) == 0 && "Already added to map");
@@ -532,7 +531,7 @@ void ModuleDependenciesCache::recordDependencies(
 
 void ModuleDependenciesCache::updateDependencies(
     ModuleDependencyID moduleID, ModuleDependencyInfo dependencies) {
-  auto globalDepRef = globalCache.updateDependencies(moduleID, dependencies);
+  auto globalDepRef = globalScanningService.updateDependencies(moduleID, dependencies);
   auto &map = getDependencyReferencesMap(moduleID.second);
   auto known = map.find(moduleID.first);
   if (known != map.end())