Pass IPI Clang module names to the Swift compiler

When a Swift target is compiled, swift-build now computes which Clang
modules in its transitive dependency closure should be treated as IPI
(project-internal) and passes their names via compiler flags.

The SKIP_INSTALL condition covers target-produced modules including
auto-generated modulemaps. The SRCROOT condition covers explicit
modulemaps committed to a project's source tree regardless of SKIP_INSTALL.

rdar://177010683

Author: sepy97

Sources/SWBCore/SpecImplementations/Tools/SwiftCompiler.swift

@@ -612,6 +612,7 @@ public struct DiscoveredSwiftCompilerToolSpecInfo: DiscoveredCommandLineToolSpec
         case emitLocalizedStrings = "emit-localized-strings"
         case libraryLevel = "library-level"
         case packageName = "package-name-if-supported"
+        case ipiClangModule = "ipi-clang-module"
         case vfsDirectoryRemap = "vfs-directory-remap"
         case indexUnitOutputPath = "index-unit-output-path"
         case indexUnitOutputPathWithoutWarning = "no-warn-superfluous-index-unit-path"
@@ -1606,6 +1607,22 @@ public final class SwiftCompilerSpec : CompilerSpec, SpecIdentifierType, SwiftDi
                 args += ["-library-level", libraryLevel]
             }
 
+            let ipiNames = cbc.producer.ipiClangModuleNames
+            if !ipiNames.isEmpty && cbc.scope.evaluate(BuiltinMacros.SWIFT_ENABLE_IPI_LIBRARY_LEVEL) {
+                if LibSwiftDriver.supportsDriverFlag(spelled: "-ipi-clang-module") {
+                    // Driver knows the option; let it forward to the frontend.
+                    for name in ipiNames {
+                        args += ["-ipi-clang-module", name]
+                    }
+                } else if toolSpecInfo.toolFeatures.has(.ipiClangModule) {
+                    // Older driver that doesn't recognise the option, but the
+                    // frontend supports it. Pass it through directly.
+                    for name in ipiNames {
+                        args += ["-Xfrontend", "-ipi-clang-module", "-Xfrontend", name]
+                    }
+                }
+            }
+
             if toolSpecInfo.toolFeatures.has(.packageName),
                let packageName = cbc.scope.evaluate(BuiltinMacros.SWIFT_PACKAGE_NAME).nilIfEmpty {
                 args += ["-package-name", packageName]

Sources/SWBCore/TaskGeneration.swift

@@ -210,6 +210,11 @@ public protocol CommandProducer: PlatformBuildContext, SpecLookupContext, Refere
     /// The module info for the target, if available.
     var moduleInfo: ModuleInfo? { get }
 
+    /// The names of Clang modules in this target's transitive dependency closure that should
+    /// be treated as IPI (project-internal), and thus passed to the Swift compiler via
+    /// `-ipi-clang-module`.
+    var ipiClangModuleNames: [String] { get }
+
     /// Whether or not the build is using a VFS.
     var needsVFS: Bool { get }
 
@@ -286,6 +291,11 @@ extension CommandProducer {
         sdkVariant?.llvmTargetTripleVendor == "apple"
     }
 
+    /// By default, no Clang modules are treated as IPI.
+    public var ipiClangModuleNames: [String] {
+        []
+    }
+
     package func discoveredCommandLineToolSpecInfo<T: DiscoveredCommandLineToolSpecInfo>(_ delegate: any CoreClientTargetDiagnosticProducingDelegate, _ toolName: String, _ path: Path, _ process: @Sendable (_ contents: Data) async throws -> any DiscoveredCommandLineToolSpecInfo) async throws -> T {
         let info = try await discoveredCommandLineToolSpecInfo(delegate, toolName, path, process)
         guard let info = info as? T else {

Sources/SWBTaskConstruction/ProductPlanning/ProductPlan.swift

@@ -97,6 +97,11 @@ package final class GlobalProductPlan: GlobalTargetInfoProvider
     /// Maps each target to its artifactbundles (direct and transitive).
     package private(set) var artifactBundlesByTarget: [ConfiguredTarget: [ArtifactBundleInfo]]
 
+    /// For each consumer target, the names of Clang modules in its transitive deps that should
+    /// be treated as IPI — a dep with `SKIP_INSTALL=YES` and a `MODULEMAP_FILE` resolving to a
+    /// path under any `SRCROOT` in the closure.
+    package private(set) var ipiClangModuleNamesByTarget: [ConfiguredTarget: [String]]
+
     /// All targets in the product plan.
     /// - remark: This property is preferred over the `TargetBuildGraph` in the `BuildPlanRequest` as it performs additional computations for Swift packages.
     package private(set) var allTargets: [ConfiguredTarget] = []
@@ -219,6 +224,7 @@ package final class GlobalProductPlan: GlobalTargetInfoProvider
         // Perform post-processing analysis of the build graph
         self.clientsOfBundlesByTarget = Self.computeBundleClients(buildGraph: planRequest.buildGraph, buildRequestContext: planRequest.buildRequestContext)
         self.artifactBundlesByTarget = await Self.computeArtifactBundleInfo(buildGraph: planRequest.buildGraph, provisioningInputs: planRequest.provisioningInputs, buildRequest: planRequest.buildRequest, buildRequestContext: planRequest.buildRequestContext, workspaceContext: planRequest.workspaceContext, getLinkageGraph: getLinkageGraph, metadataCache: self.artifactBundleMetadataCache, delegate: delegate)
+        self.ipiClangModuleNamesByTarget = Self.computeIPIClangInfo(buildGraph: planRequest.buildGraph, buildRequestContext: planRequest.buildRequestContext, workspaceContext: planRequest.workspaceContext)
         let directlyLinkedDependenciesByTarget: [ConfiguredTarget: OrderedSet<LinkedDependency>]
         (self.impartedBuildPropertiesByTarget, directlyLinkedDependenciesByTarget) = await Self.computeImpartedBuildProperties(planRequest: planRequest, getLinkageGraph: getLinkageGraph, delegate: delegate)
         self.mergeableTargetsToMergingTargets = Self.computeMergeableLibraries(buildGraph: planRequest.buildGraph, provisioningInputs: planRequest.provisioningInputs, buildRequestContext: planRequest.buildRequestContext)
@@ -586,6 +592,74 @@ package final class GlobalProductPlan: GlobalTargetInfoProvider
         return (impartedBuildPropertiesByTarget, directlyLinkedDependenciesByTarget)
     }
 
+    /// Compute, per consumer target, the Clang module names to treat as IPI.
+    /// A target-produced Clang module qualifies when the target has `SKIP_INSTALL=YES` and a
+    /// `MODULEMAP_FILE` whose resolved path lies under some `SRCROOT` in the consumer's
+    /// transitive dependency closure (including the consumer's own `SRCROOT`).
+    private static func computeIPIClangInfo(buildGraph: TargetBuildGraph, buildRequestContext: BuildRequestContext, workspaceContext: WorkspaceContext) -> [ConfiguredTarget: [String]] {
+        var namesByTarget: [ConfiguredTarget: [String]] = [:]
+        for configuredTarget in buildGraph.allTargets {
+            let deps = transitiveClosure([configuredTarget], successors: buildGraph.dependencies(of:)).0
+            let allTargets = [configuredTarget] + deps
+            // Collect the set of project-internal roots for this consumer.
+            var srcroots: Set<Path> = []
+            for target in allTargets {
+                let srcroot = buildRequestContext
+                    .getCachedSettings(target.parameters, target: target.target)
+                    .globalScope.evaluate(BuiltinMacros.SRCROOT)
+                if !srcroot.isEmpty {
+                    srcroots.insert(srcroot)
+                }
+            }
+            var names: Set<String> = []
+            for target in allTargets {
+                let settings = buildRequestContext.getCachedSettings(target.parameters, target: target.target)
+                let scope = settings.globalScope
+                // Must produce a Clang module.
+                let definesModule = scope.evaluate(BuiltinMacros.DEFINES_MODULE)
+                let modulemapFile = scope.evaluate(BuiltinMacros.MODULEMAP_FILE)
+                let modulemapContents = scope.evaluate(BuiltinMacros.MODULEMAP_FILE_CONTENTS)
+                guard definesModule || !modulemapFile.isEmpty || !modulemapContents.isEmpty else { continue }
+                // IPI if: SKIP_INSTALL=YES (target is never installed) OR the explicit MODULEMAP_FILE
+                // resolves to a path under a project-internal SRCROOT (module lives in the source tree).
+                let skipInstall = scope.evaluate(BuiltinMacros.SKIP_INSTALL)
+                let modulemapUnderSRCROOT: Bool = {
+                    guard !modulemapFile.isEmpty else { return false }
+                    let modulemapPath = Path(modulemapFile).isAbsolute
+                        ? Path(modulemapFile)
+                        : scope.evaluate(BuiltinMacros.SRCROOT).join(modulemapFile)
+                    // Resolve symlinks via the parent directory — the modulemap file itself may not
+                    // exist yet during planning, but its parent directory should.
+                    let resolvedModulemapDir = (try? localFS.realpath(modulemapPath.dirname)) ?? modulemapPath.dirname
+                    return srcroots.contains(where: {
+                        ((try? localFS.realpath($0)) ?? $0).isAncestorOrEqual(of: resolvedModulemapDir)
+                    })
+                }()
+                guard skipInstall || modulemapUnderSRCROOT else { continue }
+                // Prefer the centralized Clang module name(s) from `ModuleInfo`, which is the single
+                // source of truth and will inherit any future modulemap parsing.
+                let moduleInfo = computeModuleInfo(workspaceContext: workspaceContext, target: target.target, settings: settings, diagnosticHandler: { _, _, _, _ in })
+                let knownNames = moduleInfo?.knownClangModuleNames ?? []
+                if !knownNames.isEmpty {
+                    names.formUnion(knownNames)
+                } else {
+                    // Fall back to $(PRODUCT_MODULE_NAME) when the module name isn't known.
+                    // The case for hand-authored modulemaps, which `computeModuleInfo` doesn't yet parse.
+                    // NOTE: this can be wrong — a hand-authored MODULEMAP_FILE / MODULEMAP_FILE_CONTENTS
+                    // may declare a differently-named module (or several), so the emitted name might
+                    // not match the actual module.
+                    // Once `computeModuleInfo` parses modulemaps this fallback (and the inaccuracy) goes away.
+                    let name = scope.evaluate(BuiltinMacros.PRODUCT_MODULE_NAME)
+                    if !name.isEmpty {
+                        names.insert(name)
+                    }
+                }
+            }
+            namesByTarget[configuredTarget] = names.sorted()
+        }
+        return namesByTarget
+    }
+
     /// Determine which target produced each product in the build.
     private static func computeProducingTargetsForProducts(buildGraph: TargetBuildGraph, provisioningInputs: [ConfiguredTarget: ProvisioningTaskInputs], buildRequestContext: BuildRequestContext) -> [Path: ConfiguredTarget] {
         var productPathsToProducingTargets = [Path: ConfiguredTarget]()

Sources/SWBTaskConstruction/TaskProducers/TaskProducer.swift

@@ -1256,6 +1256,11 @@ extension TaskProducerContext: CommandProducer {
         return globalProductPlan.getModuleInfo(configuredTarget!)
     }
 
+    public var ipiClangModuleNames: [String] {
+        guard let configuredTarget else { return [] }
+        return globalProductPlan.ipiClangModuleNamesByTarget[configuredTarget] ?? []
+    }
+
     public var userPreferences: UserPreferences {
         workspaceContext.userPreferences
     }