Add a request to find a most appropriate configured target for indexing purposes

It's prompted by the fact that LSP has to operate on targets instead
of configured targets at the moment because there is (currently) no
way (or enough information) on LSP side to select a canonical target
for a given document.

This change creates an API endpoint for `selectConfiguredTargetForIndex`.
It makes it possible to select a single configured target given a target GUID and
a run destination (+ other parameters).

Author: xedin

Sources/SWBBuildService/BuildDescriptionMessages.swift

@@ -30,6 +30,7 @@ private protocol BuildDescriptionMessage: SessionMessage {
 }
 
 extension BuildDescriptionConfiguredTargetsRequest: BuildDescriptionMessage {}
+extension BuildDescriptionSelectConfiguredTargetsForIndexRequest: BuildDescriptionMessage {}
 extension BuildDescriptionConfiguredTargetSourcesRequest: BuildDescriptionMessage {}
 extension IndexBuildSettingsRequest: BuildDescriptionMessage {}
 
@@ -147,6 +148,50 @@ fileprivate extension SourceLanguage {
     }
 }
 
+struct BuildDescriptionSelectConfiguredTargetsForIndexMsg: MessageHandler {
+    private struct FailedToFindTargetForGUID: Error {
+        var guid: String
+    }
+
+    private struct FailedToSelectConfiguredTarget: Error {
+        var guid: String
+    }
+
+    func handle(request: Request, message: BuildDescriptionSelectConfiguredTargetsForIndexRequest) async throws -> BuildDescriptionSelectConfiguredTargetsForIndexResponse {
+        let buildDescription = try await request.buildDescription(for: message)
+
+        let session = try request.session(for: message)
+        guard let workspaceContext = session.workspaceContext else { throw MsgParserError.missingWorkspaceContext }
+        let buildRequest = try BuildRequest(from: message.request, workspace: workspaceContext.workspace)
+        let buildRequestContext = BuildRequestContext(workspaceContext: workspaceContext)
+
+        let uniqueTargets = OrderedSet(message.targets.map(\.rawValue))
+
+        let targets: Dictionary<String, ConfiguredTarget?> = Dictionary(buildDescription.allConfiguredTargets.lazy.filter { uniqueTargets.contains($0.target.guid) }.map {
+            ($0.target.guid, $0)
+        }, uniquingKeysWith: {
+            buildRequestContext.selectConfiguredTargetForIndex($0, $1, hasEnabledIndexBuildArena: buildRequest.enableIndexBuildArena, runDestination: message.request.parameters.activeRunDestination)
+        })
+
+        let configuredTargets = try uniqueTargets.map { target in
+            guard let configuredTarget = targets[target] else {
+                throw FailedToFindTargetForGUID(guid: target)
+            }
+
+            guard let configuredTarget else {
+                throw FailedToSelectConfiguredTarget(guid: target)
+            }
+
+            return ConfiguredTargetIdentifier(
+                rawGUID: configuredTarget.guid.stringValue,
+                targetGUID: TargetGUID(rawValue: configuredTarget.target.guid)
+            )
+        }
+
+        return BuildDescriptionSelectConfiguredTargetsForIndexResponse(configuredTargets: configuredTargets)
+    }
+}
+
 struct BuildDescriptionConfiguredTargetSourcesMsg: MessageHandler {
     private struct UnknownConfiguredTargetIDError: Error, CustomStringConvertible {
         let configuredTarget: ConfiguredTargetIdentifier

Sources/SWBBuildService/Messages.swift

@@ -1624,6 +1624,7 @@ package struct ServiceMessageHandlers: ServiceExtension {
         service.registerMessageHandler(DumpBuildDependencyInfoMsg.self)
 
         service.registerMessageHandler(BuildDescriptionConfiguredTargetsMsg.self)
+        service.registerMessageHandler(BuildDescriptionSelectConfiguredTargetsForIndexMsg.self)
         service.registerMessageHandler(BuildDescriptionConfiguredTargetSourcesMsg.self)
         service.registerMessageHandler(IndexBuildSettingsMsg.self)
         service.registerMessageHandler(ReleaseBuildDescriptionMsg.self)

Sources/SWBProtocol/BuildDescriptionMessages.swift

@@ -168,6 +168,41 @@ public struct BuildDescriptionConfiguredTargetSourcesResponse: Message, Serializ
     }
 }
 
+/// Select a configured target for each provided target GUID in the pre-generated build description to be used by the index.
+public struct BuildDescriptionSelectConfiguredTargetsForIndexRequest: SessionMessage, RequestMessage, SerializableCodable, Equatable {
+    public typealias ResponseMessage = BuildDescriptionSelectConfiguredTargetsForIndexResponse
+
+    public static let name = "BUILD_DESCRIPTION_SELECT_CONFIGURED_TARGETS_FOR_INDEX_REQUEST"
+
+    public let sessionHandle: String
+
+    /// The ID of the build description from which to load the configured targets
+    public let buildDescriptionID: BuildDescriptionID
+
+    /// The build request that was used to generate the build description with the given ID.
+    public let request: BuildRequestMessagePayload
+
+    /// The targets for which to select configured targets.
+    public let targets: [TargetGUID]
+
+    public init(sessionHandle: String, buildDescriptionID: BuildDescriptionID, request: BuildRequestMessagePayload, targets: [TargetGUID]) {
+        self.sessionHandle = sessionHandle
+        self.buildDescriptionID = buildDescriptionID
+        self.request = request
+        self.targets = targets
+    }
+}
+
+public struct BuildDescriptionSelectConfiguredTargetsForIndexResponse: Message, SerializableCodable, Equatable {
+    public static let name = "BUILD_DESCRIPTION_SELECT_CONFIGURED_TARGETS_FOR_INDEX_RESPONSE"
+
+    public let configuredTargets: [ConfiguredTargetIdentifier]
+
+    public init(configuredTargets: [ConfiguredTargetIdentifier]) {
+        self.configuredTargets = configuredTargets
+    }
+}
+
 /// Load the build settings that should be used to index a source file in a given configured target
 public struct IndexBuildSettingsRequest: SessionMessage, RequestMessage, SerializableCodable, Equatable {
     public typealias ResponseMessage = IndexBuildSettingsResponse
@@ -241,6 +276,8 @@ let buildDescriptionMessages: [any Message.Type] = [
     BuildDescriptionConfiguredTargetsResponse.self,
     BuildDescriptionConfiguredTargetSourcesRequest.self,
     BuildDescriptionConfiguredTargetSourcesResponse.self,
+    BuildDescriptionSelectConfiguredTargetsForIndexRequest.self,
+    BuildDescriptionSelectConfiguredTargetsForIndexResponse.self,
     IndexBuildSettingsRequest.self,
     IndexBuildSettingsResponse.self,
     ReleaseBuildDescriptionRequest.self,

Sources/SwiftBuild/SWBBuildServiceSession.swift

@@ -433,6 +433,24 @@ public final class SWBBuildServiceSession: Sendable {
         return buildSettings.compilerArguments
     }
 
+    public func selectConfiguredTargetsForIndex(targets: [SWBTargetGUID], buildDescription: SWBBuildDescriptionID, buildRequest: SWBBuildRequest) async throws -> [SWBConfiguredTargetIdentifier] {
+        let response = try await service.send(
+            request: BuildDescriptionSelectConfiguredTargetsForIndexRequest(
+                sessionHandle: uid,
+                buildDescriptionID: BuildDescriptionID(buildDescription),
+                request: buildRequest.messagePayloadRepresentation,
+                targets: targets.map { TargetGUID(rawValue: $0.rawValue) }
+            )
+         )
+
+        return response.configuredTargets.map {
+            SWBConfiguredTargetIdentifier(
+                rawGUID: $0.rawGUID,
+                targetGUID: .init($0.targetGUID)
+            )
+        }
+    }
+
     // MARK: Macro evaluation
 
 

Tests/SwiftBuildTests/InspectBuildDescriptionTests.swift

@@ -306,6 +306,89 @@ fileprivate struct InspectBuildDescriptionTests {
             }
         }
     }
+
+    @Test(.requireSDKs(.macOS))
+    func selectConfiguredTargets() async throws {
+        try await withTemporaryDirectory { (temporaryDirectory: NamedTemporaryDirectory) in
+            try await withAsyncDeferrable { deferrable in
+                let tmpDir = temporaryDirectory.path
+                let testSession = try await TestSWBSession(temporaryDirectory: temporaryDirectory)
+                await deferrable.addBlock {
+                    await #expect(throws: Never.self) {
+                        try await testSession.close()
+                    }
+                }
+
+                let macOSAppTarget = TestStandardTarget(
+                    "MyApp1",
+                    type: .application,
+                    buildConfigurations: [TestBuildConfiguration("Debug", buildSettings: ["SDKROOT": "macosx", "SUPPORTED_PLATFORMS": "macosx"])],
+                    buildPhases: [TestSourcesBuildPhase([TestBuildFile("MyApp1.swift")])]
+                )
+
+                let iOSAppTarget = TestStandardTarget(
+                    "MyApp2",
+                    type: .application,
+                    buildConfigurations: [TestBuildConfiguration("Debug", buildSettings: ["SDKROOT": "iphoneos", "SUPPORTED_PLATFORMS": "macosx iphoneos"])],
+                    buildPhases: [TestSourcesBuildPhase([TestBuildFile("MyApp2.swift")])],
+                    dependencies: [TestTargetDependency("MyFramework")]
+                )
+
+                let project = TestProject(
+                    "Test",
+                    groupTree: TestGroup("Test", children: [TestFile("MyFramework.swift"), TestFile("MyApp1.swift"), TestFile("MyApp2.swift")]),
+                    targets: [macOSAppTarget, iOSAppTarget]
+
+                )
+
+                let workspace = TestWorkspace("MyWorkspace", projects: [project])
+
+                try await testSession.sendPIF(TestWorkspace("Test", sourceRoot: tmpDir, projects: [project]))
+
+                let buildDescriptionID = try await createIndexBuildDescription(workspace, session: testSession)
+
+                func configuredTarget(for target: TestStandardTarget, using runDestination: SWBRunDestinationInfo? = nil) async throws -> SWBConfiguredTargetIdentifier {
+                    let result = try await configuredTargets(for: [target], using: runDestination)
+                    return try #require(result.only)
+                }
+
+                func configuredTargets(for targets: [TestStandardTarget], using runDestination: SWBRunDestinationInfo? = nil) async throws -> [SWBConfiguredTargetIdentifier] {
+                    var request = SWBBuildRequest()
+                    request.parameters.activeRunDestination = runDestination
+                    request.enableIndexBuildArena = true
+
+                    return try await testSession.session.selectConfiguredTargetsForIndex(targets: targets.map { SWBTargetGUID(rawValue: $0.guid) }, buildDescription: .init(buildDescriptionID), buildRequest: request)
+                }
+
+                let macOSAppForMacOSRef = try await configuredTarget(for: macOSAppTarget, using: .macOS)
+                #expect(macOSAppForMacOSRef.rawGUID.contains("macosx"))
+
+                let macOSAppForiOSRef = try await configuredTarget(for: macOSAppTarget, using: .iOS)
+                #expect(macOSAppForiOSRef.rawGUID.contains("macosx"))
+
+                let iOSAppRefNoDestination = try await configuredTarget(for: iOSAppTarget)
+                #expect(iOSAppRefNoDestination.rawGUID.contains("macosx"))
+
+                let iOSAppForMacOSRef = try await configuredTarget(for: iOSAppTarget, using: .macOS)
+                #expect(iOSAppForMacOSRef.rawGUID.contains("macosx"))
+
+                let iOSAppForiOSRef = try await configuredTarget(for: iOSAppTarget, using: .iOS)
+                #expect(iOSAppForiOSRef.rawGUID.contains("iphoneos"))
+
+                let iOSAppForUnsupportedRef = try await configuredTarget(for: iOSAppTarget, using: .watchOS)
+                #expect(iOSAppForUnsupportedRef.rawGUID.contains("macosx"))
+
+                let multiple = try await configuredTargets(for: [macOSAppTarget, iOSAppTarget], using: .macOS)
+                #expect(multiple.count == 2)
+                do {
+                    let macOSAppGUID = try #require(multiple.first?.targetGUID.rawValue)
+                    let iOSAppGUID = try #require(multiple.last?.targetGUID.rawValue)
+                    #expect(macOSAppGUID == macOSAppTarget.guid)
+                    #expect(iOSAppGUID == iOSAppTarget.guid)
+                }
+            }
+        }
+    }
 }
 
 fileprivate extension SWBBuildServiceSession {