Fix swift-api-digester search paths

Sources/Basics/Collections/IdentifiableSet.swift

@@ -97,6 +97,16 @@ public struct IdentifiableSet<Element: Identifiable>: Collection {
     public func contains(id: Element.ID) -> Bool {
         self.storage.keys.contains(id)
     }
+
+    public func filter(_ isIncluded: (Self.Element) throws -> Bool) rethrows -> Self {
+        var copy = Self()
+        for element in self {
+            if try isIncluded(element) {
+                copy.insert(element)
+            }
+        }
+        return copy
+    }
 }
 
 extension OrderedDictionary where Value: Identifiable, Key == Value.ID {
@@ -118,3 +128,9 @@ extension IdentifiableSet: Hashable {
         }
     }
 }
+
+extension IdentifiableSet: ExpressibleByArrayLiteral {
+    public init(arrayLiteral elements: Element...) {
+        self.init(elements)
+    }
+}

Sources/Build/BuildDescription/ClangTargetBuildDescription.swift

@@ -225,6 +225,18 @@ public final class ClangTargetBuildDescription {
         return args
     }
 
+    /// Determines the arguments needed to run `swift-api-digester` for emitting
+    /// an API baseline for this module.
+    package func apiDigesterEmitBaselineArguments() throws -> [String] {
+        throw InternalError("Unimplemented \(#function)")
+    }
+
+    /// Determines the arguments needed to run `swift-api-digester` for
+    /// comparing to an API baseline for this module.
+    package func apiDigesterCompareBaselineArguments() throws -> [String] {
+        throw InternalError("Unimplemented \(#function)")
+    }
+
     /// Builds up basic compilation arguments for a source file in this target; these arguments may be different for C++
     /// vs non-C++.
     /// NOTE: The parameter to specify whether to get C++ semantics is currently optional, but this is only for revlock

Sources/Build/BuildDescription/SwiftTargetBuildDescription.swift

@@ -641,6 +641,44 @@ public final class SwiftTargetBuildDescription {
         return args
     }
 
+    /// Determines the arguments needed to run `swift-api-digester` for emitting
+    /// an API baseline for this module.
+    package func apiDigesterEmitBaselineArguments() throws -> [String] {
+        var args = [String]()
+        args += try self.apiDigesterCommonArguments()
+        return args
+    }
+
+    /// Determines the arguments needed to run `swift-api-digester` for
+    /// comparing to an API baseline for this module.
+    package func apiDigesterCompareBaselineArguments() throws -> [String] {
+        var args = [String]()
+        args += try self.apiDigesterCommonArguments()
+        return args
+    }
+
+    public func apiDigesterCommonArguments() throws -> [String] {
+        var args = [String]()
+        args += self.buildParameters.toolchain.extraFlags.swiftCompilerFlags
+
+        // FIXME: remove additionalFlags
+        // Add search paths determined during planning
+        args += self.additionalFlags
+        args += ["-I", self.modulesPath.pathString]
+
+        // FIXME: Only include valid args
+        // `swift-api-digester` args doesn't support -L args.
+        for index in args.indices.dropLast().reversed() {
+            if args[index] == "-L" {
+                // Remove the flag
+                args.remove(at: index)
+                // Remove the argument
+                args.remove(at: index)
+            }
+        }
+        return args
+    }
+
     // FIXME: this function should operation on a strongly typed buildSetting
     // Move logic from PackageBuilder here.
     /// Determines the arguments needed for cxx interop for this module.

Sources/Build/BuildDescription/TargetBuildDescription.swift

@@ -124,4 +124,22 @@ public enum TargetBuildDescription {
         case .clang(let target): try target.symbolGraphExtractArguments()
         }
     }
+
+    /// Determines the arguments needed to run `swift-api-digester` for emitting
+    /// an API baseline for this module.
+    package func apiDigesterEmitBaselineArguments() throws -> [String] {
+        switch self {
+        case .swift(let target): try target.apiDigesterEmitBaselineArguments()
+        case .clang(let target): try target.apiDigesterEmitBaselineArguments()
+        }
+    }
+
+    /// Determines the arguments needed to run `swift-api-digester` for
+    /// comparing to an API baseline for this module.
+    package func apiDigesterCompareBaselineArguments() throws -> [String] {
+        switch self {
+        case .swift(let target): try target.apiDigesterCompareBaselineArguments()
+        case .clang(let target): try target.apiDigesterCompareBaselineArguments()
+        }
+    }
 }

Sources/Build/BuildPlan/BuildPlan.swift

@@ -523,53 +523,6 @@ public class BuildPlan: SPMBuildCore.BuildPlan {
         // handle that situation.
     }
 
-    public func createAPIToolCommonArgs(includeLibrarySearchPaths: Bool) throws -> [String] {
-        // API tool runs on products, hence using `self.productsBuildParameters`, not `self.toolsBuildParameters`
-        let buildPath = self.destinationBuildParameters.buildPath.pathString
-        var arguments = ["-I", buildPath]
-
-        // swift-symbolgraph-extract does not support parsing `-use-ld=lld` and
-        // will silently error failing the operation.  Filter out this flag
-        // similar to how we filter out the library search path unless
-        // explicitly requested.
-        var extraSwiftCFlags = self.destinationBuildParameters.toolchain.extraFlags.swiftCompilerFlags
-            .filter { !$0.starts(with: "-use-ld=") }
-        if !includeLibrarySearchPaths {
-            for index in extraSwiftCFlags.indices.dropLast().reversed() {
-                if extraSwiftCFlags[index] == "-L" {
-                    // Remove the flag
-                    extraSwiftCFlags.remove(at: index)
-                    // Remove the argument
-                    extraSwiftCFlags.remove(at: index)
-                }
-            }
-        }
-        arguments += extraSwiftCFlags
-
-        // Add search paths to the directories containing module maps and Swift modules.
-        for target in self.targets {
-            switch target {
-            case .swift(let targetDescription):
-                arguments += ["-I", targetDescription.moduleOutputPath.parentDirectory.pathString]
-            case .clang(let targetDescription):
-                if let includeDir = targetDescription.moduleMap?.parentDirectory {
-                    arguments += ["-I", includeDir.pathString]
-                }
-            }
-        }
-
-        // Add search paths from the system library targets.
-        for target in self.graph.reachableTargets {
-            if let systemLib = target.underlying as? SystemLibraryTarget {
-                try arguments.append(contentsOf: self.pkgConfig(for: systemLib).cFlags)
-                // Add the path to the module map.
-                arguments += ["-I", systemLib.moduleMapPath.parentDirectory.pathString]
-            }
-        }
-
-        return arguments
-    }
-
     /// Creates arguments required to launch the Swift REPL that will allow
     /// importing the modules in the package graph.
     public func createREPLArguments() throws -> [String] {
@@ -656,6 +609,24 @@ public class BuildPlan: SPMBuildCore.BuildPlan {
         }
         return try description.symbolGraphExtractArguments()
     }
+
+    /// Determines the arguments needed to run `swift-api-digester` for emitting
+    /// an API baseline for a particular module.
+    public func apiDigesterEmitBaselineArguments(for module: ResolvedModule) throws -> [String] {
+        guard let description = self.targetMap[module.id] else {
+            throw InternalError("Expected description for module \(module)")
+        }
+        return try description.apiDigesterEmitBaselineArguments()
+    }
+
+    /// Determines the arguments needed to run `swift-api-digester` for
+    /// comparing to an API baseline for a particular module.
+    public func apiDigesterCompareBaselineArguments(for module: ResolvedModule) throws -> [String] {
+        guard let description = self.targetMap[module.id] else {
+            throw InternalError("Expected description for module \(module)")
+        }
+        return try description.apiDigesterCompareBaselineArguments()
+    }
 }
 
 extension Basics.Diagnostic {

Sources/Commands/PackageCommands/APIDiff.swift

@@ -19,9 +19,10 @@ import PackageModel
 import SourceControl
 
 struct DeprecatedAPIDiff: ParsableCommand {
-    static let configuration = CommandConfiguration(commandName: "experimental-api-diff",
-                                                    abstract: "Deprecated - use `swift package diagnose-api-breaking-changes` instead",
-                                                    shouldDisplay: false)
+    static let configuration = CommandConfiguration(
+        commandName: "experimental-api-diff",
+        abstract: "Deprecated - use `swift package diagnose-api-breaking-changes` instead",
+        shouldDisplay: false)
 
     @Argument(parsing: .captureForPassthrough)
     var args: [String] = []
@@ -109,18 +110,18 @@ struct APIDiff: SwiftCommand {
             at: overrideBaselineDir,
             force: regenerateBaseline,
             logLevel: swiftCommandState.logLevel,
-                    swiftCommandState: swiftCommandState
+            swiftCommandState: swiftCommandState
         )
 
         let results = ThreadSafeArrayStore<SwiftAPIDigester.ComparisonResult>()
         let group = DispatchGroup()
         let semaphore = DispatchSemaphore(value: Int(try buildSystem.buildPlan.destinationBuildParameters.workers))
-        var skippedModules: Set<String> = []
+        var skippedModules = IdentifiableSet<ResolvedModule>()
 
         for module in modulesToDiff {
-            let moduleBaselinePath = baselineDir.appending("\(module).json")
+            let moduleBaselinePath = baselineDir.appending("\(module.c99name).json")
             guard swiftCommandState.fileSystem.exists(moduleBaselinePath) else {
-                print("\nSkipping \(module) because it does not exist in the baseline")
+                print("\nSkipping \(module.c99name) because it does not exist in the baseline")
                 skippedModules.insert(module)
                 continue
             }
@@ -146,7 +147,7 @@ struct APIDiff: SwiftCommand {
 
         let failedModules = modulesToDiff
             .subtracting(skippedModules)
-            .subtracting(results.map(\.moduleName))
+            .subtracting(results.map(\.module))
         for failedModule in failedModules {
             swiftCommandState.observabilityScope.emit(error: "failed to read API digester output for \(failedModule)")
         }
@@ -160,8 +161,8 @@ struct APIDiff: SwiftCommand {
         }
     }
 
-    private func determineModulesToDiff(packageGraph: ModulesGraph, observabilityScope: ObservabilityScope) throws -> Set<String> {
-        var modulesToDiff: Set<String> = []
+    private func determineModulesToDiff(packageGraph: ModulesGraph, observabilityScope: ObservabilityScope) throws -> IdentifiableSet<ResolvedModule> {
+        var modulesToDiff = IdentifiableSet<ResolvedModule>()
         if products.isEmpty && targets.isEmpty {
             modulesToDiff.formUnion(packageGraph.apiDigesterModules)
         } else {
@@ -177,7 +178,10 @@ struct APIDiff: SwiftCommand {
                     observabilityScope.emit(error: "'\(productName)' is not a library product")
                     continue
                 }
-                modulesToDiff.formUnion(product.targets.filter { $0.underlying is SwiftTarget }.map(\.c99name))
+                let swiftModules = product
+                    .targets
+                    .filter { $0.underlying is SwiftTarget }
+                modulesToDiff.formUnion(swiftModules)
             }
             for targetName in targets {
                 guard let target = packageGraph
@@ -195,7 +199,7 @@ struct APIDiff: SwiftCommand {
                     observabilityScope.emit(error: "'\(targetName)' is not a Swift language target")
                     continue
                 }
-                modulesToDiff.insert(target.c99name)
+                modulesToDiff.insert(target)
             }
             guard !observabilityScope.errorsReported else {
                 throw ExitCode.failure
@@ -232,7 +236,7 @@ struct APIDiff: SwiftCommand {
             }
         }
 
-        let moduleName = comparisonResult.moduleName
+        let moduleName = comparisonResult.module.c99name
         if comparisonResult.apiBreakingChanges.isEmpty {
             print("\nNo breaking changes detected in \(moduleName)")
         } else {