[BridgingHeader] Support automatic bridging header chaining

cachemeifyoucan · cachemeifyoucan · commit 28c76e9b39c4 · 2025-01-28T16:37:48.000-08:00
Teach swift driver to handle bridging header chaining and pass the
correct arguments to swift-frontend.
diff --git a/Sources/CSwiftScan/include/swiftscan_header.h b/Sources/CSwiftScan/include/swiftscan_header.h
@@ -18,7 +18,7 @@
 #include <stdint.h>
 
 #define SWIFTSCAN_VERSION_MAJOR 1
-#define SWIFTSCAN_VERSION_MINOR 0
+#define SWIFTSCAN_VERSION_MINOR 1
 
 //=== Public Scanner Data Types -------------------------------------------===//
 
@@ -145,6 +145,12 @@ typedef struct {
   (*swiftscan_swift_textual_detail_get_swift_overlay_dependencies)(swiftscan_module_details_t);
   swiftscan_string_ref_t
   (*swiftscan_swift_textual_detail_get_module_cache_key)(swiftscan_module_details_t);
+  swiftscan_string_ref_t
+  (*swiftscan_swift_textual_detail_get_user_module_version)(swiftscan_module_details_t);
+  swiftscan_string_ref_t
+  (*swiftscan_swift_textual_detail_get_chained_bridging_header_path)(swiftscan_module_details_t);
+  swiftscan_string_ref_t
+  (*swiftscan_swift_textual_detail_get_chained_bridging_header_content)(swiftscan_module_details_t);
 
   //=== Swift Binary Module Details query APIs ------------------------------===//
   swiftscan_string_ref_t
diff --git a/Sources/SwiftDriver/Driver/Driver.swift b/Sources/SwiftDriver/Driver/Driver.swift
@@ -336,17 +336,30 @@ public struct Driver {
     }
   }
 
+  /// If PCH job is needed.
+  let producePCHJob: Bool
+
+  /// Original ObjC Header passed from command-line
+  let originalObjCHeaderFile: VirtualPath.Handle?
+
   /// The path to the imported Objective-C header.
-  let importedObjCHeader: VirtualPath.Handle?
+  lazy var importedObjCHeader: VirtualPath.Handle? = {
+    assert(explicitDependencyBuildPlanner != nil ||
+           !parsedOptions.hasArgument(.driverExplicitModuleBuild),
+           "should not be queried before scanning")
+    let chainedBridgingHeader = try? explicitDependencyBuildPlanner?.getChainedBridgingHeaderFile()
+    return try? computeImportedObjCHeader(&parsedOptions, compilerMode: compilerMode,
+                                          chainedBridgingHeader: chainedBridgingHeader)
+  }()
 
   /// The path to the pch for the imported Objective-C header.
   lazy var bridgingPrecompiledHeader: VirtualPath.Handle? = {
     let contextHash = try? explicitDependencyBuildPlanner?.getMainModuleContextHash()
-    return Self.computeBridgingPrecompiledHeader(&parsedOptions,
-                                                 compilerMode: compilerMode,
-                                                 importedObjCHeader: importedObjCHeader,
-                                                 outputFileMap: outputFileMap,
-                                                 contextHash: contextHash)
+    return computeBridgingPrecompiledHeader(&parsedOptions,
+                                            compilerMode: compilerMode,
+                                            importedObjCHeader: importedObjCHeader,
+                                            outputFileMap: outputFileMap,
+                                            contextHash: contextHash)
   }()
 
   /// Path to the dependencies file.
@@ -866,8 +879,6 @@ public struct Driver {
       parsedOptions: parsedOptions,
       recordedInputModificationDates: recordedInputModificationDates)
 
-    self.importedObjCHeader = try Self.computeImportedObjCHeader(&parsedOptions, compilerMode: compilerMode, diagnosticEngine: diagnosticEngine)
-
     self.supportedFrontendFlags =
       try Self.computeSupportedCompilerArgs(of: self.toolchain,
                                             libSwiftScan: self.swiftScanLibInstance,
@@ -892,16 +903,38 @@ public struct Driver {
         diagnosticsEngine.emit(.warning("-cache-compile-job cannot be used without explicit module build, turn off caching"),
                                location: nil)
         self.enableCaching = false
-      } else if importedObjCHeader != nil, !parsedOptions.hasFlag(positive: .enableBridgingPch, negative: .disableBridgingPch, default: true) {
-        diagnosticsEngine.emit(.warning("-cache-compile-job cannot be used with -disable-bridging-pch, turn off caching"),
-                               location: nil)
-        self.enableCaching = false
       } else {
         self.enableCaching = true
       }
     } else {
       self.enableCaching = false
     }
+
+    // PCH related options.
+    if parsedOptions.hasArgument(.importObjcHeader) {
+      // Check for conflicting options.
+      if parsedOptions.hasArgument(.importUnderlyingModule) {
+        diagnosticEngine.emit(.error_framework_bridging_header)
+      }
+
+      if parsedOptions.hasArgument(.emitModuleInterface, .emitModuleInterfacePath) {
+        diagnosticEngine.emit(.error_bridging_header_module_interface)
+      }
+    }
+    var maybeNeedPCH = parsedOptions.hasFlag(positive: .enableBridgingPch, negative: .disableBridgingPch, default: true)
+    if enableCaching && !maybeNeedPCH {
+      diagnosticsEngine.emit(.warning("-cache-compile-job cannot be used with -disable-bridging-pch, turn on PCH generation"),
+                             location: nil)
+      maybeNeedPCH = true
+    }
+    self.producePCHJob = maybeNeedPCH
+
+    if let objcHeaderPathArg = parsedOptions.getLastArgument(.importObjcHeader) {
+      self.originalObjCHeaderFile = try? VirtualPath.intern(path: objcHeaderPathArg.asSingle)
+    } else {
+      self.originalObjCHeaderFile = nil
+    }
+
     self.useClangIncludeTree = !parsedOptions.hasArgument(.noClangIncludeTree) && !env.keys.contains("SWIFT_CACHING_USE_CLANG_CAS_FS")
     self.scannerPrefixMap = try Self.computeScanningPrefixMapper(&parsedOptions)
     if let sdkMapping =  parsedOptions.getLastArgument(.scannerPrefixMapSdk)?.asSingle {
@@ -2898,36 +2931,31 @@ extension Driver {
 // Imported Objective-C header.
 extension Driver {
   /// Compute the path of the imported Objective-C header.
-  static func computeImportedObjCHeader(
+  func computeImportedObjCHeader(
     _ parsedOptions: inout ParsedOptions,
     compilerMode: CompilerMode,
-    diagnosticEngine: DiagnosticsEngine
+    chainedBridgingHeader: ChainedBridgingHeaderFile?,
   ) throws -> VirtualPath.Handle? {
-    guard let objcHeaderPathArg = parsedOptions.getLastArgument(.importObjcHeader) else {
-      return nil
-    }
-
-    // Check for conflicting options.
-    if parsedOptions.hasArgument(.importUnderlyingModule) {
-      diagnosticEngine.emit(.error_framework_bridging_header)
-    }
-
-    if parsedOptions.hasArgument(.emitModuleInterface, .emitModuleInterfacePath) {
-      diagnosticEngine.emit(.error_bridging_header_module_interface)
+    // handle chained bridging header.
+    if let chainedHeader = chainedBridgingHeader, !chainedHeader.path.isEmpty {
+      let path = try VirtualPath(path: chainedHeader.path)
+      if !enableCaching {
+        try fileSystem.writeFileContents(path,
+                                         bytes: ByteString(encodingAsUTF8: chainedHeader.content),
+                                         atomically: true)
+      }
+      return path.intern()
     }
-
-    return try VirtualPath.intern(path: objcHeaderPathArg.asSingle)
+    return originalObjCHeaderFile
   }
 
   /// Compute the path of the generated bridging PCH for the Objective-C header.
-  static func computeBridgingPrecompiledHeader(_ parsedOptions: inout ParsedOptions,
-                                               compilerMode: CompilerMode,
-                                               importedObjCHeader: VirtualPath.Handle?,
-                                               outputFileMap: OutputFileMap?,
-                                               contextHash: String?) -> VirtualPath.Handle? {
-    guard compilerMode.supportsBridgingPCH,
-      let input = importedObjCHeader,
-      parsedOptions.hasFlag(positive: .enableBridgingPch, negative: .disableBridgingPch, default: true) else {
+  func computeBridgingPrecompiledHeader(_ parsedOptions: inout ParsedOptions,
+                                        compilerMode: CompilerMode,
+                                        importedObjCHeader: VirtualPath.Handle?,
+                                        outputFileMap: OutputFileMap?,
+                                        contextHash: String?) -> VirtualPath.Handle? {
+    guard compilerMode.supportsBridgingPCH, producePCHJob, let input = importedObjCHeader else {
         return nil
     }
 
diff --git a/Sources/SwiftDriver/ExplicitModuleBuilds/ExplicitDependencyBuildPlanner.swift b/Sources/SwiftDriver/ExplicitModuleBuilds/ExplicitDependencyBuildPlanner.swift
@@ -27,6 +27,12 @@ public struct ExternalTargetModuleDetails {
   let isFramework: Bool
 }
 
+/// A chained bridging header file.
+public struct ChainedBridgingHeaderFile {
+  let path: String
+  let content: String
+}
+
 public typealias ExternalTargetModuleDetailsMap = [ModuleDependencyId: ExternalTargetModuleDetails]
 
 /// In Explicit Module Build mode, this planner is responsible for generating and providing
@@ -471,6 +477,17 @@ public typealias ExternalTargetModuleDetailsMap = [ModuleDependencyId: ExternalT
     return mainModuleDetails.contextHash
   }
 
+  /// Get the chained bridging header info
+  public func getChainedBridgingHeaderFile() throws -> ChainedBridgingHeaderFile? {
+    let mainModuleId: ModuleDependencyId = .swift(dependencyGraph.mainModuleName)
+    let mainModuleDetails = try dependencyGraph.swiftModuleDetails(of: mainModuleId)
+    guard let path = mainModuleDetails.chainedBridgingHeaderPath,
+          let content = mainModuleDetails.chainedBridgingHeaderContent else{
+      return nil
+    }
+    return ChainedBridgingHeaderFile(path: path, content: content)
+  }
+
   /// Resolve all module dependencies of the main module and add them to the lists of
   /// inputs and command line flags.
   public mutating func resolveBridgingHeaderDependencies(inputs: inout [TypedVirtualPath],
diff --git a/Sources/SwiftDriver/ExplicitModuleBuilds/InterModuleDependencies/InterModuleDependencyGraph.swift b/Sources/SwiftDriver/ExplicitModuleBuilds/InterModuleDependencies/InterModuleDependencyGraph.swift
@@ -124,7 +124,7 @@ public struct SwiftModuleDetails: Codable, Hashable {
   /// Options to the compile command
   public var commandLine: [String]? = []
 
-  /// Options to the compile command
+  /// Options to the compile bridging header command
   public var bridgingPchCommandLine: [String]? = []
 
   /// The context hash for this module that encodes the producing interface's path,
@@ -145,6 +145,11 @@ public struct SwiftModuleDetails: Codable, Hashable {
 
   /// The module cache key of the output module.
   public var moduleCacheKey: String?
+
+  /// Chained bridging header path
+  public var chainedBridgingHeaderPath: String?
+  /// Chained bridging header content
+  public var chainedBridgingHeaderContent: String?
 }
 
 /// Details specific to Swift placeholder dependencies.
diff --git a/Sources/SwiftDriver/ExplicitModuleBuilds/ModuleDependencyScanning.swift b/Sources/SwiftDriver/ExplicitModuleBuilds/ModuleDependencyScanning.swift
@@ -141,6 +141,25 @@ public extension Driver {
       }
     }
 
+    if isFrontendArgSupported(.experimentalBridgingHeaderChaining) {
+      try commandLine.appendLast(.experimentalBridgingHeaderChaining, from: &parsedOptions)
+    }
+
+    // Provide a directory to path to scanner for where the chained bridging header will be.
+    // Prefer writing next to pch output, otherwise next to module output path before fallback to temp directory for non-caching build.
+    if isFrontendArgSupported(.scannerOutputDir) {
+      if let outputDir = parsedOptions.getLastArgument(.pchOutputDir)?.asSingle {
+        commandLine.appendFlag(.scannerOutputDir)
+        commandLine.appendFlag(outputDir)
+      } else if let outputModule = moduleOutputInfo.output {
+        commandLine.appendFlag(.scannerOutputDir)
+        commandLine.appendFlag(VirtualPath.lookup(outputModule.outputPath).parentDirectory.name)
+      } else if !enableCaching, let tempDir = try? fileSystem.tempDirectory {
+        commandLine.appendFlag(.scannerOutputDir)
+        commandLine.appendFlag(tempDir.pathString)
+      }
+    }
+
     // Pass on the input files
     commandLine.append(contentsOf: inputFiles.filter { $0.type == .swift }.map { .path($0.file) })
     return (inputs, commandLine)
diff --git a/Sources/SwiftDriver/Jobs/FrontendJobHelpers.swift b/Sources/SwiftDriver/Jobs/FrontendJobHelpers.swift
@@ -451,9 +451,9 @@ extension Driver {
       try commandLine.appendAll(.Xcc, from: &parsedOptions)
     }
 
-    if let importedObjCHeader = importedObjCHeader,
+    let objcHeaderFile = (kind == .scanDependencies) ? originalObjCHeaderFile : importedObjCHeader
+    if let importedObjCHeader = objcHeaderFile,
         bridgingHeaderHandling != .ignored {
-      commandLine.appendFlag(.importObjcHeader)
       if bridgingHeaderHandling == .precompiled,
           let pch = bridgingPrecompiledHeader {
         // For explicit module build, we directly pass the compiled pch as
@@ -462,15 +462,27 @@ extension Driver {
         // of a lookup failure.
         if parsedOptions.contains(.pchOutputDir) &&
            !parsedOptions.contains(.driverExplicitModuleBuild) {
+          commandLine.appendFlag(.importObjcHeader)
           try addPathArgument(VirtualPath.lookup(importedObjCHeader), to:&commandLine, remap: jobNeedPathRemap)
           try commandLine.appendLast(.pchOutputDir, from: &parsedOptions)
           if !compilerMode.isSingleCompilation {
             commandLine.appendFlag(.pchDisableValidation)
           }
         } else {
-          try addPathArgument(VirtualPath.lookup(pch), to:&commandLine, remap: jobNeedPathRemap)
+          if isFrontendArgSupported(.importPch) {
+            commandLine.appendFlag(.importPch)
+            try addPathArgument(VirtualPath.lookup(pch), to:&commandLine, remap: jobNeedPathRemap)
+            if let originalHeader = originalObjCHeaderFile {
+              commandLine.appendFlag(.importObjcHeader)
+              try addPathArgument(VirtualPath.lookup(originalHeader), to:&commandLine, remap: jobNeedPathRemap)
+            }
+          } else {
+            commandLine.appendFlag(.importObjcHeader)
+            try addPathArgument(VirtualPath.lookup(pch), to:&commandLine, remap: jobNeedPathRemap)
+          }
         }
       } else {
+        commandLine.appendFlag(.importObjcHeader)
         try addPathArgument(VirtualPath.lookup(importedObjCHeader), to:&commandLine, remap: jobNeedPathRemap)
       }
     }
diff --git a/Sources/SwiftDriver/SwiftScan/DependencyGraphBuilder.swift b/Sources/SwiftDriver/SwiftScan/DependencyGraphBuilder.swift
@@ -188,6 +188,10 @@ private extension SwiftScan {
     let isFramework = api.swiftscan_swift_textual_detail_get_is_framework(moduleDetailsRef)
     let moduleCacheKey = supportsCaching ?  try getOptionalStringDetail(from: moduleDetailsRef,
                                                      using: api.swiftscan_swift_textual_detail_get_module_cache_key) : nil
+    let chainedBridgingHeaderPath = supportsChainedBridgingHeader ?
+      try getOptionalStringDetail(from: moduleDetailsRef, using: api.swiftscan_swift_textual_detail_get_chained_bridging_header_path) : nil
+    let chainedBridgingHeaderContent = supportsChainedBridgingHeader ?
+      try getOptionalStringDetail(from: moduleDetailsRef, using: api.swiftscan_swift_textual_detail_get_chained_bridging_header_content) : nil
 
     // Decode all dependencies of this module
     let swiftOverlayDependencies: [ModuleDependencyId]?
@@ -209,7 +213,9 @@ private extension SwiftScan {
                               extraPcmArgs: extraPcmArgs,
                               isFramework: isFramework,
                               swiftOverlayDependencies: swiftOverlayDependencies,
-                              moduleCacheKey: moduleCacheKey)
+                              moduleCacheKey: moduleCacheKey,
+                              chainedBridgingHeaderPath: chainedBridgingHeaderPath,
+                              chainedBridgingHeaderContent: chainedBridgingHeaderContent)
   }
 
   /// Construct a `SwiftPrebuiltExternalModuleDetails` from a `swiftscan_module_details_t` reference
diff --git a/Sources/SwiftDriver/SwiftScan/SwiftScan.swift b/Sources/SwiftDriver/SwiftScan/SwiftScan.swift
@@ -294,6 +294,10 @@ private extension String {
     return api.swiftscan_swift_textual_detail_get_bridging_pch_command_line != nil
   }
 
+  @_spi(Testing) public var supportsChainedBridgingHeader : Bool {
+    return api.swiftscan_swift_textual_detail_get_chained_bridging_header_path != nil &&
+           api.swiftscan_swift_textual_detail_get_chained_bridging_header_content != nil
+  }
 
   @_spi(Testing) public var canQueryPerScanDiagnostics : Bool {
     return api.swiftscan_dependency_graph_get_diagnostics != nil &&
@@ -507,6 +511,10 @@ private extension swiftscan_functions_t {
     // Bridging PCH build command-line
     self.swiftscan_swift_textual_detail_get_bridging_pch_command_line =
       loadOptional("swiftscan_swift_textual_detail_get_bridging_pch_command_line")
+    self.swiftscan_swift_textual_detail_get_chained_bridging_header_path =
+      loadOptional("swiftscan_swift_textual_detail_get_chained_bridging_header_path")
+    self.swiftscan_swift_textual_detail_get_chained_bridging_header_content =
+      loadOptional("swiftscan_swift_textual_detail_get_chained_bridging_header_content")
 
     // Caching related APIs.
     self.swiftscan_swift_textual_detail_get_module_cache_key =
diff --git a/Sources/SwiftOptions/Options.swift b/Sources/SwiftOptions/Options.swift
diff --git a/Tests/SwiftDriverTests/CachingBuildTests.swift b/Tests/SwiftDriverTests/CachingBuildTests.swift
diff --git a/Tests/SwiftDriverTests/ExplicitModuleBuildTests.swift b/Tests/SwiftDriverTests/ExplicitModuleBuildTests.swift
