[Dependency Scanning] Do not disambiguate 'GlobalModuleDependenciesCache' by search path set

This is no longer necessary since the cache is always configured for the current scanning context hash, which includes the search path set.

Author: artemcm

include/swift/AST/ModuleDependencies.h

@@ -76,12 +76,6 @@ struct ModuleDependenciesKindHash {
   }
 };
 
-/// Details of a given module used for dependency scanner cache queries.
-struct ModuleLookupSpecifics {
-  Optional<ModuleDependenciesKind> kind;
-  llvm::StringSet<> currentSearchPaths;
-};
-
 /// Base class for the variant storage of ModuleDependencies.
 ///
 /// This class is mostly an implementation detail for \c ModuleDependencies.
@@ -331,6 +325,7 @@ class ModuleDependencies {
     : storage(std::move(storage)) { }
 
 public:
+  ModuleDependencies() = default;
   ModuleDependencies(const ModuleDependencies &other)
     : storage(other.storage->clone()) { }
   ModuleDependencies(ModuleDependencies &&other) = default;
@@ -481,9 +476,10 @@ class ModuleDependencies {
 
 using ModuleDependencyID = std::pair<std::string, ModuleDependenciesKind>;
 using ModuleDependenciesVector = llvm::SmallVector<ModuleDependencies, 1>;
+using ModuleNameToDependencyMap = llvm::StringMap<ModuleDependencies>;
 using ModuleDependenciesKindMap =
     std::unordered_map<ModuleDependenciesKind,
-                       llvm::StringMap<ModuleDependenciesVector>,
+                       ModuleNameToDependencyMap,
                        ModuleDependenciesKindHash>;
 using ModuleDependenciesKindRefMap =
     std::unordered_map<ModuleDependenciesKind,
@@ -497,9 +493,6 @@ using ModuleDependenciesKindRefMap =
 /// `DependencyScanningTool`). 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.
-/// Queries to this cache must be disambiguated with a set of search paths to
-/// ensure that the returned cached dependency was one that can be found in the
-/// current scanning action's filesystem view.
 class GlobalModuleDependenciesCache {
   /// Global cache contents specific to a specific scanner invocation context
   struct ContextSpecificGlobalCacheState {
@@ -508,9 +501,7 @@ class GlobalModuleDependenciesCache {
     std::vector<ModuleDependencyID> AllModules;
 
     /// Dependencies for modules that have already been computed.
-    /// This maps a dependency kind to a map of a module's name to a vector of Dependency objects,
-    /// which correspond to instances of the same module that may have been found
-    /// in different sets of search paths.
+    /// This maps a dependency kind to a map of a module's name to a Dependency object
     ModuleDependenciesKindMap ModuleDependenciesMap;
   };
 
@@ -522,7 +513,7 @@ class GlobalModuleDependenciesCache {
 
   /// Dependencies for all Swift source-based modules discovered. Each one is the main
   /// module of a prior invocation of the scanner.
-  llvm::StringMap<ModuleDependencies> SwiftSourceModuleDependenciesMap;
+  ModuleNameToDependencyMap SwiftSourceModuleDependenciesMap;
 
   /// A map from a String representing the target triple of a scanner invocation to the corresponding
   /// cached dependencies discovered so far when using this triple.
@@ -536,9 +527,9 @@ class GlobalModuleDependenciesCache {
 
   /// Retrieve the dependencies map that corresponds to the given dependency
   /// kind.
-  llvm::StringMap<ModuleDependenciesVector> &
+  ModuleNameToDependencyMap &
   getDependenciesMap(ModuleDependenciesKind kind);
-  const llvm::StringMap<ModuleDependenciesVector> &
+  const ModuleNameToDependencyMap &
   getDependenciesMap(ModuleDependenciesKind kind) const;
 
 public:
@@ -548,8 +539,6 @@ class GlobalModuleDependenciesCache {
   operator=(const GlobalModuleDependenciesCache &) = delete;
   virtual ~GlobalModuleDependenciesCache() {}
 
-  void configureForContextHash(std::string scanningContextHash);
-
   const std::vector<std::string>& getAllContextHashes() const {
     return AllContextHashes;
   }
@@ -558,38 +547,34 @@ class GlobalModuleDependenciesCache {
   /// Enforce clients not being allowed to query this cache directly, it must be
   /// wrapped in an instance of `ModuleDependenciesCache`.
   friend class ModuleDependenciesCache;
+  friend class ModuleDependenciesCacheDeserializer;
+  friend class ModuleDependenciesCacheSerializer;
+
+  /// Configure the current state of the cache to respond to queries
+  /// for the specified scanning context hash.
+  void configureForContextHash(std::string scanningContextHash);
 
   /// Whether we have cached dependency information for the given module.
   bool hasDependencies(StringRef moduleName,
-                       ModuleLookupSpecifics details) const;
-
-  /// Look for module dependencies for a module with the given name given
-  /// current search paths.
-  ///
-  /// \returns the cached result, or \c None if there is no cached entry.
-  Optional<ModuleDependencies>
-  findDependencies(StringRef moduleName, ModuleLookupSpecifics details) const;
+                       Optional<ModuleDependenciesKind> kind) const;
 
   /// Return a pointer to the context-specific cache state of the current scanning action.
   ContextSpecificGlobalCacheState* getCurrentCache() const;
 
   /// Return a pointer to the cache state of the specified context hash.
   ContextSpecificGlobalCacheState* getCacheForScanningContextHash(StringRef scanningContextHash) const;
 
-public:
-  /// Look for module dependencies for a module with the given name.
-  /// This method has a deliberately-obtuse name to indicate that it is not to
-  /// be used for general queries.
-  ///
-  /// \returns the cached result, or \c None if there is no cached entry.
-  Optional<ModuleDependenciesVector>
-  findAllDependenciesIrrespectiveOfSearchPaths(
-      StringRef moduleName, Optional<ModuleDependenciesKind> kind) const;
-
   /// Look for source-based module dependency details
   Optional<ModuleDependencies>
   findSourceModuleDependency(StringRef moduleName) const;
 
+  /// Look for module dependencies for a module with the given name
+  ///
+  /// \returns the cached result, or \c None if there is no cached entry.
+  Optional<ModuleDependencies>
+  findDependencies(StringRef moduleName,
+                   Optional<ModuleDependenciesKind> kind) const;
+
   /// Record dependencies for the given module.
   const ModuleDependencies *recordDependencies(StringRef moduleName,
                                                ModuleDependencies dependencies);
@@ -616,8 +601,7 @@ class GlobalModuleDependenciesCache {
 /// scanning action, and wraps an instance of a `GlobalModuleDependenciesCache`
 /// 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),
-/// since these do not require clients to disambiguate them with search paths.
+/// the current scanning action (with their values stored in the global Cache).
 class ModuleDependenciesCache {
 private:
   GlobalModuleDependenciesCache &globalCache;
@@ -629,11 +613,13 @@ class ModuleDependenciesCache {
 
   /// Name of the module under scan
   StringRef mainScanModuleName;
+  /// The context hash of the current scanning invocation
+  std::string scannerContextHash;
+
   /// Set containing all of the Clang modules that have already been seen.
   llvm::StringSet<> alreadySeenClangModules;
   /// The Clang dependency scanner tool
   clang::tooling::dependencies::DependencyScanningTool clangScanningTool;
-
   /// Discovered Clang modules are only cached locally.
   llvm::StringMap<ModuleDependenciesVector> clangModuleDependencies;
 
@@ -646,25 +632,26 @@ class ModuleDependenciesCache {
 
   /// Local cache results lookup, only for modules which were discovered during
   /// the current scanner invocation.
-  bool hasDependencies(StringRef moduleName,
-                       Optional<ModuleDependenciesKind> kind) const;
+  bool hasDependenciesLocalOnly(StringRef moduleName,
+                                Optional<ModuleDependenciesKind> kind) const;
 
   /// Local cache results lookup, only for modules which were discovered during
   /// the current scanner invocation.
   Optional<const ModuleDependencies *>
-  findDependencies(StringRef moduleName,
-                   Optional<ModuleDependenciesKind> kind) const;
+  findDependenciesLocalOnly(StringRef moduleName,
+                            Optional<ModuleDependenciesKind> kind) const;
 
 public:
   ModuleDependenciesCache(GlobalModuleDependenciesCache &globalCache,
-                          StringRef mainScanModuleName);
+                          std::string mainScanModuleName,
+                          std::string scanningContextHash);
   ModuleDependenciesCache(const ModuleDependenciesCache &) = delete;
   ModuleDependenciesCache &operator=(const ModuleDependenciesCache &) = delete;
 
 public:
   /// Whether we have cached dependency information for the given module.
   bool hasDependencies(StringRef moduleName,
-                       ModuleLookupSpecifics details) const;
+                       Optional<ModuleDependenciesKind> kind) const;
 
   /// Produce a reference to the Clang scanner tool associated with this cache
   clang::tooling::dependencies::DependencyScanningTool& getClangScannerTool() {
@@ -674,24 +661,12 @@ class ModuleDependenciesCache {
     return alreadySeenClangModules;
   }
 
-  /// Look for module dependencies for a module with the given name given
-  /// current search paths.
+  /// Look for module dependencies for a module with the given name
   ///
   /// \returns the cached result, or \c None if there is no cached entry.
   Optional<ModuleDependencies>
-  findDependencies(StringRef moduleName, ModuleLookupSpecifics details) const;
-
-  /// Look for module dependencies for a module with the given name.
-  /// This method has a deliberately-obtuse name to indicate that it is not to
-  /// be used for general queries.
-  ///
-  /// \returns the cached result, or \c None if there is no cached entry.
-  Optional<ModuleDependenciesVector>
-  findAllDependenciesIrrespectiveOfSearchPaths(
-      StringRef moduleName, Optional<ModuleDependenciesKind> kind) const {
-    return globalCache.findAllDependenciesIrrespectiveOfSearchPaths(moduleName,
-                                                                    kind);
-  }
+  findDependencies(StringRef moduleName,
+                   Optional<ModuleDependenciesKind> kind) const;
 
   /// Record dependencies for the given module.
   void recordDependencies(StringRef moduleName,

lib/AST/ASTContext.cpp

@@ -1883,21 +1883,23 @@ Identifier ASTContext::getRealModuleName(Identifier key, ModuleAliasLookupOption
   return value.first;
 }
 
-using ModuleDependencyIDSet = std::unordered_set<ModuleDependencyID, llvm::pair_hash<std::string, ModuleDependenciesKind>>;
+using ModuleDependencyIDSet =
+    std::unordered_set<ModuleDependencyID,
+                       llvm::pair_hash<std::string,
+                                       ModuleDependenciesKind>>;
 static void findPath_dfs(ModuleDependencyID X,
                          ModuleDependencyID Y,
                          ModuleDependencyIDSet &visited,
                          std::vector<ModuleDependencyID> &stack,
                          std::vector<ModuleDependencyID> &result,
-                         const ModuleDependenciesCache &cache,
-                         const llvm::StringSet<> &searchPathSet) {
+                         const ModuleDependenciesCache &cache) {
   stack.push_back(X);
   if (X == Y) {
     copy(stack.begin(), stack.end(), std::back_inserter(result));
     return;
   }
   visited.insert(X);
-  auto node = cache.findDependencies(X.first, {X.second, searchPathSet});
+  auto node = cache.findDependencies(X.first, X.second);
   assert(node.has_value() && "Expected cache value for dependency.");
   for (const auto &dep : node->getModuleDependencies()) {
     Optional<ModuleDependenciesKind> lookupKind = None;
@@ -1906,24 +1908,22 @@ static void findPath_dfs(ModuleDependencyID X,
     if ((dep == X.first && node->isSwiftModule()) || node->isClangModule())
       lookupKind = ModuleDependenciesKind::Clang;
 
-    auto depNode = cache.findDependencies(dep, {lookupKind, searchPathSet});
+    auto depNode = cache.findDependencies(dep, lookupKind);
     if (!depNode.has_value())
       continue;
     auto depID = std::make_pair(dep, depNode->getKind());
     if (!visited.count(depID)) {
-      findPath_dfs(depID, Y, visited, stack, result, cache, searchPathSet);
+      findPath_dfs(depID, Y, visited, stack, result, cache);
     }
   }
   stack.pop_back();
 }
 
 static std::vector<ModuleDependencyID>
 findPathToDependency(ModuleDependencyID dependency,
-                     const ModuleDependenciesCache &cache,
-                     const llvm::StringSet<> &searchPathSet) {
+                     const ModuleDependenciesCache &cache) {
   auto mainModuleDep = cache.findDependencies(cache.getMainModuleName(),
-                                              {ModuleDependenciesKind::SwiftSource,
-                                               searchPathSet});
+                                              ModuleDependenciesKind::SwiftSource);
   // We may be in a batch scan instance which does not have this dependency
   if (!mainModuleDep.has_value())
     return {};
@@ -1932,7 +1932,7 @@ findPathToDependency(ModuleDependencyID dependency,
   auto visited = ModuleDependencyIDSet();
   auto stack = std::vector<ModuleDependencyID>();
   auto dependencyPath = std::vector<ModuleDependencyID>();
-  findPath_dfs(mainModuleID, dependency, visited, stack, dependencyPath, cache, searchPathSet);
+  findPath_dfs(mainModuleID, dependency, visited, stack, dependencyPath, cache);
   return dependencyPath;
 }
 
@@ -1941,19 +1941,18 @@ findPathToDependency(ModuleDependencyID dependency,
 static void diagnoseScannerFailure(StringRef moduleName,
                                    DiagnosticEngine &Diags,
                                    const ModuleDependenciesCache &cache,
-                                   const llvm::StringSet<> &searchPathSet,
                                    llvm::Optional<ModuleDependencyID> dependencyOf) {
   Diags.diagnose(SourceLoc(), diag::dependency_scan_module_not_found, moduleName);
   if (dependencyOf.has_value()) {
-    auto path = findPathToDependency(dependencyOf.value(), cache, searchPathSet);
+    auto path = findPathToDependency(dependencyOf.value(), cache);
     // We may fail to construct a path in some cases, such as a Swift overlay of a Clang
     // module dependnecy.
     if (path.empty())
       path = {dependencyOf.value()};
 
     for (auto it = path.rbegin(), end = path.rend(); it != end; ++it) {
       const auto &entry = *it;
-      auto entryNode = cache.findDependencies(entry.first, {entry.second, searchPathSet});
+      auto entryNode = cache.findDependencies(entry.first, entry.second);
       assert(entryNode.has_value());
       std::string moduleFilePath = "";
       bool isClang = false;
@@ -1996,23 +1995,20 @@ Optional<ModuleDependencies> ASTContext::getModuleDependencies(
     // Check whether we've cached this result.
     if (!isUnderlyingClangModule) {
       if (auto found = cache.findDependencies(
-              moduleName,
-              {ModuleDependenciesKind::SwiftSource, searchPathSet}))
+              moduleName, ModuleDependenciesKind::SwiftSource))
         return found;
       if (auto found = cache.findDependencies(
-              moduleName,
-              {ModuleDependenciesKind::SwiftInterface, searchPathSet}))
+              moduleName, ModuleDependenciesKind::SwiftInterface))
         return found;
       if (auto found = cache.findDependencies(
-              moduleName, {ModuleDependenciesKind::SwiftBinary, searchPathSet}))
+              moduleName, ModuleDependenciesKind::SwiftBinary))
         return found;
       if (auto found = cache.findDependencies(
-              moduleName,
-              {ModuleDependenciesKind::SwiftPlaceholder, searchPathSet}))
+              moduleName, ModuleDependenciesKind::SwiftPlaceholder))
         return found;
     }
     if (auto found = cache.findDependencies(
-            moduleName, {ModuleDependenciesKind::Clang, searchPathSet}))
+            moduleName, ModuleDependenciesKind::Clang))
       return found;
   } else {
     for (auto &loader : getImpl().ModuleLoaders) {
@@ -2025,7 +2021,7 @@ Optional<ModuleDependencies> ASTContext::getModuleDependencies(
         return dependencies;
     }
 
-    diagnoseScannerFailure(moduleName, Diags, cache, searchPathSet,
+    diagnoseScannerFailure(moduleName, Diags, cache,
                            dependencyOf);
   }