[Caching] Resolve BridgingHeader Module Deps correctly

Fix the bridging header dependencies calculation for explicit module
build, especially for caching which needs an accurate list of deps for
compute cache key correctly.

Previously, the bridging header deps are computed from `ModuleGraph`
from the clang dependency scanner, which can be affected by already seen
modules. It causes the dependencies to be missing for bridging header if
the module is seen by main swift source module.

Now report only the directly module dependencies from bridging header,
then compute all the transitive dependencies before calculating all the
cache keys.

rdar://123156636

Author: cachemeifyoucan

lib/ClangImporter/ClangModuleDependencyScanner.cpp

@@ -491,8 +491,8 @@ bool ClangImporter::addBridgingHeaderDependencies(
 
   // ... and all module dependencies.
   llvm::StringSet<> alreadyAddedModules;
-  for (const auto &moduleDep : clangModuleDependencies->ModuleGraph)
-    targetModule.addBridgingModuleDependency(moduleDep.ID.ModuleName,
+  for (const auto &moduleDep : clangModuleDependencies->ClangModuleDeps)
+    targetModule.addBridgingModuleDependency(moduleDep.ModuleName,
                                              alreadyAddedModules);
 
   if (auto TreeID = clangModuleDependencies->IncludeTreeID)

lib/DependencyScan/ScanDependencies.cpp

@@ -193,7 +193,8 @@ updateModuleCacheKey(ModuleDependencyInfo &depInfo,
 static llvm::Error resolveExplicitModuleInputs(
     ModuleDependencyID moduleID, const ModuleDependencyInfo &resolvingDepInfo,
     const std::set<ModuleDependencyID> &dependencies,
-    ModuleDependenciesCache &cache, CompilerInstance &instance) {
+    ModuleDependenciesCache &cache, CompilerInstance &instance,
+    std::optional<std::set<ModuleDependencyID>> bridgingHeaderDeps) {
   // Only need to resolve dependency for following dependencies.
   if (moduleID.Kind == ModuleDependencyKind::SwiftPlaceholder)
     return llvm::Error::success();
@@ -359,13 +360,11 @@ static llvm::Error resolveExplicitModuleInputs(
       dependencyInfoCopy.updateCommandLine(newCommandLine);
     }
 
-    if (auto *sourceDep = resolvingDepInfo.getAsSwiftSourceModule()) {
+    if (bridgingHeaderDeps) {
       std::vector<std::string> newCommandLine =
           dependencyInfoCopy.getBridgingHeaderCommandline();
-      for (auto bridgingDep :
-           sourceDep->textualModuleDetails.bridgingModuleDependencies) {
-        auto dep =
-            cache.findDependency(bridgingDep, ModuleDependencyKind::Clang);
+      for (auto bridgingDep : *bridgingHeaderDeps) {
+        auto dep = cache.findDependency(bridgingDep);
         assert(dep && "unknown clang dependency");
         auto *clangDep = (*dep)->getAsClangModule();
         assert(clangDep && "wrong module dependency kind");
@@ -377,8 +376,8 @@ static llvm::Error resolveExplicitModuleInputs(
           newCommandLine.push_back("-Xcc");
           newCommandLine.push_back(clangDep->moduleCacheKey);
         }
-        dependencyInfoCopy.updateBridgingHeaderCommandLine(newCommandLine);
       }
+      dependencyInfoCopy.updateBridgingHeaderCommandLine(newCommandLine);
     }
 
     if (resolvingDepInfo.isClangModule() ||
@@ -1336,6 +1335,27 @@ computeTransitiveClosureOfExplicitDependencies(
   return result;
 }
 
+static std::set<ModuleDependencyID> computeBridgingHeaderTransitiveDependencies(
+    const ModuleDependencyInfo *dep,
+    const std::unordered_map<ModuleDependencyID, std::set<ModuleDependencyID>>
+        &transitiveClosures,
+    const ModuleDependenciesCache &cache) {
+  std::set<ModuleDependencyID> result;
+  auto *sourceDep = dep->getAsSwiftSourceModule();
+  if (!sourceDep)
+    return result;
+
+  for (auto &dep : sourceDep->textualModuleDetails.bridgingModuleDependencies) {
+    ModuleDependencyID modID{dep, ModuleDependencyKind::Clang};
+    result.insert(modID);
+    auto succDeps = transitiveClosures.find(modID);
+    assert(succDeps != transitiveClosures.end() && "unknown dependency");
+    llvm::set_union(result, succDeps->second);
+  }
+
+  return result;
+}
+
 static std::vector<ModuleDependencyID>
 findClangDepPath(const ModuleDependencyID &from, const ModuleDependencyID &to,
                  ModuleDependenciesCache &cache) {
@@ -1763,8 +1783,14 @@ static void resolveDependencyCommandLineArguments(
     auto optionalDeps = cache.findDependency(modID);
     assert(optionalDeps.has_value());
     auto deps = optionalDeps.value();
-    if (auto E = resolveExplicitModuleInputs(modID, *deps, dependencyClosure,
-                                             cache, instance))
+    std::optional<std::set<ModuleDependencyID>> bridgingHeaderDeps;
+    if (modID.Kind == ModuleDependencyKind::SwiftSource)
+      bridgingHeaderDeps = computeBridgingHeaderTransitiveDependencies(
+          deps, moduleTransitiveClosures, cache);
+
+    if (auto E =
+            resolveExplicitModuleInputs(modID, *deps, dependencyClosure, cache,
+                                        instance, bridgingHeaderDeps))
       instance.getDiags().diagnose(SourceLoc(), diag::error_cas,
                                    toString(std::move(E)));
 

test/CAS/bridging-header.swift

@@ -0,0 +1,54 @@
+// RUN: %empty-directory(%t)
+// RUN: split-file %s %t
+
+// RUN: %target-swift-frontend -scan-dependencies -module-name Test -module-cache-path %t/clang-module-cache -O \
+// RUN:   -disable-implicit-string-processing-module-import -disable-implicit-concurrency-module-import \
+// RUN:   %t/test.swift -o %t/deps.json -swift-version 5 -cache-compile-job -cas-path %t/cas \
+// RUN:   -Xcc -fmodule-map-file=%t/a.modulemap -Xcc -fmodule-map-file=%t/b.modulemap -import-objc-header %t/Bridging.h
+
+// RUN: %{python} %S/Inputs/SwiftDepsExtractor.py %t/deps.json Test bridgingHeader | %FileCheck %s
+
+// CHECK:       "includeTree"
+// CHECK-NEXT:  "moduleDependencies": [
+// CHECK-NEXT:    "A"
+// CHECK-NEXT:  ],
+// CHECK-NEXT:  "commandLine": [
+// CHECK:         "-fmodule-file-cache-key",
+// CHECK-NEXT:    "-Xcc",
+// CHECK-NEXT:    "{{.*}}{{/|\\}}A-{{.*}}.pcm", 
+// CHECK-NEXT:    "-Xcc",
+// CHECK-NEXT:    "llvmcas://{{.*}}", 
+// CHECK-NEXT:    "-Xcc",
+// CHECK-NEXT:    "-fmodule-file-cache-key",
+// CHECK-NEXT:    "-Xcc",
+// CHECK-NEXT:    "{{.*}}{{/|\\}}B-{{.*}}.pcm", 
+// CHECK-NEXT:    "-Xcc",
+// CHECK-NEXT:    "llvmcas://{{.*}}"
+
+//--- test.swift
+import B
+public func test() {}
+
+//--- Bridging.h
+#include "Foo.h"
+
+//--- Foo.h
+#import "a.h"
+
+//--- a.h
+#include "b.h"
+
+//--- b.h
+void b(void);
+
+//--- a.modulemap
+module A {
+  header "a.h"
+  export *
+}
+
+//--- b.modulemap
+module B {
+  header "b.h"
+  export *
+}