[Dependency Scanning] Record header dependencies of Binary Swift module dependencies

artemcm · artemcm · commit b974d9787976 · 2023-06-12T14:56:28.000-04:00
These are meant to capture paths to the PCH files that a given module was built with.
diff --git a/include/swift/AST/ModuleDependencies.h b/include/swift/AST/ModuleDependencies.h
@@ -106,10 +106,15 @@ class ModuleDependencyInfoStorageBase {
   const ModuleDependencyKind dependencyKind;
 
   ModuleDependencyInfoStorageBase(ModuleDependencyKind dependencyKind,
-                                  StringRef moduleCacheKey = "",
-                                  bool resolved = false)
+                                  StringRef moduleCacheKey = "")
       : dependencyKind(dependencyKind), moduleCacheKey(moduleCacheKey.str()),
-        resolved(resolved) {}
+        resolved(false) { }
+
+  ModuleDependencyInfoStorageBase(ModuleDependencyKind dependencyKind,
+                                  const std::vector<std::string> &moduleImports,
+                                  StringRef moduleCacheKey = "")
+      : dependencyKind(dependencyKind), moduleImports(moduleImports),
+        moduleCacheKey(moduleCacheKey.str()), resolved(false)  {}
 
   virtual ModuleDependencyInfoStorageBase *clone() const = 0;
 
@@ -282,12 +287,15 @@ class SwiftBinaryModuleDependencyStorage : public ModuleDependencyInfoStorageBas
   SwiftBinaryModuleDependencyStorage(const std::string &compiledModulePath,
                                      const std::string &moduleDocPath,
                                      const std::string &sourceInfoPath,
+                                     const std::vector<std::string> &moduleImports,
+                                     const std::vector<std::string> &headerImports,
                                      const bool isFramework,
                                      const std::string &moduleCacheKey)
       : ModuleDependencyInfoStorageBase(ModuleDependencyKind::SwiftBinary,
-                                        moduleCacheKey),
+                                        moduleImports, moduleCacheKey),
         compiledModulePath(compiledModulePath), moduleDocPath(moduleDocPath),
-        sourceInfoPath(sourceInfoPath), isFramework(isFramework) {}
+        sourceInfoPath(sourceInfoPath), preCompiledBridgingHeaderPaths(headerImports),
+        isFramework(isFramework) {}
 
   ModuleDependencyInfoStorageBase *clone() const override {
     return new SwiftBinaryModuleDependencyStorage(*this);
@@ -302,6 +310,9 @@ class SwiftBinaryModuleDependencyStorage : public ModuleDependencyInfoStorageBas
   /// The path to the .swiftSourceInfo file.
   const std::string sourceInfoPath;
 
+  /// The paths of all the .pch dependencies of this module.
+  const std::vector<std::string> preCompiledBridgingHeaderPaths;
+
   /// A flag that indicates this dependency is a framework
   const bool isFramework;
 
@@ -447,15 +458,17 @@ class ModuleDependencyInfo {
   }
 
   /// Describe the module dependencies for a serialized or parsed Swift module.
-  static ModuleDependencyInfo
-  forSwiftBinaryModule(const std::string &compiledModulePath,
-                       const std::string &moduleDocPath,
-                       const std::string &sourceInfoPath, bool isFramework,
-                       const std::string &moduleCacheKey) {
+  static ModuleDependencyInfo forSwiftBinaryModule(
+      const std::string &compiledModulePath,
+      const std::string &moduleDocPath,
+      const std::string &sourceInfoPath,
+      const std::vector<std::string> &moduleImports,
+      const std::vector<std::string> &headerImports,
+      bool isFramework, const std::string &moduleCacheKey) {
     return ModuleDependencyInfo(
         std::make_unique<SwiftBinaryModuleDependencyStorage>(
-            compiledModulePath, moduleDocPath, sourceInfoPath, isFramework,
-            moduleCacheKey));
+          compiledModulePath, moduleDocPath, sourceInfoPath,
+          moduleImports, headerImports, isFramework, moduleCacheKey));
   }
 
   /// Describe the main Swift module.
diff --git a/include/swift/DependencyScan/SerializedModuleDependencyCacheFormat.h b/include/swift/DependencyScan/SerializedModuleDependencyCacheFormat.h
@@ -165,6 +165,7 @@ using SwiftBinaryModuleDetailsLayout =
                    FileIDField,                      // compiledModulePath
                    FileIDField,                      // moduleDocPath
                    FileIDField,                      // moduleSourceInfoPath
+                   ImportArrayIDField,               // headerImports
                    IsFrameworkField,                 // isFramework
                    IdentifierIDField                 // moduleCacheKey
                    >;
diff --git a/include/swift/Serialization/SerializedModuleLoader.h b/include/swift/Serialization/SerializedModuleLoader.h
@@ -150,15 +150,20 @@ class SerializedModuleLoaderBase : public ModuleLoader {
   /// Scan the given serialized module file to determine dependencies.
   llvm::ErrorOr<ModuleDependencyInfo> scanModuleFile(Twine modulePath, bool isFramework);
 
-  static llvm::ErrorOr<llvm::StringSet<>>
-  getModuleImportsOfModule(Twine modulePath,
-                           ModuleLoadingBehavior transitiveBehavior,
-                           bool isFramework,
-                           bool isRequiredOSSAModules,
-                           StringRef SDKName,
-                           StringRef packageName,
-                           llvm::vfs::FileSystem *fileSystem,
-                           PathObfuscator &recoverer);
+  struct BinaryModuleImports {
+    llvm::StringSet<> moduleImports;
+    llvm::StringSet<> headerImports;
+  };
+
+  static llvm::ErrorOr<BinaryModuleImports>
+  getImportsOfModule(Twine modulePath,
+                     ModuleLoadingBehavior transitiveBehavior,
+                     bool isFramework,
+                     bool isRequiredOSSAModules,
+                     StringRef SDKName,
+                     StringRef packageName,
+                     llvm::vfs::FileSystem *fileSystem,
+                     PathObfuscator &recoverer);
 
   /// Load the module file into a buffer and also collect its module name.
   static std::unique_ptr<llvm::MemoryBuffer>
diff --git a/lib/DependencyScan/ModuleDependencyCacheSerialization.cpp b/lib/DependencyScan/ModuleDependencyCacheSerialization.cpp
@@ -462,10 +462,11 @@ bool ModuleDependenciesCacheDeserializer::readGraph(SwiftDependencyScanningServi
             "Unexpected SWIFT_BINARY_MODULE_DETAILS_NODE record");
       cache.configureForContextHash(getContextHash());
       unsigned compiledModulePathID, moduleDocPathID, moduleSourceInfoPathID,
-          isFramework, moduleCacheKeyID;
+               headerImportsArrayID, isFramework, moduleCacheKeyID;
       SwiftBinaryModuleDetailsLayout::readRecord(
           Scratch, compiledModulePathID, moduleDocPathID,
-          moduleSourceInfoPathID, isFramework, moduleCacheKeyID);
+          moduleSourceInfoPathID, headerImportsArrayID, isFramework,
+          moduleCacheKeyID);
 
       auto compiledModulePath = getIdentifier(compiledModulePathID);
       if (!compiledModulePath)
@@ -477,16 +478,18 @@ bool ModuleDependenciesCacheDeserializer::readGraph(SwiftDependencyScanningServi
       if (!moduleSourceInfoPath)
         llvm::report_fatal_error("Bad module source info path");
       auto moduleCacheKey = getIdentifier(moduleCacheKeyID);
-      if (!moduleCacheKeyID)
+      if (!moduleCacheKey)
         llvm::report_fatal_error("Bad moduleCacheKey");
 
+      auto headerImports = getStringArray(headerImportsArrayID);
+      if (!headerImports)
+        llvm::report_fatal_error("Bad binary direct dependencies: no header imports");
+
       // Form the dependencies storage object
       auto moduleDep = ModuleDependencyInfo::forSwiftBinaryModule(
-          *compiledModulePath, *moduleDocPath, *moduleSourceInfoPath,
-          isFramework, *moduleCacheKey);
-      // Add dependencies of this module
-      for (const auto &moduleName : *currentModuleImports)
-        moduleDep.addModuleImport(moduleName);
+           *compiledModulePath, *moduleDocPath, *moduleSourceInfoPath,
+           *currentModuleImports, *headerImports, isFramework,
+           *moduleCacheKey);
 
       cache.recordDependency(currentModuleName, std::move(moduleDep),
                              getContextHash());
@@ -704,6 +707,7 @@ bool swift::dependencies::module_dependency_cache_serialization::
 enum ModuleIdentifierArrayKind : uint8_t {
   Empty = 0,
   DependencyImports,
+  DependencyHeaders,
   QualifiedModuleDependencyIDs,
   CompiledModuleCandidates,
   BuildCommandLine,
@@ -975,6 +979,7 @@ void ModuleDependenciesCacheSerializer::writeModuleInfo(ModuleDependencyID modul
         getIdentifier(swiftBinDeps->compiledModulePath),
         getIdentifier(swiftBinDeps->moduleDocPath),
         getIdentifier(swiftBinDeps->sourceInfoPath),
+        getArrayID(moduleID, ModuleIdentifierArrayKind::DependencyHeaders),
         swiftBinDeps->isFramework,
         getIdentifier(swiftBinDeps->moduleCacheKey));
 
@@ -1152,6 +1157,8 @@ void ModuleDependenciesCacheSerializer::collectStringsAndArrays(
         addIdentifier(swiftBinDeps->moduleDocPath);
         addIdentifier(swiftBinDeps->sourceInfoPath);
         addIdentifier(swiftBinDeps->moduleCacheKey);
+        addStringArray(moduleID, ModuleIdentifierArrayKind::DependencyHeaders,
+                       swiftBinDeps->preCompiledBridgingHeaderPaths);
         break;
       }
       case swift::ModuleDependencyKind::SwiftPlaceholder: {
diff --git a/lib/Serialization/ModuleDependencyScanner.cpp b/lib/Serialization/ModuleDependencyScanner.cpp
@@ -208,38 +208,41 @@ ErrorOr<ModuleDependencyInfo> ModuleDependencyScanner::scanInterfaceFile(
           });
       if (adjacentBinaryModule != compiledCandidates.end()) {
         // Required modules.
-        auto adjacentBinaryModuleRequiredImports = getModuleImportsOfModule(
+        auto adjacentBinaryModuleRequiredImports = getImportsOfModule(
             *adjacentBinaryModule, ModuleLoadingBehavior::Required, isFramework,
             isRequiredOSSAModules(), Ctx.LangOpts.SDKName,
             Ctx.LangOpts.PackageName, Ctx.SourceMgr.getFileSystem().get(),
             Ctx.SearchPathOpts.DeserializedPathRecoverer);
         if (!adjacentBinaryModuleRequiredImports)
           return adjacentBinaryModuleRequiredImports.getError();
-
+        auto adjacentBinaryModuleRequiredModuleImports =
+          (*adjacentBinaryModuleRequiredImports).moduleImports;
 #ifndef NDEBUG
         //  Verify that the set of required modules read out from the binary
         //  module is a super-set of module imports identified in the
         //  textual interface.
         for (const auto &requiredImport : Result->getModuleImports()) {
-          assert(adjacentBinaryModuleRequiredImports->contains(requiredImport) &&
+          assert(adjacentBinaryModuleRequiredModuleImports.contains(requiredImport) &&
                  "Expected adjacent binary module's import set to contain all "
                  "textual interface imports.");
         }
 #endif
 
-        for (const auto &requiredImport : *adjacentBinaryModuleRequiredImports)
+        for (const auto &requiredImport : adjacentBinaryModuleRequiredModuleImports)
           Result->addModuleImport(requiredImport.getKey(),
                                   &alreadyAddedModules);
 
         // Optional modules. Will be looked-up on a best-effort basis
-        auto adjacentBinaryModuleOptionalImports = getModuleImportsOfModule(
+        auto adjacentBinaryModuleOptionalImports = getImportsOfModule(
             *adjacentBinaryModule, ModuleLoadingBehavior::Optional, isFramework,
             isRequiredOSSAModules(), Ctx.LangOpts.SDKName,
             Ctx.LangOpts.PackageName, Ctx.SourceMgr.getFileSystem().get(),
             Ctx.SearchPathOpts.DeserializedPathRecoverer);
         if (!adjacentBinaryModuleOptionalImports)
           return adjacentBinaryModuleOptionalImports.getError();
-        for (const auto &optionalImport : *adjacentBinaryModuleOptionalImports)
+        auto adjacentBinaryModuleOptionalModuleImports =
+          (*adjacentBinaryModuleOptionalImports).moduleImports;
+        for (const auto &optionalImport : adjacentBinaryModuleOptionalModuleImports)
           Result->addOptionalModuleImport(optionalImport.getKey(),
                                           &alreadyAddedModules);
       }
diff --git a/lib/Serialization/SerializedModuleLoader.cpp b/lib/Serialization/SerializedModuleLoader.cpp
@@ -392,8 +392,8 @@ std::error_code SerializedModuleLoaderBase::openModuleFile(
   return std::error_code();
 }
 
-llvm::ErrorOr<llvm::StringSet<>>
-SerializedModuleLoaderBase::getModuleImportsOfModule(
+llvm::ErrorOr<SerializedModuleLoaderBase::BinaryModuleImports>
+SerializedModuleLoaderBase::getImportsOfModule(
     Twine modulePath, ModuleLoadingBehavior transitiveBehavior,
     bool isFramework, bool isRequiredOSSAModules, StringRef SDKName,
     StringRef packageName, llvm::vfs::FileSystem *fileSystem,
@@ -403,16 +403,18 @@ SerializedModuleLoaderBase::getModuleImportsOfModule(
     return moduleBuf.getError();
 
   llvm::StringSet<> importedModuleNames;
+  llvm::StringSet<> importedHeaders;
   // Load the module file without validation.
   std::shared_ptr<const ModuleFileSharedCore> loadedModuleFile;
   serialization::ValidationInfo loadInfo = ModuleFileSharedCore::load(
       "", "", std::move(moduleBuf.get()), nullptr, nullptr, isFramework,
       isRequiredOSSAModules, SDKName, recoverer, loadedModuleFile);
 
   for (const auto &dependency : loadedModuleFile->getDependencies()) {
-    // FIXME: Record header dependency?
-    if (dependency.isHeader())
+    if (dependency.isHeader()) {
+      importedHeaders.insert(dependency.RawPath);
       continue;
+    }
 
     ModuleLoadingBehavior dependencyTransitiveBehavior =
         loadedModuleFile->getTransitiveLoadingBehavior(
@@ -433,17 +435,13 @@ SerializedModuleLoaderBase::getModuleImportsOfModule(
     importedModuleNames.insert(moduleName);
   }
 
-  return importedModuleNames;
+  return SerializedModuleLoaderBase::BinaryModuleImports{importedModuleNames, importedHeaders};
 }
 
 llvm::ErrorOr<ModuleDependencyInfo>
 SerializedModuleLoaderBase::scanModuleFile(Twine modulePath, bool isFramework) {
   const std::string moduleDocPath;
   const std::string sourceInfoPath;
-  // Map the set of dependencies over to the "module dependencies".
-  auto dependencies = ModuleDependencyInfo::forSwiftBinaryModule(
-      modulePath.str(), moduleDocPath, sourceInfoPath, isFramework,
-      /*module-cache-key*/ "");
   // Some transitive dependencies of binary modules are not required to be
   // imported during normal builds.
   // TODO: This is worth revisiting for debugger purposes where
@@ -452,18 +450,37 @@ SerializedModuleLoaderBase::scanModuleFile(Twine modulePath, bool isFramework) {
   //       optional.
   ModuleLoadingBehavior transitiveLoadingBehavior =
       ModuleLoadingBehavior::Required;
-  auto importedModuleNames = getModuleImportsOfModule(
+  auto binaryModuleImports = getImportsOfModule(
       modulePath, transitiveLoadingBehavior, isFramework,
       isRequiredOSSAModules(), Ctx.LangOpts.SDKName, Ctx.LangOpts.PackageName,
       Ctx.SourceMgr.getFileSystem().get(),
       Ctx.SearchPathOpts.DeserializedPathRecoverer);
-  if (!importedModuleNames)
-    return importedModuleNames.getError();
+  if (!binaryModuleImports)
+    return binaryModuleImports.getError();
+
+  auto importedModuleSet = binaryModuleImports.get().moduleImports;
+  std::vector<std::string> importedModuleNames;
+  importedModuleNames.reserve(importedModuleSet.size());
+  llvm::transform(importedModuleSet.keys(),
+                  std::back_inserter(importedModuleNames),
+                  [](llvm::StringRef N) {
+                     return N.str();
+                  });
+
+  auto importedHeaderSet = binaryModuleImports.get().headerImports;
+  std::vector<std::string> importedHeaders;
+  importedHeaders.reserve(importedHeaderSet.size());
+  llvm::transform(importedHeaderSet.keys(),
+                  std::back_inserter(importedHeaders),
+                  [](llvm::StringRef N) {
+                     return N.str();
+                  });
 
-  llvm::StringSet<> addedModuleNames;
-  for (const auto &importedModuleName : *importedModuleNames)
-    dependencies.addModuleImport(importedModuleName.getKey(),
-                                 &addedModuleNames);
+  // Map the set of dependencies over to the "module dependencies".
+  auto dependencies = ModuleDependencyInfo::forSwiftBinaryModule(
+       modulePath.str(), moduleDocPath, sourceInfoPath,
+       importedModuleNames, importedHeaders, isFramework,
+       /*module-cache-key*/ "");
 
   return std::move(dependencies);
 }
