[Dependency Scanning] Restrict Swift overlay lookup to "visible" Clang modules only

Previously Swift overlay lookup was performed for every directly and transitively-imported Clang module.

llvm/llvm-project#147969 introduced the concept of "visible" Clang modules from a given named Clang dependency scanner query which closely maps to the set of modules for which Swift will attempt to load a Swift overlay. This change switches overlay querying to apply only to the set of such visible modules.

Resolves rdar://144797648

Author: artemcm

include/swift/AST/ModuleDependencies.h

@@ -212,6 +212,11 @@ class ModuleDependencyInfoStorageBase {
   /// The macro dependencies.
   std::map<std::string, MacroPluginDependency> macroDependencies;
 
+  /// A list of Clang modules that are visible to this Swift module. This
+  /// includes both direct Clang modules as well as transitive Clang
+  /// module dependencies when they are exported
+  llvm::StringSet<> visibleClangModules;
+
   /// ModuleDependencyInfo is finalized (with all transitive dependencies
   /// and inputs).
   bool finalized;
@@ -816,7 +821,17 @@ class ModuleDependencyInfo {
       cast<ClangModuleDependencyStorage>(storage.get())->CASFileSystemRootID =
           rootID;
     else
-      llvm_unreachable("Unexpected type");
+      llvm_unreachable("Unexpected module dependency kind");
+  }
+
+  llvm::StringSet<> &getVisibleClangModules() const {
+    return storage->visibleClangModules;
+  }
+
+  void
+  addVisibleClangModules(const std::vector<std::string> &moduleNames) const {
+    storage->visibleClangModules.insert(moduleNames.begin(),
+                                        moduleNames.end());
   }
 
   /// Whether explicit input paths of all the module dependencies
@@ -1057,6 +1072,9 @@ class ModuleDependenciesCache {
   /// Query all cross-import overlay dependencies
   llvm::ArrayRef<ModuleDependencyID>
   getCrossImportOverlayDependencies(const ModuleDependencyID &moduleID) const;
+  /// Query all visible Clang modules for a given Swift dependency
+  llvm::StringSet<>&
+  getVisibleClangModules(ModuleDependencyID moduleID) const;
 
   /// Look for module dependencies for a module with the given ID
   ///
@@ -1123,6 +1141,11 @@ class ModuleDependenciesCache {
   setCrossImportOverlayDependencies(ModuleDependencyID moduleID,
                                     const ArrayRef<ModuleDependencyID> dependencyIDs);
 
+  /// Add to this module's set of visible Clang modules
+  void
+  addVisibleClangModules(ModuleDependencyID moduleID,
+                         const std::vector<std::string> &moduleNames);
+
   StringRef getMainModuleName() const { return mainScanModuleName; }
 
 private:

include/swift/DependencyScan/ModuleDependencyScanner.h

@@ -40,7 +40,7 @@ class ModuleDependencyScanningWorker {
 
 private:
   /// Retrieve the module dependencies for the Clang module with the given name.
-  ModuleDependencyVector scanFilesystemForClangModuleDependency(
+  ClangModuleScannerQueryResult scanFilesystemForClangModuleDependency(
       Identifier moduleName,
       const llvm::DenseSet<clang::tooling::dependencies::ModuleID>
           &alreadySeenModules);
@@ -72,6 +72,7 @@ class ModuleDependencyScanningWorker {
       ModuleDependencyIDSetVector &headerClangModuleDependencies,
       std::vector<std::string> &headerFileInputs,
       std::vector<std::string> &bridgingHeaderCommandLine,
+      std::vector<std::string> &visibleClangModules,
       std::optional<std::string> &includeTreeID);
 
 

include/swift/Serialization/ScanningLoaders.h

@@ -40,6 +40,18 @@ struct SwiftModuleScannerQueryResult {
   std::vector<IncompatibleCandidate> incompatibleCandidates;
 };
 
+/// Result of looking up a Clang module on the current filesystem
+/// search paths.
+struct ClangModuleScannerQueryResult {
+  ClangModuleScannerQueryResult(const ModuleDependencyVector &dependencyModuleGraph,
+                                const std::vector<std::string> &visibleModuleIdentifiers)
+      : foundDependencyModuleGraph(dependencyModuleGraph),
+        visibleModuleIdentifiers(visibleModuleIdentifiers) {}
+
+  ModuleDependencyVector foundDependencyModuleGraph;
+  std::vector<std::string> visibleModuleIdentifiers;
+};
+
 /// A module "loader" that looks for .swiftinterface and .swiftmodule files
 /// for the purpose of determining dependencies, but does not attempt to
 /// load the module files.

lib/AST/ModuleDependencies.cpp

@@ -918,6 +918,24 @@ ModuleDependenciesCache::setCrossImportOverlayDependencies(ModuleDependencyID mo
   updateDependency(moduleID, updatedDependencyInfo);
 }
 
+void
+ModuleDependenciesCache::addVisibleClangModules(ModuleDependencyID moduleID,
+                                                const std::vector<std::string> &moduleNames) {
+  if (moduleNames.empty())
+    return;
+  auto dependencyInfo = findKnownDependency(moduleID);
+  auto updatedDependencyInfo = dependencyInfo;
+  updatedDependencyInfo.addVisibleClangModules(moduleNames);
+  updateDependency(moduleID, updatedDependencyInfo);
+}
+
+llvm::StringSet<> &ModuleDependenciesCache::getVisibleClangModules(ModuleDependencyID moduleID) const {
+  ASSERT(moduleID.Kind == ModuleDependencyKind::SwiftSource ||
+         moduleID.Kind == ModuleDependencyKind::SwiftInterface ||
+         moduleID.Kind == ModuleDependencyKind::SwiftBinary);
+  return findKnownDependency(moduleID).getVisibleClangModules();
+}
+
 ModuleDependencyIDSetVector
 ModuleDependenciesCache::getAllDependencies(const ModuleDependencyID &moduleID) const {
   const auto &moduleInfo = findKnownDependency(moduleID);