Merge pull request #60789 from artemcm/DepScan-ForgetUnderlyingModule

[Dependency Scanning] Do not add underlying Clang moduel to persistent (global) scanner cache

Author: artemcm

include/swift/AST/ModuleDependencies.h

@@ -610,6 +610,15 @@ class ModuleDependenciesCache {
   /// Additional information needed for Clang dependency scanning.
   ClangModuleDependenciesCacheImpl *clangImpl = nullptr;
 
+  /// Name of the main Swift module of this scan
+  StringRef mainModuleName;
+  /// Underlying Clang module is seen differently by the main
+  /// module and by module clients. For this reason, we do not wish subsequent
+  /// scans to be able to re-use this dependency info and therefore we avoid
+  /// adding it to the global cache. The dependency storage is therefore tied
+  /// to this, local, cache.
+  std::unique_ptr<ModuleDependencies> underlyingClangModuleDependency = nullptr;
+
   /// Function that will delete \c clangImpl properly.
   void (*clangImplDeleter)(ClangModuleDependenciesCacheImpl *) = nullptr;
 
@@ -638,7 +647,8 @@ class ModuleDependenciesCache {
                    Optional<ModuleDependenciesKind> kind) const;
 
 public:
-  ModuleDependenciesCache(GlobalModuleDependenciesCache &globalCache);
+  ModuleDependenciesCache(GlobalModuleDependenciesCache &globalCache,
+                          StringRef mainModuleName);
   ModuleDependenciesCache(const ModuleDependenciesCache &) = delete;
   ModuleDependenciesCache &operator=(const ModuleDependenciesCache &) = delete;
   virtual ~ModuleDependenciesCache() { destroyClangImpl(); }

lib/AST/ModuleDependencies.cpp

@@ -517,8 +517,9 @@ ModuleDependenciesCache::getDependencyReferencesMap(
 }
 
 ModuleDependenciesCache::ModuleDependenciesCache(
-    GlobalModuleDependenciesCache &globalCache)
-    : globalCache(globalCache) {
+    GlobalModuleDependenciesCache &globalCache,
+    StringRef mainModuleName)
+    : globalCache(globalCache), mainModuleName(mainModuleName) {
   for (auto kind = ModuleDependenciesKind::FirstKind;
        kind != ModuleDependenciesKind::LastKind; ++kind) {
     ModuleDependenciesMap.insert(
@@ -566,11 +567,21 @@ bool ModuleDependenciesCache::hasDependencies(
 
 void ModuleDependenciesCache::recordDependencies(
     StringRef moduleName, ModuleDependencies dependencies) {
-  auto globalDepPtr = globalCache.recordDependencies(moduleName, dependencies);
-  auto kind = globalDepPtr->getKind();
-  auto &map = getDependencyReferencesMap(kind);
+  auto dependenciesKind = dependencies.getKind();
+
+  // The underlying Clang module needs to be cached in this invocation,
+  // but should not make it to the global cache since it will look slightly
+  // differently for clients of this module than it does for the module itself.
+  const ModuleDependencies* recordedDependencies;
+  if (moduleName == mainModuleName && dependencies.isClangModule()) {
+    underlyingClangModuleDependency = std::make_unique<ModuleDependencies>(std::move(dependencies));
+    recordedDependencies = underlyingClangModuleDependency.get();
+  } else
+    recordedDependencies = globalCache.recordDependencies(moduleName, dependencies);
+
+  auto &map = getDependencyReferencesMap(dependenciesKind);
   assert(map.count(moduleName) == 0 && "Already added to map");
-  map.insert({moduleName, globalDepPtr});
+  map.insert({moduleName, recordedDependencies});
 }
 
 void ModuleDependenciesCache::updateDependencies(

lib/DependencyScan/DependencyScanningTool.cpp

@@ -73,7 +73,8 @@ DependencyScanningTool::getDependencies(
   auto Instance = std::move(*InstanceOrErr);
 
   // Local scan cache instance, wrapping the shared global cache.
-  ModuleDependenciesCache cache(*SharedCache);
+  ModuleDependenciesCache cache(*SharedCache,
+                                Instance->getMainModule()->getNameStr());
   // Execute the scanning action, retrieving the in-memory result
   auto DependenciesOrErr = performModuleScan(*Instance.get(), cache);
   if (DependenciesOrErr.getError())
@@ -113,7 +114,8 @@ DependencyScanningTool::getDependencies(
   auto Instance = std::move(*InstanceOrErr);
 
   // Local scan cache instance, wrapping the shared global cache.
-  ModuleDependenciesCache cache(*SharedCache);
+  ModuleDependenciesCache cache(*SharedCache,
+                                Instance->getMainModule()->getNameStr());
   auto BatchScanResults = performBatchModuleScan(
       *Instance.get(), cache, VersionedPCMInstanceCacheCache.get(),
       Saver, BatchInput);

lib/DependencyScan/ScanDependencies.cpp

@@ -1089,32 +1089,33 @@ forEachBatchEntry(CompilerInstance &invocationInstance,
 
       // Create a new instance by the arguments and save it in the map.
       auto newGlobalCache = std::make_unique<GlobalModuleDependenciesCache>();
-      subInstanceMap->insert(
-          {entry.arguments,
-           std::make_tuple(std::make_unique<CompilerInstance>(),
-                           std::move(newGlobalCache),
-                           std::make_unique<ModuleDependenciesCache>(*newGlobalCache))});
+      auto newInstance = std::make_unique<CompilerInstance>();
 
-      pInstance = std::get<0>((*subInstanceMap)[entry.arguments]).get();
-      auto globalCache = std::get<1>((*subInstanceMap)[entry.arguments]).get();
-      pCache = std::get<2>((*subInstanceMap)[entry.arguments]).get();
       SmallVector<const char *, 4> args;
       llvm::cl::TokenizeGNUCommandLine(entry.arguments, saver, args);
       CompilerInvocation subInvoke = invoke;
-      pInstance->addDiagnosticConsumer(&FDC);
+      newInstance->addDiagnosticConsumer(&FDC);
       if (subInvoke.parseArgs(args, diags)) {
         invocationInstance.getDiags().diagnose(
             SourceLoc(), diag::scanner_arguments_invalid, entry.arguments);
         return true;
       }
       std::string InstanceSetupError;
-      if (pInstance->setup(subInvoke, InstanceSetupError)) {
+      if (newInstance->setup(subInvoke, InstanceSetupError)) {
         invocationInstance.getDiags().diagnose(
             SourceLoc(), diag::scanner_arguments_invalid, entry.arguments);
         return true;
       }
-      globalCache->configureForTriple(pInstance->getInvocation()
-                                                .getLangOptions().Target.str());
+      newGlobalCache->configureForTriple(
+          newInstance->getInvocation().getLangOptions().Target.str());
+      auto newLocalCache = std::make_unique<ModuleDependenciesCache>(
+          *newGlobalCache, newInstance->getMainModule()->getNameStr());
+      pInstance = newInstance.get();
+      pCache = newLocalCache.get();
+      subInstanceMap->insert(
+          {entry.arguments,
+           std::make_tuple(std::move(newInstance), std::move(newGlobalCache),
+                           std::move(newLocalCache))});
     }
     assert(pInstance);
     assert(pCache);
@@ -1252,7 +1253,8 @@ bool swift::dependencies::scanDependencies(CompilerInstance &instance) {
   if (opts.ReuseDependencyScannerCache)
     deserializeDependencyCache(instance, globalCache);
 
-  ModuleDependenciesCache cache(globalCache);
+  ModuleDependenciesCache cache(globalCache,
+                                instance.getMainModule()->getNameStr());
 
   // Execute scan
   auto dependenciesOrErr = performModuleScan(instance, cache);
@@ -1287,7 +1289,8 @@ bool swift::dependencies::prescanDependencies(CompilerInstance &instance) {
   GlobalModuleDependenciesCache singleUseGlobalCache;
   singleUseGlobalCache.configureForTriple(instance.getInvocation()
                                                   .getLangOptions().Target.str());
-  ModuleDependenciesCache cache(singleUseGlobalCache);
+  ModuleDependenciesCache cache(singleUseGlobalCache,
+                                instance.getMainModule()->getNameStr());
   if (out.has_error() || EC) {
     Context.Diags.diagnose(SourceLoc(), diag::error_opening_output, path,
                            EC.message());
@@ -1318,7 +1321,8 @@ bool swift::dependencies::batchScanDependencies(
   GlobalModuleDependenciesCache singleUseGlobalCache;
   singleUseGlobalCache.configureForTriple(instance.getInvocation()
                                                   .getLangOptions().Target.str());
-  ModuleDependenciesCache cache(singleUseGlobalCache);
+  ModuleDependenciesCache cache(singleUseGlobalCache,
+                                instance.getMainModule()->getNameStr());
   (void)instance.getMainModule();
   llvm::BumpPtrAllocator alloc;
   llvm::StringSaver saver(alloc);
@@ -1353,7 +1357,8 @@ bool swift::dependencies::batchPrescanDependencies(
   GlobalModuleDependenciesCache singleUseGlobalCache;
   singleUseGlobalCache.configureForTriple(instance.getInvocation()
                                                   .getLangOptions().Target.str());
-  ModuleDependenciesCache cache(singleUseGlobalCache);
+  ModuleDependenciesCache cache(singleUseGlobalCache,
+                                instance.getMainModule()->getNameStr());
   (void)instance.getMainModule();
   llvm::BumpPtrAllocator alloc;
   llvm::StringSaver saver(alloc);