Adding bridging header as module handling

Sources/SwiftDriver/Driver/Driver.swift

@@ -299,6 +299,9 @@ public struct Driver {
  /// The path to the pch for the imported Objective-C header.
  let bridgingPrecompiledHeader: VirtualPath.Handle?
 
+ /// The path to the module map for imported Objective-C header.
+ let bridgingModuleMap: VirtualPath.Handle?
+
  /// Path to the dependencies file.
  let dependenciesFilePath: VirtualPath.Handle?
 
@@ -758,6 +761,9 @@ public struct Driver {
  compilerMode: compilerMode,
  importedObjCHeader: importedObjCHeader,
  outputFileMap: outputFileMap)
+ self.bridgingModuleMap = try Self.generateModuleMapForObjCHeader(&parsedOptions,
+ fileSystem: fileSystem,
+ importedObjCHeader: importedObjCHeader)
 
  self.supportedFrontendFlags =
  try Self.computeSupportedCompilerArgs(of: self.toolchain,
@@ -2739,7 +2745,8 @@ extension Driver {
  outputFileMap: OutputFileMap?) throws -> VirtualPath.Handle? {
  guard compilerMode.supportsBridgingPCH,
  let input = importedObjCHeader,
- parsedOptions.hasFlag(positive: .enableBridgingPch, negative: .disableBridgingPch, default: true) else {
+ parsedOptions.hasFlag(positive: .enableBridgingPch, negative: .disableBridgingPch, default: true),
+ !parsedOptions.hasArgument(.experimentalBridgingHeaderAsModule) else {
  return nil
  }
 
@@ -2755,6 +2762,30 @@ extension Driver {
  return VirtualPath.createUniqueTemporaryFile(RelativePath(pchFileName)).intern()
  }
  }
+
+ /// Write the module map for bridging header.
+ static func generateModuleMapForObjCHeader(_ parsedOptions: inout ParsedOptions,
+ fileSystem: FileSystem,
+ importedObjCHeader: VirtualPath.Handle?) throws -> VirtualPath.Handle? {
+ guard let header = importedObjCHeader,
+ parsedOptions.hasArgument(.experimentalBridgingHeaderAsModule) else {
+ return nil
+ }
+ guard let moduleMapContent = """
+ module __ObjC {
+ umbrella header \"\(VirtualPath.lookup(header))\"
+ export *
+ }
+ """.data(using: .utf8) else { return nil }
+ // Write the modulemap inside -pch-output-dir if specified, otherwise in temporary directory.
+ if let outputDir = parsedOptions.getLastArgument(.pchOutputDir)?.asSingle {
+ let moduleMap = try VirtualPath(path: outputDir).appending(components: "module.modulemap")
+ try fileSystem.writeFileContents(moduleMap, bytes: ByteString(moduleMapContent), atomically: true)
+ return moduleMap.intern()
+ }
+ return VirtualPath.createUniqueTemporaryFileWithKnownContents(.init("module.modulemap"),
+ moduleMapContent).intern()
+ }
 }
 
 extension Diagnostic.Message {

Sources/SwiftDriver/ExplicitModuleBuilds/ModuleDependencyScanning.swift

@@ -106,8 +106,10 @@ public extension Driver {
  var commandLine: [Job.ArgTemplate] = swiftCompilerPrefixArgs.map { Job.ArgTemplate.flag($0) }
  commandLine.appendFlag("-frontend")
  commandLine.appendFlag("-scan-dependencies")
+
+ let bridgingHandling: BridgingHeaderHandling = parsedOptions.hasArgument(.experimentalBridgingHeaderAsModule) ? .module : .parsed
  try addCommonFrontendOptions(commandLine: &commandLine, inputs: &inputs, kind: .scanDependencies,
- bridgingHeaderHandling: .parsed,
+ bridgingHeaderHandling: bridgingHandling,
  moduleDependencyGraphUse: .dependencyScan)
  // FIXME: MSVC runtime flags
 

Sources/SwiftDriver/Jobs/CompileJob.swift

@@ -284,7 +284,8 @@ extension Driver {
  commandLine.appendFlag(.disableObjcAttrRequiresFoundationModule)
  }
 
- try addCommonFrontendOptions(commandLine: &commandLine, inputs: &inputs, kind: .compile)
+ let bridgingHandling: BridgingHeaderHandling = parsedOptions.hasArgument(.experimentalBridgingHeaderAsModule) ? .module : .precompiled
+ try addCommonFrontendOptions(commandLine: &commandLine, inputs: &inputs, kind: .compile, bridgingHeaderHandling: bridgingHandling)
 
  // FIXME: MSVC runtime flags
 

Sources/SwiftDriver/Jobs/FrontendJobHelpers.swift

@@ -41,6 +41,9 @@ extension Driver {
 
  /// Use the precompiled bridging header.
  case precompiled
+
+ /// Use module for bridging header.
+ case module
  }
  /// Whether the driver has already constructed a module dependency graph or is in the process
  /// of doing so
@@ -364,15 +367,17 @@ extension Driver {
  try commandLine.appendAll(.Xcc, from: &parsedOptions)
  }
 
- if let importedObjCHeader = importedObjCHeader,
- bridgingHeaderHandling != .ignored {
- commandLine.appendFlag(.importObjcHeader)
- if bridgingHeaderHandling == .precompiled,
- let pch = bridgingPrecompiledHeader {
+ if let importedObjCHeader = importedObjCHeader {
+ switch bridgingHeaderHandling {
+ case .ignored:
+ break
+ case .precompiled:
+ guard let pch = bridgingPrecompiledHeader else { break }
  // For explicit module build, we directly pass the compiled pch as
  // `-import-objc-header`, rather than rely on swift-frontend to locate
  // the pch in the pchOutputDir and can start an implicit build in case
  // of a lookup failure.
+ commandLine.appendFlag(.importObjcHeader)
  if parsedOptions.contains(.pchOutputDir) &&
  !parsedOptions.contains(.driverExplicitModuleBuild) {
  commandLine.appendPath(VirtualPath.lookup(importedObjCHeader))
@@ -383,8 +388,17 @@ extension Driver {
  } else {
  commandLine.appendPath(VirtualPath.lookup(pch))
  }
- } else {
+ case .parsed:
+ commandLine.appendFlag(.importObjcHeader)
  commandLine.appendPath(VirtualPath.lookup(importedObjCHeader))
+ case .module:
+ commandLine.appendFlag(.experimentalBridgingHeaderAsModule)
+ // Tell clang importer where to look for the module map during dependency scanning.
+ guard let moduleMapFile = bridgingModuleMap, kind == .scanDependencies else { break }
+ commandLine.appendFlag(.clangModuleMap)
+ commandLine.appendPath(VirtualPath.lookup(moduleMapFile))
+ inputs.append(TypedVirtualPath(file: moduleMapFile,
+ type: .clangModuleMap))
  }
  }
 

Sources/SwiftOptions/Options.swift

@@ -60,6 +60,7 @@ extension Option {
  public static let bsdk: Option = Option("-bsdk", .joinedOrSeparate, attributes: [.noDriver, .argumentIsPath], helpText: "path to the baseline SDK to import frameworks")
  public static let buildModuleFromParseableInterface: Option = Option("-build-module-from-parseable-interface", .flag, alias: Option.compileModuleFromInterface, attributes: [.helpHidden, .frontend, .noDriver], group: .modes)
  public static let bypassBatchModeChecks: Option = Option("-bypass-batch-mode-checks", .flag, attributes: [.helpHidden, .frontend, .noDriver], helpText: "Bypass checks for batch-mode errors.")
+ public static let bypassResilience: Option = Option("-bypass-resilience-checks", .flag, attributes: [.helpHidden, .frontend, .noDriver], helpText: "Ignore all checks for module resilience.")
  public static let cacheCompileJob: Option = Option("-cache-compile-job", .flag, attributes: [.frontend], helpText: "Enable compiler caching")
  public static let cacheDisableReplay: Option = Option("-cache-disable-replay", .flag, attributes: [.frontend], helpText: "Skip loading the compilation result from cache")
  public static let candidateModuleFile: Option = Option("-candidate-module-file", .separate, attributes: [.helpHidden, .frontend, .noDriver], metaVar: "<path>", helpText: "Specify Swift module may be ready to use for an interface")
@@ -74,6 +75,7 @@ extension Option {
  public static let clangHeaderExposeModule: Option = Option("-clang-header-expose-module", .separate, attributes: [.helpHidden, .frontend, .noDriver], metaVar: "<imported-module-name>=<generated-header-name>", helpText: "Allow the compiler to assume that APIs from the specified module are exposed to C/C++/Objective-C in another generated header, so that APIs in the current module that depend on declarations from the specified module can be exposed in the generated header.")
  public static let clangIncludeTreeRoot: Option = Option("-clang-include-tree-root", .separate, attributes: [.helpHidden, .frontend, .noDriver], metaVar: "<cas-id>", helpText: "Clang Include Tree CASID")
  public static let clangIncludeTree: Option = Option("-clang-include-tree", .flag, attributes: [.helpHidden, .frontend, .noDriver], helpText: "Use clang include tree")
+ public static let clangModuleMap: Option = Option("-clang-module-map", .separate, attributes: [.frontend, .argumentIsPath], metaVar: "<path>", helpText: "clang module map path")
  public static let clangTarget: Option = Option("-clang-target", .separate, attributes: [.frontend], helpText: "Separately set the target we should use for internal Clang instance")
  public static let codeCompleteCallPatternHeuristics: Option = Option("-code-complete-call-pattern-heuristics", .flag, attributes: [.helpHidden, .frontend, .noDriver], helpText: "Use heuristics to guess whether we want call pattern completions")
  public static let codeCompleteInitsInPostfixExpr: Option = Option("-code-complete-inits-in-postfix-expr", .flag, attributes: [.helpHidden, .frontend, .noDriver], helpText: "Include initializers when completing a postfix expression")
@@ -431,6 +433,7 @@ extension Option {
  public static let enforceExclusivityEQ: Option = Option("-enforce-exclusivity=", .joined, attributes: [.frontend, .moduleInterface], metaVar: "<enforcement>", helpText: "Enforce law of exclusivity")
  public static let entryPointFunctionName: Option = Option("-entry-point-function-name", .separate, attributes: [.helpHidden, .frontend, .noDriver], metaVar: "<string>", helpText: "Name of the entry point function")
  public static let experimentalAllowModuleWithCompilerErrors: Option = Option("-experimental-allow-module-with-compiler-errors", .flag, attributes: [.helpHidden, .frontend, .noDriver], helpText: "Attempt to output .swiftmodule, regardless of compilation errors")
+ public static let experimentalBridgingHeaderAsModule: Option = Option("-experimental-bridging-header-as-module", .flag, attributes: [.frontend], helpText: "Import bridging header as module")
  public static let experimentalCForeignReferenceTypes: Option = Option("-experimental-c-foreign-reference-types", .flag, attributes: [.helpHidden, .frontend, .moduleInterface], helpText: "Enable experimental C foreign references types (with reference coutning).")
  public static let experimentalCxxStdlib: Option = Option("-experimental-cxx-stdlib", .separate, attributes: [.helpHidden], helpText: "C++ standard library to use; forwarded to Clang's -stdlib flag")
  public static let emitModuleSeparately: Option = Option("-experimental-emit-module-separately", .flag, attributes: [.helpHidden], helpText: "Emit module files as a distinct job")
@@ -853,6 +856,7 @@ extension Option {
  Option.bsdk,
  Option.buildModuleFromParseableInterface,
  Option.bypassBatchModeChecks,
+ Option.bypassResilience,
  Option.cacheCompileJob,
  Option.cacheDisableReplay,
  Option.candidateModuleFile,
@@ -867,6 +871,7 @@ extension Option {
  Option.clangHeaderExposeModule,
  Option.clangIncludeTreeRoot,
  Option.clangIncludeTree,
+ Option.clangModuleMap,
  Option.clangTarget,
  Option.codeCompleteCallPatternHeuristics,
  Option.codeCompleteInitsInPostfixExpr,
@@ -1224,6 +1229,7 @@ extension Option {
  Option.enforceExclusivityEQ,
  Option.entryPointFunctionName,
  Option.experimentalAllowModuleWithCompilerErrors,
+ Option.experimentalBridgingHeaderAsModule,
  Option.experimentalCForeignReferenceTypes,
  Option.experimentalCxxStdlib,
  Option.emitModuleSeparately,

TestInputs/ExplicitModuleBuilds/CHeaders/BridgingModule.h

@@ -0,0 +1,6 @@
+#include "A.h"
+
+@interface A
+@end
+
+void bridgingA(A *a);