Remove client-side API for macro evaluation scopes.

This primarily involves removing the messages to create and discard the scope, and client-side methods for doing so. Clients no longer hold on to a scope directly but rather request the service perform evaluations using a set of build parameters, which eliminates the need to do bookkeeping for these objects.

(There is still service-side caching of registered Settings objects in the Session, as it it used in PlanningOperation.)

rdar://142511013

Author: mhrawdon

Sources/SWBBuildService/Messages.swift

@@ -1326,42 +1326,6 @@ private func getSettings(for session: Session, workspaceContext: WorkspaceContex
     }
 }
 
-/// Handle a `CreateMacroEvaluationScopeRequest` message.
-private struct CreateMacroEvaluationScopeMsg: MessageHandler {
-    func handle(request: Request, message: CreateMacroEvaluationScopeRequest) throws -> StringResponse {
-        // Look up the session, and create the build parameters.
-        let session = try request.session(for: message)
-        guard let workspaceContext = session.workspaceContext else {
-            throw MsgParserError.missingWorkspaceContext
-        }
-        let buildParameters = try BuildParameters(from: message.buildParameters)
-
-        // Create a settings object for the requested level and register it with the session.
-        let settings = try getSettings(for: session, workspaceContext: workspaceContext, level: message.level, buildParameters: buildParameters, purpose: .build)
-        let handle = session.registerSettings(settings)
-
-        // Return the handle to the client.
-        return StringResponse(handle)
-    }
-}
-
-private struct DiscardMacroEvaluationScopeMsg: MessageHandler {
-    func handle(request: Request, message: DiscardMacroEvaluationScope) throws -> VoidResponse {
-        // Look up the session.
-        let session = try request.session(for: message)
-
-        // Discard the settings.
-        do {
-            try session.unregisterSettings(for: message.settingsHandle)
-        }
-        catch {
-            throw MsgParserError.missingSettings
-        }
-
-        return VoidResponse()
-    }
-}
-
 private struct MacroEvaluationMsg: MessageHandler {
     func handle(request: Request, message: MacroEvaluationRequest) async throws -> MacroEvaluationResponse {
         // We get the Settings to use for evaluation from the session.
@@ -1641,8 +1605,6 @@ package struct ServiceMessageHandlers: ServiceExtension {
         service.registerMessageHandler(ComputeDependencyGraphMsg.self)
         service.registerMessageHandler(DumpBuildDependencyInfoMsg.self)
 
-        service.registerMessageHandler(CreateMacroEvaluationScopeMsg.self)
-        service.registerMessageHandler(DiscardMacroEvaluationScopeMsg.self)
         service.registerMessageHandler(MacroEvaluationMsg.self)
         service.registerMessageHandler(AllExportedMacrosAndValuesMsg.self)
         service.registerMessageHandler(BuildSettingsEditorInfoMsg.self)

Sources/SWBBuildService/Session.swift

@@ -204,10 +204,12 @@ package final class Session {
         return startPIFTransfer(workspaceSignature: workspaceSignature)
     }
 
-    // MARK: Support for the client to request build setting evaluation
+
+    // MARK: Support for saving macro evaluation scopes to look up by a handle (UUID).
 
 
     /// The active Settings objects being vended for use by the client.
+    /// - remark: This is presently only used in `PlanningOperation` to be able to evaluate some settings after receiving provisioning inputs from the client, without having to reconstruct the `ConfiguredTarget` in that asyncronous operation.
     var registeredSettings = Registry<String, Settings>()
 
     /// Register a `Settings` object with the session.  This returns a handle (a `UUID` string) to the caller which it can pass to the client and which can then be used to evaluate settings using this `Settings` object.  The caller is responsible for removing this `Settings` object from the session when it is no longer needed.

Sources/SWBProtocol/MacroEvaluationMessages.swift

@@ -61,7 +61,8 @@ public struct DiscardMacroEvaluationScope: SessionMessage, RequestMessage, Equat
 
 /// The context within which a macro evaluation should occur.
 public enum MacroEvaluationRequestContext: Equatable, Sendable, SerializableCodable {
-    /// A `Settings` handle, if called from a scope.
+    /// A `Settings` handle, if called by something which is holding on to a handle.
+    /// - remark: This was previously used when the client held a handle to a macro evaluation scope to use for evaluation. Presently it is unused, but could be revived if the handle-to-a-scope model is useful in the future.
     case settingsHandle(String)
     /// A level and build parameters, if called on the fly.
     case components(level: MacroEvaluationRequestLevel, buildParameters: BuildParametersMessagePayload)

Sources/SwiftBuild/CMakeLists.txt

@@ -45,7 +45,6 @@ add_library(SwiftBuild
   SWBIndexingSupport.swift
   SWBLocalizationSupport.swift
   SWBMacroEvaluation.swift
-  SWBMacroEvaluationScope.swift
   SWBPreviewSupport.swift
   SWBProductPlannerSupport.swift
   SWBPropertyList.swift

Sources/SwiftBuild/CompatibilityShims.swift

@@ -15,8 +15,6 @@ public typealias XCBBuildService = SWBBuildService
 public typealias XCBBuildServiceConsole = SWBBuildServiceConsole
 public typealias XCBServiceConsoleCommandRegistry = SWBServiceConsoleCommandRegistry
 public typealias XCBBuildServiceSession = SWBBuildServiceSession
-@available(*, deprecated, message: "SWBMacroEvaluationScope is deprecated and should not be used")
-public typealias XCBMacroEvaluationScope = SWBMacroEvaluationScope
 public typealias XCBuildFileType = SwiftBuildFileType
 public typealias XCBBuildOperationTaskMetrics = SWBBuildOperationTaskMetrics
 public typealias XCBBuildOperationBacktraceFrame = SWBBuildOperationBacktraceFrame

Sources/SwiftBuild/SWBBuildServiceSession.swift

@@ -32,10 +32,6 @@ public enum SwiftBuildServicePIFObjectType: Sendable {
     }
 }
 
-private protocol InvalidateDeprecated {
-    func invalidateDeprecated(isolated: (any Actor)?) async throws
-}
-
 /// This class encapsulates a unique session connection to the inferior build service process.
 ///
 /// The state for each individual session is separated, and generally a unique session is used for each separate workspace, project, etc. that a client may want to build
@@ -57,9 +53,7 @@ public final class SWBBuildServiceSession: Sendable {
     /// For macro evaluation scopes, the session will register each newly created scope with the tracker. If the client manually discards the scope, it will be removed from the tracker by the session. If the client does not manually discard their scopes, they will be cleaned up by the tracker when the session is closed.
     ///
     /// For build operations, the tracker implements a generic background operation queue. Closures are enqueued to a stream, and consumed and awaited on a background task. Closing the session awaits that background taskto ensure all closures are awaited before continuing with teardown.
-    private actor SessionResourceTracker: InvalidateDeprecated {
-        @available(*, deprecated, message: "SWBMacroEvaluationScope is deprecated and should not be used")
-        private var macroEvaluationScopes: [String: SWBMacroEvaluationScope] = [:]
+    private actor SessionResourceTracker {
         private var awaitableBuildOperations: AsyncStreamController<SWBBuildOperation, Never>
         private let cancellableBuildOperationsHolder = CancellableBuildOperationsHolder()
 
@@ -94,16 +88,6 @@ public final class SWBBuildServiceSession: Sendable {
             }
         }
 
-        @available(*, deprecated, message: "SWBMacroEvaluationScope is deprecated and should not be used")
-        func append(_ scope: SWBMacroEvaluationScope) {
-            macroEvaluationScopes[scope.settingsHandle] = scope
-        }
-
-        @available(*, deprecated, message: "SWBMacroEvaluationScope is deprecated and should not be used")
-        func remove(_ scope: SWBMacroEvaluationScope) {
-            macroEvaluationScopes.removeValue(forKey: scope.settingsHandle)
-        }
-
         func enqueue(_ operation: SWBBuildOperation) async {
             let queuedResult = awaitableBuildOperations.yield(operation)
             switch queuedResult {
@@ -128,22 +112,6 @@ public final class SWBBuildServiceSession: Sendable {
             awaitableBuildOperations.finish()
             await cancellableBuildOperationsHolder.cancelAll()
             await awaitableBuildOperations.wait()
-
-            try await (self as (any InvalidateDeprecated)).invalidateDeprecated(isolated: #isolation)
-        }
-
-        @available(*, deprecated, message: "SWBMacroEvaluationScope is deprecated and should not be used")
-        func invalidateDeprecated(isolated: (any Actor)?) async throws {
-            let scopes = macroEvaluationScopes.values
-            macroEvaluationScopes = [:]
-            try await withThrowingTaskGroup(of: Void.self) { group in
-                for scope in scopes {
-                    group.addTask {
-                        try await scope.invalidate()
-                    }
-                }
-                try await group.waitForAll()
-            }
         }
     }
 
@@ -441,70 +409,42 @@ public final class SWBBuildServiceSession: Sendable {
     }
 
 
-    // Helper methods to package up a request and send it to the service.
-    // These methods are used both by the public methods below, and by those in SWBMacroEvaluationScope.
-
-    func evaluateMacroAsString(_ macro: String, context: MacroEvaluationRequestContext, overrides: [String : String]?) async throws -> String {
-        let request = MacroEvaluationRequest(sessionHandle: uid, context: context, request: .macro(macro), overrides: overrides, resultType: .string)
-        return try await sendMacroEvaluationStringRequest(self, request)
-    }
-
-    func evaluateMacroAsStringList(_ macro: String, context: MacroEvaluationRequestContext, overrides: [String : String]?) async throws -> [String] {
-        let request = MacroEvaluationRequest(sessionHandle: uid, context: context, request: .macro(macro), overrides: overrides, resultType: .stringList)
-        return try await sendMacroEvaluationStringListRequest(self, request)
-    }
-
-    func evaluateMacroAsBoolean(_ macro: String, context: MacroEvaluationRequestContext, overrides: [String : String]?) async throws -> Bool {
-        let request = MacroEvaluationRequest(sessionHandle: uid, context: context, request: .macro(macro), overrides: overrides, resultType: .string)
-        return try await sendMacroEvaluationStringRequest(self, request) == "YES"
-    }
-
-    func evaluateMacroExpressionAsString(_ expr: String, context: MacroEvaluationRequestContext, overrides: [String : String]?) async throws -> String {
-        let request = MacroEvaluationRequest(sessionHandle: uid, context: context, request: .stringExpression(expr), overrides: overrides, resultType: .string)
-        return try await sendMacroEvaluationStringRequest(self, request)
-    }
-
-    func evaluateMacroExpressionAsStringList(_ expr: String, context: MacroEvaluationRequestContext, overrides: [String : String]?) async throws -> [String] {
-        let request = MacroEvaluationRequest(sessionHandle: uid, context: context, request: .stringExpression(expr), overrides: overrides, resultType: .stringList)
-        return try await sendMacroEvaluationStringListRequest(self, request)
-    }
-
-    func evaluateMacroExpressionArrayAsStringList(_ expr: [String], context: MacroEvaluationRequestContext, overrides: [String : String]?) async throws -> [String] {
-        let request = MacroEvaluationRequest(sessionHandle: uid, context: context, request: .stringExpressionArray(expr), overrides: overrides, resultType: .stringList)
-        return try await sendMacroEvaluationStringListRequest(self, request)
-    }
-
-
     // Public methods to perform macro evaluations for a level and build parameters.
 
     public func evaluateMacroAsString(_ macro: String, level: SWBMacroEvaluationLevel, buildParameters: SWBBuildParameters, overrides: [String : String]?) async throws -> String {
         let parameters = buildParameters.messagePayloadRepresentation
-        return try await evaluateMacroAsString(macro, context: .components(level: level.toSWBRequest, buildParameters: parameters), overrides: overrides)
+        let request = MacroEvaluationRequest(sessionHandle: uid, context: .components(level: level.toSWBRequest, buildParameters: parameters), request: .macro(macro), overrides: overrides, resultType: .string)
+        return try await sendMacroEvaluationStringRequest(self, request)
     }
 
     public func evaluateMacroAsStringList(_ macro: String, level: SWBMacroEvaluationLevel, buildParameters: SWBBuildParameters, overrides: [String : String]?) async throws -> [String] {
         let parameters = buildParameters.messagePayloadRepresentation
-        return try await evaluateMacroAsStringList(macro, context: .components(level: level.toSWBRequest, buildParameters: parameters), overrides: overrides)
+        let request = MacroEvaluationRequest(sessionHandle: uid, context: .components(level: level.toSWBRequest, buildParameters: parameters), request: .macro(macro), overrides: overrides, resultType: .stringList)
+        return try await sendMacroEvaluationStringListRequest(self, request)
     }
 
     public func evaluateMacroAsBoolean(_ macro: String, level: SWBMacroEvaluationLevel, buildParameters: SWBBuildParameters, overrides: [String : String]?) async throws -> Bool {
         let parameters = buildParameters.messagePayloadRepresentation
-        return try await evaluateMacroAsBoolean(macro, context: .components(level: level.toSWBRequest, buildParameters: parameters), overrides: overrides)
+        let request = MacroEvaluationRequest(sessionHandle: uid, context: .components(level: level.toSWBRequest, buildParameters: parameters), request: .macro(macro), overrides: overrides, resultType: .string)
+        return try await sendMacroEvaluationStringRequest(self, request) == "YES"
     }
 
     public func evaluateMacroExpressionAsString(_ expr: String, level: SWBMacroEvaluationLevel, buildParameters: SWBBuildParameters, overrides: [String : String]?) async throws -> String {
         let parameters = buildParameters.messagePayloadRepresentation
-        return try await evaluateMacroExpressionAsString(expr, context: .components(level: level.toSWBRequest, buildParameters: parameters), overrides: overrides)
+        let request = MacroEvaluationRequest(sessionHandle: uid, context: .components(level: level.toSWBRequest, buildParameters: parameters), request: .stringExpression(expr), overrides: overrides, resultType: .string)
+        return try await sendMacroEvaluationStringRequest(self, request)
     }
 
     public func evaluateMacroExpressionAsStringList(_ expr: String, level: SWBMacroEvaluationLevel, buildParameters: SWBBuildParameters, overrides: [String : String]?) async throws -> [String] {
         let parameters = buildParameters.messagePayloadRepresentation
-        return try await evaluateMacroExpressionAsStringList(expr, context: .components(level: level.toSWBRequest, buildParameters: parameters), overrides: overrides)
+        let request = MacroEvaluationRequest(sessionHandle: uid, context: .components(level: level.toSWBRequest, buildParameters: parameters), request: .stringExpression(expr), overrides: overrides, resultType: .stringList)
+        return try await sendMacroEvaluationStringListRequest(self, request)
     }
 
     public func evaluateMacroExpressionArrayAsStringList(_ expr: [String], level: SWBMacroEvaluationLevel, buildParameters: SWBBuildParameters, overrides: [String : String]?) async throws -> [String] {
         let parameters = buildParameters.messagePayloadRepresentation
-        return try await evaluateMacroExpressionArrayAsStringList(expr, context: .components(level: level.toSWBRequest, buildParameters: parameters), overrides: overrides)
+        let request = MacroEvaluationRequest(sessionHandle: uid, context: .components(level: level.toSWBRequest, buildParameters: parameters), request: .stringExpressionArray(expr), overrides: overrides, resultType: .stringList)
+        return try await sendMacroEvaluationStringListRequest(self, request)
     }
 
 
@@ -525,61 +465,6 @@ public final class SWBBuildServiceSession: Sendable {
     }
 
 
-    // MARK: Macro evaluation scopes
-
-
-    // FIXME: rdar://142511013 (Remove deprecated macro evaluation scope logic from SWBuild)
-    /// Request a macro evaluation scope for given level and build parameters.
-    @available(*, deprecated, message: "SWBMacroEvaluationScope is deprecated and should not be used")
-    public func createMacroEvaluationScope(level: SWBMacroEvaluationLevel, buildParameters: SWBBuildParameters) async throws -> SWBMacroEvaluationScope {
-        let parameters = buildParameters.messagePayloadRepresentation
-        let request = CreateMacroEvaluationScopeRequest(sessionHandle: uid, level: level.toSWBRequest, buildParameters: parameters)
-        let scope = try await SWBMacroEvaluationScope(self, service.send(request: request).value)
-        await sessionResourceTracker.append(scope)
-        return scope
-    }
-
-    // FIXME: rdar://142511013 (Remove deprecated macro evaluation scope logic from SWBuild)
-    @available(*, deprecated, message: "SWBMacroEvaluationScope is deprecated and should not be used")
-    public func createMacroEvaluationScope(_ level: MacroEvaluationScopeLevel, buildParameters: SWBBuildParameters) async throws -> SWBMacroEvaluationScope {
-        switch level {
-        case .defaults:
-            return try await createMacroEvaluationScope(level: .defaults, buildParameters: buildParameters)
-        case .project(let guid):
-            return try await createMacroEvaluationScope(level: .project(guid), buildParameters: buildParameters)
-        case .target(let guid):
-            return try await createMacroEvaluationScope(level: .target(guid), buildParameters: buildParameters)
-        }
-    }
-
-    // FIXME: rdar://142511013 (Remove deprecated macro evaluation scope logic from SWBuild)
-    @available(*, deprecated, message: "MacroEvaluationScopeLevel is deprecated and should not be used")
-    public enum MacroEvaluationScopeLevel: Sendable {
-        case defaults
-        case project(_ guid: String)
-        case target(_ guid: String)
-    }
-
-    // FIXME: rdar://142511013 (Remove deprecated macro evaluation scope logic from SWBuild)
-    @available(*, deprecated, message: "SWBMacroEvaluationScope is deprecated and should not be used")
-    public func createMacroEvaluationScope(projectGUID: String, buildParameters: SWBBuildParameters) async throws -> SWBMacroEvaluationScope {
-        return try await createMacroEvaluationScope(level: .project(projectGUID), buildParameters: buildParameters)
-    }
-
-    // FIXME: rdar://142511013 (Remove deprecated macro evaluation scope logic from SWBuild)
-    @available(*, deprecated, message: "SWBMacroEvaluationScope is deprecated and should not be used")
-    public func createMacroEvaluationScope(targetGUID: String, buildParameters: SWBBuildParameters) async throws -> SWBMacroEvaluationScope {
-        return try await createMacroEvaluationScope(level: .project(targetGUID), buildParameters: buildParameters)
-    }
-
-    // FIXME: rdar://142511013 (Remove deprecated macro evaluation scope logic from SWBuild)
-    /// Discard a macro evaluation scope.
-    @available(*, deprecated, message: "SWBMacroEvaluationScope is deprecated and should not be used")
-    public func discardMacroEvaluationScope(_ scope: SWBMacroEvaluationScope) async throws {
-        await sessionResourceTracker.remove(scope)
-        _ = try await service.send(request: DiscardMacroEvaluationScope(sessionHandle: uid, settingsHandle: scope.settingsHandle))
-    }
-
     /// Loads the workspace at the specified container path.
     ///
     /// The container path may be:

Sources/SwiftBuild/SWBMacroEvaluation.swift

@@ -14,6 +14,7 @@ public import Foundation
 
 import SWBProtocol
 
+/// Errors resulting from macro evaluation.
 public struct SWBMacroEvaluationError: Error, LocalizedError {
     public let message: String