Swift Package IndexBuild Information
Successful build of SecureXPC, reference 0.8.0 (d6e439), with Swift 6.0 (beta) for macOS (SPM) on 14 Sep 2024 03:54:53 UTC.
Swift 6 data race errors: 17
Build Command
env DEVELOPER_DIR=/Applications/Xcode-16.0.0-Release.Candidate.app xcrun swift build --arch arm64 -Xswiftc -Xfrontend -Xswiftc -stats-output-dir -Xswiftc -Xfrontend -Xswiftc .stats -Xswiftc -strict-concurrency=completeBuild Log
225 | let route: XPCRoute
226 |
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Request.swift:15:20: warning: static property 'route' is not concurrency-safe because non-'Sendable' type 'XPCDictionaryKey' (aka 'UnsafePointer<Int8>') may have shared mutable state; this is an error in the Swift 6 language mode
13 | struct Request {
14 | private enum RequestKeys {
15 | static let route: XPCDictionaryKey = const("__route")
| |- warning: static property 'route' is not concurrency-safe because non-'Sendable' type 'XPCDictionaryKey' (aka 'UnsafePointer<Int8>') may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'route' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
16 | static let payload: XPCDictionaryKey = const("__payload")
17 | static let requestID: XPCDictionaryKey = const("__request_id")
Swift.UnsafePointer:1:23: note: generic struct 'UnsafePointer' does not conform to the 'Sendable' protocol
1 | @frozen public struct UnsafePointer<Pointee> : Copyable where Pointee : ~Copyable {
| `- note: generic struct 'UnsafePointer' does not conform to the 'Sendable' protocol
2 | public let _rawValue: Builtin.RawPointer
3 | public init(_ _rawValue: Builtin.RawPointer)
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Request.swift:16:20: warning: static property 'payload' is not concurrency-safe because non-'Sendable' type 'XPCDictionaryKey' (aka 'UnsafePointer<Int8>') may have shared mutable state; this is an error in the Swift 6 language mode
14 | private enum RequestKeys {
15 | static let route: XPCDictionaryKey = const("__route")
16 | static let payload: XPCDictionaryKey = const("__payload")
| |- warning: static property 'payload' is not concurrency-safe because non-'Sendable' type 'XPCDictionaryKey' (aka 'UnsafePointer<Int8>') may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'payload' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
17 | static let requestID: XPCDictionaryKey = const("__request_id")
18 | static let clientBookmark: XPCDictionaryKey = const("__client_bookmark")
Swift.UnsafePointer:1:23: note: generic struct 'UnsafePointer' does not conform to the 'Sendable' protocol
1 | @frozen public struct UnsafePointer<Pointee> : Copyable where Pointee : ~Copyable {
| `- note: generic struct 'UnsafePointer' does not conform to the 'Sendable' protocol
2 | public let _rawValue: Builtin.RawPointer
3 | public init(_ _rawValue: Builtin.RawPointer)
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Request.swift:17:20: warning: static property 'requestID' is not concurrency-safe because non-'Sendable' type 'XPCDictionaryKey' (aka 'UnsafePointer<Int8>') may have shared mutable state; this is an error in the Swift 6 language mode
15 | static let route: XPCDictionaryKey = const("__route")
16 | static let payload: XPCDictionaryKey = const("__payload")
17 | static let requestID: XPCDictionaryKey = const("__request_id")
| |- warning: static property 'requestID' is not concurrency-safe because non-'Sendable' type 'XPCDictionaryKey' (aka 'UnsafePointer<Int8>') may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'requestID' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
18 | static let clientBookmark: XPCDictionaryKey = const("__client_bookmark")
19 | }
Swift.UnsafePointer:1:23: note: generic struct 'UnsafePointer' does not conform to the 'Sendable' protocol
1 | @frozen public struct UnsafePointer<Pointee> : Copyable where Pointee : ~Copyable {
| `- note: generic struct 'UnsafePointer' does not conform to the 'Sendable' protocol
2 | public let _rawValue: Builtin.RawPointer
3 | public init(_ _rawValue: Builtin.RawPointer)
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Request.swift:18:20: warning: static property 'clientBookmark' is not concurrency-safe because non-'Sendable' type 'XPCDictionaryKey' (aka 'UnsafePointer<Int8>') may have shared mutable state; this is an error in the Swift 6 language mode
16 | static let payload: XPCDictionaryKey = const("__payload")
17 | static let requestID: XPCDictionaryKey = const("__request_id")
18 | static let clientBookmark: XPCDictionaryKey = const("__client_bookmark")
| |- warning: static property 'clientBookmark' is not concurrency-safe because non-'Sendable' type 'XPCDictionaryKey' (aka 'UnsafePointer<Int8>') may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'clientBookmark' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
19 | }
20 |
Swift.UnsafePointer:1:23: note: generic struct 'UnsafePointer' does not conform to the 'Sendable' protocol
1 | @frozen public struct UnsafePointer<Pointee> : Copyable where Pointee : ~Copyable {
| `- note: generic struct 'UnsafePointer' does not conform to the 'Sendable' protocol
2 | public let _rawValue: Builtin.RawPointer
3 | public init(_ _rawValue: Builtin.RawPointer)
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Response.swift:17:20: warning: static property 'error' is not concurrency-safe because non-'Sendable' type 'XPCDictionaryKey' (aka 'UnsafePointer<Int8>') may have shared mutable state; this is an error in the Swift 6 language mode
15 |
16 | private enum ResponseKeys {
17 | static let error: XPCDictionaryKey = const("__error")
| |- warning: static property 'error' is not concurrency-safe because non-'Sendable' type 'XPCDictionaryKey' (aka 'UnsafePointer<Int8>') may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'error' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
18 | static let payload: XPCDictionaryKey = const("__payload")
19 | static let requestID: XPCDictionaryKey = const("__request_id")
Swift.UnsafePointer:1:23: note: generic struct 'UnsafePointer' does not conform to the 'Sendable' protocol
1 | @frozen public struct UnsafePointer<Pointee> : Copyable where Pointee : ~Copyable {
| `- note: generic struct 'UnsafePointer' does not conform to the 'Sendable' protocol
2 | public let _rawValue: Builtin.RawPointer
3 | public init(_ _rawValue: Builtin.RawPointer)
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Response.swift:18:20: warning: static property 'payload' is not concurrency-safe because non-'Sendable' type 'XPCDictionaryKey' (aka 'UnsafePointer<Int8>') may have shared mutable state; this is an error in the Swift 6 language mode
16 | private enum ResponseKeys {
17 | static let error: XPCDictionaryKey = const("__error")
18 | static let payload: XPCDictionaryKey = const("__payload")
| |- warning: static property 'payload' is not concurrency-safe because non-'Sendable' type 'XPCDictionaryKey' (aka 'UnsafePointer<Int8>') may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'payload' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
19 | static let requestID: XPCDictionaryKey = const("__request_id")
20 | }
Swift.UnsafePointer:1:23: note: generic struct 'UnsafePointer' does not conform to the 'Sendable' protocol
1 | @frozen public struct UnsafePointer<Pointee> : Copyable where Pointee : ~Copyable {
| `- note: generic struct 'UnsafePointer' does not conform to the 'Sendable' protocol
2 | public let _rawValue: Builtin.RawPointer
3 | public init(_ _rawValue: Builtin.RawPointer)
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Response.swift:19:20: warning: static property 'requestID' is not concurrency-safe because non-'Sendable' type 'XPCDictionaryKey' (aka 'UnsafePointer<Int8>') may have shared mutable state; this is an error in the Swift 6 language mode
17 | static let error: XPCDictionaryKey = const("__error")
18 | static let payload: XPCDictionaryKey = const("__payload")
19 | static let requestID: XPCDictionaryKey = const("__request_id")
| |- warning: static property 'requestID' is not concurrency-safe because non-'Sendable' type 'XPCDictionaryKey' (aka 'UnsafePointer<Int8>') may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'requestID' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
20 | }
21 |
Swift.UnsafePointer:1:23: note: generic struct 'UnsafePointer' does not conform to the 'Sendable' protocol
1 | @frozen public struct UnsafePointer<Pointee> : Copyable where Pointee : ~Copyable {
| `- note: generic struct 'UnsafePointer' does not conform to the 'Sendable' protocol
2 | public let _rawValue: Builtin.RawPointer
3 | public init(_ _rawValue: Builtin.RawPointer)
[23/50] Compiling SecureXPC Request.swift
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/HandlerError.swift:33:16: warning: stored property 'underlyingError' of 'Sendable'-conforming struct 'HandlerError' has non-sendable type 'HandlerError.UnderlyingError'; this is an error in the Swift 6 language mode
12 |
13 | /// Wrapper around the actual error thrown by the server or an explanation of why it is not available.
14 | public enum UnderlyingError {
| `- note: consider making enum 'UnderlyingError' conform to the 'Sendable' protocol
15 | /// The underlying error is available and is the associated type of this case.
16 | ///
:
31 | public let localizedDescription: String
32 | /// Wrapper around the actual error thrown by the handler and whether it exists in this process.
33 | public let underlyingError: UnderlyingError
| `- warning: stored property 'underlyingError' of 'Sendable'-conforming struct 'HandlerError' has non-sendable type 'HandlerError.UnderlyingError'; this is an error in the Swift 6 language mode
34 | /// The name of the underlying error's type within the server's runtime.
35 | ///
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/PackageInternalRoutes.swift:15:16: warning: static property 'noopRoute' is not concurrency-safe because non-'Sendable' type 'XPCRouteWithoutMessageWithoutReply' may have shared mutable state; this is an error in the Swift 6 language mode
13 | ///
14 | /// This is useful because the client can use this to know the server exists and get information about it such as its `SecCode`.
15 | static let noopRoute = XPCRoute.named("noop").packageInternal
| |- warning: static property 'noopRoute' is not concurrency-safe because non-'Sendable' type 'XPCRouteWithoutMessageWithoutReply' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'noopRoute' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
16 | }
17 |
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Routes.swift:224:15: note: consider making struct 'XPCRouteWithoutMessageWithoutReply' conform to the 'Sendable' protocol
222 | ///
223 | /// See ``XPCRoute`` for how to create a route.
224 | public struct XPCRouteWithoutMessageWithoutReply {
| `- note: consider making struct 'XPCRouteWithoutMessageWithoutReply' conform to the 'Sendable' protocol
225 | let route: XPCRoute
226 |
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Request.swift:15:20: warning: static property 'route' is not concurrency-safe because non-'Sendable' type 'XPCDictionaryKey' (aka 'UnsafePointer<Int8>') may have shared mutable state; this is an error in the Swift 6 language mode
13 | struct Request {
14 | private enum RequestKeys {
15 | static let route: XPCDictionaryKey = const("__route")
| |- warning: static property 'route' is not concurrency-safe because non-'Sendable' type 'XPCDictionaryKey' (aka 'UnsafePointer<Int8>') may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'route' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
16 | static let payload: XPCDictionaryKey = const("__payload")
17 | static let requestID: XPCDictionaryKey = const("__request_id")
Swift.UnsafePointer:1:23: note: generic struct 'UnsafePointer' does not conform to the 'Sendable' protocol
1 | @frozen public struct UnsafePointer<Pointee> : Copyable where Pointee : ~Copyable {
| `- note: generic struct 'UnsafePointer' does not conform to the 'Sendable' protocol
2 | public let _rawValue: Builtin.RawPointer
3 | public init(_ _rawValue: Builtin.RawPointer)
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Request.swift:16:20: warning: static property 'payload' is not concurrency-safe because non-'Sendable' type 'XPCDictionaryKey' (aka 'UnsafePointer<Int8>') may have shared mutable state; this is an error in the Swift 6 language mode
14 | private enum RequestKeys {
15 | static let route: XPCDictionaryKey = const("__route")
16 | static let payload: XPCDictionaryKey = const("__payload")
| |- warning: static property 'payload' is not concurrency-safe because non-'Sendable' type 'XPCDictionaryKey' (aka 'UnsafePointer<Int8>') may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'payload' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
17 | static let requestID: XPCDictionaryKey = const("__request_id")
18 | static let clientBookmark: XPCDictionaryKey = const("__client_bookmark")
Swift.UnsafePointer:1:23: note: generic struct 'UnsafePointer' does not conform to the 'Sendable' protocol
1 | @frozen public struct UnsafePointer<Pointee> : Copyable where Pointee : ~Copyable {
| `- note: generic struct 'UnsafePointer' does not conform to the 'Sendable' protocol
2 | public let _rawValue: Builtin.RawPointer
3 | public init(_ _rawValue: Builtin.RawPointer)
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Request.swift:17:20: warning: static property 'requestID' is not concurrency-safe because non-'Sendable' type 'XPCDictionaryKey' (aka 'UnsafePointer<Int8>') may have shared mutable state; this is an error in the Swift 6 language mode
15 | static let route: XPCDictionaryKey = const("__route")
16 | static let payload: XPCDictionaryKey = const("__payload")
17 | static let requestID: XPCDictionaryKey = const("__request_id")
| |- warning: static property 'requestID' is not concurrency-safe because non-'Sendable' type 'XPCDictionaryKey' (aka 'UnsafePointer<Int8>') may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'requestID' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
18 | static let clientBookmark: XPCDictionaryKey = const("__client_bookmark")
19 | }
Swift.UnsafePointer:1:23: note: generic struct 'UnsafePointer' does not conform to the 'Sendable' protocol
1 | @frozen public struct UnsafePointer<Pointee> : Copyable where Pointee : ~Copyable {
| `- note: generic struct 'UnsafePointer' does not conform to the 'Sendable' protocol
2 | public let _rawValue: Builtin.RawPointer
3 | public init(_ _rawValue: Builtin.RawPointer)
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Request.swift:18:20: warning: static property 'clientBookmark' is not concurrency-safe because non-'Sendable' type 'XPCDictionaryKey' (aka 'UnsafePointer<Int8>') may have shared mutable state; this is an error in the Swift 6 language mode
16 | static let payload: XPCDictionaryKey = const("__payload")
17 | static let requestID: XPCDictionaryKey = const("__request_id")
18 | static let clientBookmark: XPCDictionaryKey = const("__client_bookmark")
| |- warning: static property 'clientBookmark' is not concurrency-safe because non-'Sendable' type 'XPCDictionaryKey' (aka 'UnsafePointer<Int8>') may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'clientBookmark' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
19 | }
20 |
Swift.UnsafePointer:1:23: note: generic struct 'UnsafePointer' does not conform to the 'Sendable' protocol
1 | @frozen public struct UnsafePointer<Pointee> : Copyable where Pointee : ~Copyable {
| `- note: generic struct 'UnsafePointer' does not conform to the 'Sendable' protocol
2 | public let _rawValue: Builtin.RawPointer
3 | public init(_ _rawValue: Builtin.RawPointer)
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Response.swift:17:20: warning: static property 'error' is not concurrency-safe because non-'Sendable' type 'XPCDictionaryKey' (aka 'UnsafePointer<Int8>') may have shared mutable state; this is an error in the Swift 6 language mode
15 |
16 | private enum ResponseKeys {
17 | static let error: XPCDictionaryKey = const("__error")
| |- warning: static property 'error' is not concurrency-safe because non-'Sendable' type 'XPCDictionaryKey' (aka 'UnsafePointer<Int8>') may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'error' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
18 | static let payload: XPCDictionaryKey = const("__payload")
19 | static let requestID: XPCDictionaryKey = const("__request_id")
Swift.UnsafePointer:1:23: note: generic struct 'UnsafePointer' does not conform to the 'Sendable' protocol
1 | @frozen public struct UnsafePointer<Pointee> : Copyable where Pointee : ~Copyable {
| `- note: generic struct 'UnsafePointer' does not conform to the 'Sendable' protocol
2 | public let _rawValue: Builtin.RawPointer
3 | public init(_ _rawValue: Builtin.RawPointer)
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Response.swift:18:20: warning: static property 'payload' is not concurrency-safe because non-'Sendable' type 'XPCDictionaryKey' (aka 'UnsafePointer<Int8>') may have shared mutable state; this is an error in the Swift 6 language mode
16 | private enum ResponseKeys {
17 | static let error: XPCDictionaryKey = const("__error")
18 | static let payload: XPCDictionaryKey = const("__payload")
| |- warning: static property 'payload' is not concurrency-safe because non-'Sendable' type 'XPCDictionaryKey' (aka 'UnsafePointer<Int8>') may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'payload' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
19 | static let requestID: XPCDictionaryKey = const("__request_id")
20 | }
Swift.UnsafePointer:1:23: note: generic struct 'UnsafePointer' does not conform to the 'Sendable' protocol
1 | @frozen public struct UnsafePointer<Pointee> : Copyable where Pointee : ~Copyable {
| `- note: generic struct 'UnsafePointer' does not conform to the 'Sendable' protocol
2 | public let _rawValue: Builtin.RawPointer
3 | public init(_ _rawValue: Builtin.RawPointer)
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Response.swift:19:20: warning: static property 'requestID' is not concurrency-safe because non-'Sendable' type 'XPCDictionaryKey' (aka 'UnsafePointer<Int8>') may have shared mutable state; this is an error in the Swift 6 language mode
17 | static let error: XPCDictionaryKey = const("__error")
18 | static let payload: XPCDictionaryKey = const("__payload")
19 | static let requestID: XPCDictionaryKey = const("__request_id")
| |- warning: static property 'requestID' is not concurrency-safe because non-'Sendable' type 'XPCDictionaryKey' (aka 'UnsafePointer<Int8>') may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'requestID' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
20 | }
21 |
Swift.UnsafePointer:1:23: note: generic struct 'UnsafePointer' does not conform to the 'Sendable' protocol
1 | @frozen public struct UnsafePointer<Pointee> : Copyable where Pointee : ~Copyable {
| `- note: generic struct 'UnsafePointer' does not conform to the 'Sendable' protocol
2 | public let _rawValue: Builtin.RawPointer
3 | public init(_ _rawValue: Builtin.RawPointer)
[24/50] Compiling SecureXPC Response.swift
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/HandlerError.swift:33:16: warning: stored property 'underlyingError' of 'Sendable'-conforming struct 'HandlerError' has non-sendable type 'HandlerError.UnderlyingError'; this is an error in the Swift 6 language mode
12 |
13 | /// Wrapper around the actual error thrown by the server or an explanation of why it is not available.
14 | public enum UnderlyingError {
| `- note: consider making enum 'UnderlyingError' conform to the 'Sendable' protocol
15 | /// The underlying error is available and is the associated type of this case.
16 | ///
:
31 | public let localizedDescription: String
32 | /// Wrapper around the actual error thrown by the handler and whether it exists in this process.
33 | public let underlyingError: UnderlyingError
| `- warning: stored property 'underlyingError' of 'Sendable'-conforming struct 'HandlerError' has non-sendable type 'HandlerError.UnderlyingError'; this is an error in the Swift 6 language mode
34 | /// The name of the underlying error's type within the server's runtime.
35 | ///
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/PackageInternalRoutes.swift:15:16: warning: static property 'noopRoute' is not concurrency-safe because non-'Sendable' type 'XPCRouteWithoutMessageWithoutReply' may have shared mutable state; this is an error in the Swift 6 language mode
13 | ///
14 | /// This is useful because the client can use this to know the server exists and get information about it such as its `SecCode`.
15 | static let noopRoute = XPCRoute.named("noop").packageInternal
| |- warning: static property 'noopRoute' is not concurrency-safe because non-'Sendable' type 'XPCRouteWithoutMessageWithoutReply' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'noopRoute' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
16 | }
17 |
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Routes.swift:224:15: note: consider making struct 'XPCRouteWithoutMessageWithoutReply' conform to the 'Sendable' protocol
222 | ///
223 | /// See ``XPCRoute`` for how to create a route.
224 | public struct XPCRouteWithoutMessageWithoutReply {
| `- note: consider making struct 'XPCRouteWithoutMessageWithoutReply' conform to the 'Sendable' protocol
225 | let route: XPCRoute
226 |
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Request.swift:15:20: warning: static property 'route' is not concurrency-safe because non-'Sendable' type 'XPCDictionaryKey' (aka 'UnsafePointer<Int8>') may have shared mutable state; this is an error in the Swift 6 language mode
13 | struct Request {
14 | private enum RequestKeys {
15 | static let route: XPCDictionaryKey = const("__route")
| |- warning: static property 'route' is not concurrency-safe because non-'Sendable' type 'XPCDictionaryKey' (aka 'UnsafePointer<Int8>') may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'route' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
16 | static let payload: XPCDictionaryKey = const("__payload")
17 | static let requestID: XPCDictionaryKey = const("__request_id")
Swift.UnsafePointer:1:23: note: generic struct 'UnsafePointer' does not conform to the 'Sendable' protocol
1 | @frozen public struct UnsafePointer<Pointee> : Copyable where Pointee : ~Copyable {
| `- note: generic struct 'UnsafePointer' does not conform to the 'Sendable' protocol
2 | public let _rawValue: Builtin.RawPointer
3 | public init(_ _rawValue: Builtin.RawPointer)
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Request.swift:16:20: warning: static property 'payload' is not concurrency-safe because non-'Sendable' type 'XPCDictionaryKey' (aka 'UnsafePointer<Int8>') may have shared mutable state; this is an error in the Swift 6 language mode
14 | private enum RequestKeys {
15 | static let route: XPCDictionaryKey = const("__route")
16 | static let payload: XPCDictionaryKey = const("__payload")
| |- warning: static property 'payload' is not concurrency-safe because non-'Sendable' type 'XPCDictionaryKey' (aka 'UnsafePointer<Int8>') may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'payload' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
17 | static let requestID: XPCDictionaryKey = const("__request_id")
18 | static let clientBookmark: XPCDictionaryKey = const("__client_bookmark")
Swift.UnsafePointer:1:23: note: generic struct 'UnsafePointer' does not conform to the 'Sendable' protocol
1 | @frozen public struct UnsafePointer<Pointee> : Copyable where Pointee : ~Copyable {
| `- note: generic struct 'UnsafePointer' does not conform to the 'Sendable' protocol
2 | public let _rawValue: Builtin.RawPointer
3 | public init(_ _rawValue: Builtin.RawPointer)
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Request.swift:17:20: warning: static property 'requestID' is not concurrency-safe because non-'Sendable' type 'XPCDictionaryKey' (aka 'UnsafePointer<Int8>') may have shared mutable state; this is an error in the Swift 6 language mode
15 | static let route: XPCDictionaryKey = const("__route")
16 | static let payload: XPCDictionaryKey = const("__payload")
17 | static let requestID: XPCDictionaryKey = const("__request_id")
| |- warning: static property 'requestID' is not concurrency-safe because non-'Sendable' type 'XPCDictionaryKey' (aka 'UnsafePointer<Int8>') may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'requestID' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
18 | static let clientBookmark: XPCDictionaryKey = const("__client_bookmark")
19 | }
Swift.UnsafePointer:1:23: note: generic struct 'UnsafePointer' does not conform to the 'Sendable' protocol
1 | @frozen public struct UnsafePointer<Pointee> : Copyable where Pointee : ~Copyable {
| `- note: generic struct 'UnsafePointer' does not conform to the 'Sendable' protocol
2 | public let _rawValue: Builtin.RawPointer
3 | public init(_ _rawValue: Builtin.RawPointer)
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Request.swift:18:20: warning: static property 'clientBookmark' is not concurrency-safe because non-'Sendable' type 'XPCDictionaryKey' (aka 'UnsafePointer<Int8>') may have shared mutable state; this is an error in the Swift 6 language mode
16 | static let payload: XPCDictionaryKey = const("__payload")
17 | static let requestID: XPCDictionaryKey = const("__request_id")
18 | static let clientBookmark: XPCDictionaryKey = const("__client_bookmark")
| |- warning: static property 'clientBookmark' is not concurrency-safe because non-'Sendable' type 'XPCDictionaryKey' (aka 'UnsafePointer<Int8>') may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'clientBookmark' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
19 | }
20 |
Swift.UnsafePointer:1:23: note: generic struct 'UnsafePointer' does not conform to the 'Sendable' protocol
1 | @frozen public struct UnsafePointer<Pointee> : Copyable where Pointee : ~Copyable {
| `- note: generic struct 'UnsafePointer' does not conform to the 'Sendable' protocol
2 | public let _rawValue: Builtin.RawPointer
3 | public init(_ _rawValue: Builtin.RawPointer)
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Response.swift:17:20: warning: static property 'error' is not concurrency-safe because non-'Sendable' type 'XPCDictionaryKey' (aka 'UnsafePointer<Int8>') may have shared mutable state; this is an error in the Swift 6 language mode
15 |
16 | private enum ResponseKeys {
17 | static let error: XPCDictionaryKey = const("__error")
| |- warning: static property 'error' is not concurrency-safe because non-'Sendable' type 'XPCDictionaryKey' (aka 'UnsafePointer<Int8>') may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'error' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
18 | static let payload: XPCDictionaryKey = const("__payload")
19 | static let requestID: XPCDictionaryKey = const("__request_id")
Swift.UnsafePointer:1:23: note: generic struct 'UnsafePointer' does not conform to the 'Sendable' protocol
1 | @frozen public struct UnsafePointer<Pointee> : Copyable where Pointee : ~Copyable {
| `- note: generic struct 'UnsafePointer' does not conform to the 'Sendable' protocol
2 | public let _rawValue: Builtin.RawPointer
3 | public init(_ _rawValue: Builtin.RawPointer)
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Response.swift:18:20: warning: static property 'payload' is not concurrency-safe because non-'Sendable' type 'XPCDictionaryKey' (aka 'UnsafePointer<Int8>') may have shared mutable state; this is an error in the Swift 6 language mode
16 | private enum ResponseKeys {
17 | static let error: XPCDictionaryKey = const("__error")
18 | static let payload: XPCDictionaryKey = const("__payload")
| |- warning: static property 'payload' is not concurrency-safe because non-'Sendable' type 'XPCDictionaryKey' (aka 'UnsafePointer<Int8>') may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'payload' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
19 | static let requestID: XPCDictionaryKey = const("__request_id")
20 | }
Swift.UnsafePointer:1:23: note: generic struct 'UnsafePointer' does not conform to the 'Sendable' protocol
1 | @frozen public struct UnsafePointer<Pointee> : Copyable where Pointee : ~Copyable {
| `- note: generic struct 'UnsafePointer' does not conform to the 'Sendable' protocol
2 | public let _rawValue: Builtin.RawPointer
3 | public init(_ _rawValue: Builtin.RawPointer)
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Response.swift:19:20: warning: static property 'requestID' is not concurrency-safe because non-'Sendable' type 'XPCDictionaryKey' (aka 'UnsafePointer<Int8>') may have shared mutable state; this is an error in the Swift 6 language mode
17 | static let error: XPCDictionaryKey = const("__error")
18 | static let payload: XPCDictionaryKey = const("__payload")
19 | static let requestID: XPCDictionaryKey = const("__request_id")
| |- warning: static property 'requestID' is not concurrency-safe because non-'Sendable' type 'XPCDictionaryKey' (aka 'UnsafePointer<Int8>') may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'requestID' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
20 | }
21 |
Swift.UnsafePointer:1:23: note: generic struct 'UnsafePointer' does not conform to the 'Sendable' protocol
1 | @frozen public struct UnsafePointer<Pointee> : Copyable where Pointee : ~Copyable {
| `- note: generic struct 'UnsafePointer' does not conform to the 'Sendable' protocol
2 | public let _rawValue: Builtin.RawPointer
3 | public init(_ _rawValue: Builtin.RawPointer)
[25/50] Compiling SecureXPC Routes.swift
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/HandlerError.swift:33:16: warning: stored property 'underlyingError' of 'Sendable'-conforming struct 'HandlerError' has non-sendable type 'HandlerError.UnderlyingError'; this is an error in the Swift 6 language mode
12 |
13 | /// Wrapper around the actual error thrown by the server or an explanation of why it is not available.
14 | public enum UnderlyingError {
| `- note: consider making enum 'UnderlyingError' conform to the 'Sendable' protocol
15 | /// The underlying error is available and is the associated type of this case.
16 | ///
:
31 | public let localizedDescription: String
32 | /// Wrapper around the actual error thrown by the handler and whether it exists in this process.
33 | public let underlyingError: UnderlyingError
| `- warning: stored property 'underlyingError' of 'Sendable'-conforming struct 'HandlerError' has non-sendable type 'HandlerError.UnderlyingError'; this is an error in the Swift 6 language mode
34 | /// The name of the underlying error's type within the server's runtime.
35 | ///
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/PackageInternalRoutes.swift:15:16: warning: static property 'noopRoute' is not concurrency-safe because non-'Sendable' type 'XPCRouteWithoutMessageWithoutReply' may have shared mutable state; this is an error in the Swift 6 language mode
13 | ///
14 | /// This is useful because the client can use this to know the server exists and get information about it such as its `SecCode`.
15 | static let noopRoute = XPCRoute.named("noop").packageInternal
| |- warning: static property 'noopRoute' is not concurrency-safe because non-'Sendable' type 'XPCRouteWithoutMessageWithoutReply' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'noopRoute' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
16 | }
17 |
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Routes.swift:224:15: note: consider making struct 'XPCRouteWithoutMessageWithoutReply' conform to the 'Sendable' protocol
222 | ///
223 | /// See ``XPCRoute`` for how to create a route.
224 | public struct XPCRouteWithoutMessageWithoutReply {
| `- note: consider making struct 'XPCRouteWithoutMessageWithoutReply' conform to the 'Sendable' protocol
225 | let route: XPCRoute
226 |
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Request.swift:15:20: warning: static property 'route' is not concurrency-safe because non-'Sendable' type 'XPCDictionaryKey' (aka 'UnsafePointer<Int8>') may have shared mutable state; this is an error in the Swift 6 language mode
13 | struct Request {
14 | private enum RequestKeys {
15 | static let route: XPCDictionaryKey = const("__route")
| |- warning: static property 'route' is not concurrency-safe because non-'Sendable' type 'XPCDictionaryKey' (aka 'UnsafePointer<Int8>') may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'route' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
16 | static let payload: XPCDictionaryKey = const("__payload")
17 | static let requestID: XPCDictionaryKey = const("__request_id")
Swift.UnsafePointer:1:23: note: generic struct 'UnsafePointer' does not conform to the 'Sendable' protocol
1 | @frozen public struct UnsafePointer<Pointee> : Copyable where Pointee : ~Copyable {
| `- note: generic struct 'UnsafePointer' does not conform to the 'Sendable' protocol
2 | public let _rawValue: Builtin.RawPointer
3 | public init(_ _rawValue: Builtin.RawPointer)
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Request.swift:16:20: warning: static property 'payload' is not concurrency-safe because non-'Sendable' type 'XPCDictionaryKey' (aka 'UnsafePointer<Int8>') may have shared mutable state; this is an error in the Swift 6 language mode
14 | private enum RequestKeys {
15 | static let route: XPCDictionaryKey = const("__route")
16 | static let payload: XPCDictionaryKey = const("__payload")
| |- warning: static property 'payload' is not concurrency-safe because non-'Sendable' type 'XPCDictionaryKey' (aka 'UnsafePointer<Int8>') may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'payload' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
17 | static let requestID: XPCDictionaryKey = const("__request_id")
18 | static let clientBookmark: XPCDictionaryKey = const("__client_bookmark")
Swift.UnsafePointer:1:23: note: generic struct 'UnsafePointer' does not conform to the 'Sendable' protocol
1 | @frozen public struct UnsafePointer<Pointee> : Copyable where Pointee : ~Copyable {
| `- note: generic struct 'UnsafePointer' does not conform to the 'Sendable' protocol
2 | public let _rawValue: Builtin.RawPointer
3 | public init(_ _rawValue: Builtin.RawPointer)
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Request.swift:17:20: warning: static property 'requestID' is not concurrency-safe because non-'Sendable' type 'XPCDictionaryKey' (aka 'UnsafePointer<Int8>') may have shared mutable state; this is an error in the Swift 6 language mode
15 | static let route: XPCDictionaryKey = const("__route")
16 | static let payload: XPCDictionaryKey = const("__payload")
17 | static let requestID: XPCDictionaryKey = const("__request_id")
| |- warning: static property 'requestID' is not concurrency-safe because non-'Sendable' type 'XPCDictionaryKey' (aka 'UnsafePointer<Int8>') may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'requestID' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
18 | static let clientBookmark: XPCDictionaryKey = const("__client_bookmark")
19 | }
Swift.UnsafePointer:1:23: note: generic struct 'UnsafePointer' does not conform to the 'Sendable' protocol
1 | @frozen public struct UnsafePointer<Pointee> : Copyable where Pointee : ~Copyable {
| `- note: generic struct 'UnsafePointer' does not conform to the 'Sendable' protocol
2 | public let _rawValue: Builtin.RawPointer
3 | public init(_ _rawValue: Builtin.RawPointer)
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Request.swift:18:20: warning: static property 'clientBookmark' is not concurrency-safe because non-'Sendable' type 'XPCDictionaryKey' (aka 'UnsafePointer<Int8>') may have shared mutable state; this is an error in the Swift 6 language mode
16 | static let payload: XPCDictionaryKey = const("__payload")
17 | static let requestID: XPCDictionaryKey = const("__request_id")
18 | static let clientBookmark: XPCDictionaryKey = const("__client_bookmark")
| |- warning: static property 'clientBookmark' is not concurrency-safe because non-'Sendable' type 'XPCDictionaryKey' (aka 'UnsafePointer<Int8>') may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'clientBookmark' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
19 | }
20 |
Swift.UnsafePointer:1:23: note: generic struct 'UnsafePointer' does not conform to the 'Sendable' protocol
1 | @frozen public struct UnsafePointer<Pointee> : Copyable where Pointee : ~Copyable {
| `- note: generic struct 'UnsafePointer' does not conform to the 'Sendable' protocol
2 | public let _rawValue: Builtin.RawPointer
3 | public init(_ _rawValue: Builtin.RawPointer)
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Response.swift:17:20: warning: static property 'error' is not concurrency-safe because non-'Sendable' type 'XPCDictionaryKey' (aka 'UnsafePointer<Int8>') may have shared mutable state; this is an error in the Swift 6 language mode
15 |
16 | private enum ResponseKeys {
17 | static let error: XPCDictionaryKey = const("__error")
| |- warning: static property 'error' is not concurrency-safe because non-'Sendable' type 'XPCDictionaryKey' (aka 'UnsafePointer<Int8>') may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'error' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
18 | static let payload: XPCDictionaryKey = const("__payload")
19 | static let requestID: XPCDictionaryKey = const("__request_id")
Swift.UnsafePointer:1:23: note: generic struct 'UnsafePointer' does not conform to the 'Sendable' protocol
1 | @frozen public struct UnsafePointer<Pointee> : Copyable where Pointee : ~Copyable {
| `- note: generic struct 'UnsafePointer' does not conform to the 'Sendable' protocol
2 | public let _rawValue: Builtin.RawPointer
3 | public init(_ _rawValue: Builtin.RawPointer)
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Response.swift:18:20: warning: static property 'payload' is not concurrency-safe because non-'Sendable' type 'XPCDictionaryKey' (aka 'UnsafePointer<Int8>') may have shared mutable state; this is an error in the Swift 6 language mode
16 | private enum ResponseKeys {
17 | static let error: XPCDictionaryKey = const("__error")
18 | static let payload: XPCDictionaryKey = const("__payload")
| |- warning: static property 'payload' is not concurrency-safe because non-'Sendable' type 'XPCDictionaryKey' (aka 'UnsafePointer<Int8>') may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'payload' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
19 | static let requestID: XPCDictionaryKey = const("__request_id")
20 | }
Swift.UnsafePointer:1:23: note: generic struct 'UnsafePointer' does not conform to the 'Sendable' protocol
1 | @frozen public struct UnsafePointer<Pointee> : Copyable where Pointee : ~Copyable {
| `- note: generic struct 'UnsafePointer' does not conform to the 'Sendable' protocol
2 | public let _rawValue: Builtin.RawPointer
3 | public init(_ _rawValue: Builtin.RawPointer)
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Response.swift:19:20: warning: static property 'requestID' is not concurrency-safe because non-'Sendable' type 'XPCDictionaryKey' (aka 'UnsafePointer<Int8>') may have shared mutable state; this is an error in the Swift 6 language mode
17 | static let error: XPCDictionaryKey = const("__error")
18 | static let payload: XPCDictionaryKey = const("__payload")
19 | static let requestID: XPCDictionaryKey = const("__request_id")
| |- warning: static property 'requestID' is not concurrency-safe because non-'Sendable' type 'XPCDictionaryKey' (aka 'UnsafePointer<Int8>') may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'requestID' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
20 | }
21 |
Swift.UnsafePointer:1:23: note: generic struct 'UnsafePointer' does not conform to the 'Sendable' protocol
1 | @frozen public struct UnsafePointer<Pointee> : Copyable where Pointee : ~Copyable {
| `- note: generic struct 'UnsafePointer' does not conform to the 'Sendable' protocol
2 | public let _rawValue: Builtin.RawPointer
3 | public init(_ _rawValue: Builtin.RawPointer)
[26/50] Compiling SecureXPC XPCAnonymousServer.swift
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCMachServer.swift:89:24: warning: static property 'machServerCache' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
87 | /// This exists for correctness reasons, not as a performance optimization. Only one listener connection for a named service can exist simultaneously, so it's
88 | /// important this invariant be upheld when returning `XPCServer` instances.
89 | private static var machServerCache = [String : XPCMachServer]()
| |- warning: static property 'machServerCache' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
| |- note: convert 'machServerCache' to a 'let' constant to make 'Sendable' shared state immutable
| |- note: annotate 'machServerCache' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
90 |
91 | /// Prevents race conditions for creating and retrieving cached Mach servers
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/PackageInternalRoutes.swift:15:16: warning: static property 'noopRoute' is not concurrency-safe because non-'Sendable' type 'XPCRouteWithoutMessageWithoutReply' may have shared mutable state; this is an error in the Swift 6 language mode
13 | ///
14 | /// This is useful because the client can use this to know the server exists and get information about it such as its `SecCode`.
15 | static let noopRoute = XPCRoute.named("noop").packageInternal
| |- warning: static property 'noopRoute' is not concurrency-safe because non-'Sendable' type 'XPCRouteWithoutMessageWithoutReply' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'noopRoute' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
16 | }
17 |
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Routes.swift:224:15: note: consider making struct 'XPCRouteWithoutMessageWithoutReply' conform to the 'Sendable' protocol
222 | ///
223 | /// See ``XPCRoute`` for how to create a route.
224 | public struct XPCRouteWithoutMessageWithoutReply {
| `- note: consider making struct 'XPCRouteWithoutMessageWithoutReply' conform to the 'Sendable' protocol
225 | let route: XPCRoute
226 |
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCServer.swift:392:74: warning: capture of 'connection' with non-sendable type 'xpc_connection_t' (aka 'any OS_xpc_object') in a `@Sendable` closure; this is an error in the Swift 6 language mode
390 | // concurrent. (Although if an API user sets the target queue to be serial that's supported too.)
391 | self.handlerQueue.async {
392 | XPCServer.ClientIdentity.setForCurrentThread(connection: connection, message: message) {
| `- warning: capture of 'connection' with non-sendable type 'xpc_connection_t' (aka 'any OS_xpc_object') in a `@Sendable` closure; this is an error in the Swift 6 language mode
393 | var reply = handler.shouldCreateReply ? xpc_dictionary_create_reply(message) : nil
394 | do {
XPC.OS_xpc_object:1:17: note: protocol 'OS_xpc_object' does not conform to the 'Sendable' protocol
1 | public protocol OS_xpc_object : NSObjectProtocol {
| `- note: protocol 'OS_xpc_object' does not conform to the 'Sendable' protocol
2 | }
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCServer.swift:8:1: warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'XPC'
6 | //
7 |
8 | import Foundation
| `- warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'XPC'
9 |
10 | /// An XPC server to receive requests from and send responses to an ``XPCClient``.
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCServer.swift:392:95: warning: capture of 'message' with non-sendable type 'xpc_object_t' (aka 'any OS_xpc_object') in a `@Sendable` closure; this is an error in the Swift 6 language mode
390 | // concurrent. (Although if an API user sets the target queue to be serial that's supported too.)
391 | self.handlerQueue.async {
392 | XPCServer.ClientIdentity.setForCurrentThread(connection: connection, message: message) {
| `- warning: capture of 'message' with non-sendable type 'xpc_object_t' (aka 'any OS_xpc_object') in a `@Sendable` closure; this is an error in the Swift 6 language mode
393 | var reply = handler.shouldCreateReply ? xpc_dictionary_create_reply(message) : nil
394 | do {
XPC.OS_xpc_object:1:17: note: protocol 'OS_xpc_object' does not conform to the 'Sendable' protocol
1 | public protocol OS_xpc_object : NSObjectProtocol {
| `- note: protocol 'OS_xpc_object' does not conform to the 'Sendable' protocol
2 | }
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCServer.swift:393:33: warning: capture of 'handler' with non-sendable type 'any XPCHandlerSync' in a `@Sendable` closure; this is an error in the Swift 6 language mode
391 | self.handlerQueue.async {
392 | XPCServer.ClientIdentity.setForCurrentThread(connection: connection, message: message) {
393 | var reply = handler.shouldCreateReply ? xpc_dictionary_create_reply(message) : nil
| `- warning: capture of 'handler' with non-sendable type 'any XPCHandlerSync' in a `@Sendable` closure; this is an error in the Swift 6 language mode
394 | do {
395 | try handler.handle(request: request, server: self, connection: connection, reply: &reply)
:
703 | // MARK: sync handler function wrappers
704 |
705 | fileprivate protocol XPCHandlerSync: XPCHandler {
| `- note: protocol 'XPCHandlerSync' does not conform to the 'Sendable' protocol
706 | func handle(request: Request, server: XPCServer, connection: xpc_connection_t, reply: inout xpc_object_t?) throws
707 | }
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCServer.swift:395:53: warning: capture of 'request' with non-sendable type 'Request' in a `@Sendable` closure; this is an error in the Swift 6 language mode
393 | var reply = handler.shouldCreateReply ? xpc_dictionary_create_reply(message) : nil
394 | do {
395 | try handler.handle(request: request, server: self, connection: connection, reply: &reply)
| `- warning: capture of 'request' with non-sendable type 'Request' in a `@Sendable` closure; this is an error in the Swift 6 language mode
396 | try self.maybeSendReply(&reply, request: request, connection: connection)
397 | } catch {
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Request.swift:13:8: note: consider making struct 'Request' conform to the 'Sendable' protocol
11 | ///
12 | /// A request always contains a route and optionally contains a payload.
13 | struct Request {
| `- note: consider making struct 'Request' conform to the 'Sendable' protocol
14 | private enum RequestKeys {
15 | static let route: XPCDictionaryKey = const("__route")
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCServer.swift:395:70: warning: capture of 'self' with non-sendable type 'XPCServer' in a `@Sendable` closure; this is an error in the Swift 6 language mode
133 | /// - ``connectionDescriptor``
134 | /// - ``endpoint``
135 | public class XPCServer {
| `- note: class 'XPCServer' does not conform to the 'Sendable' protocol
136 |
137 | /// The queue used to run synchronous handlers associated with registered routes.
:
393 | var reply = handler.shouldCreateReply ? xpc_dictionary_create_reply(message) : nil
394 | do {
395 | try handler.handle(request: request, server: self, connection: connection, reply: &reply)
| `- warning: capture of 'self' with non-sendable type 'XPCServer' in a `@Sendable` closure; this is an error in the Swift 6 language mode
396 | try self.maybeSendReply(&reply, request: request, connection: connection)
397 | } catch {
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCServer.swift:393:33: warning: capture of 'handler' with non-sendable type 'any XPCHandlerSync' in an isolated closure; this is an error in the Swift 6 language mode
391 | self.handlerQueue.async {
392 | XPCServer.ClientIdentity.setForCurrentThread(connection: connection, message: message) {
393 | var reply = handler.shouldCreateReply ? xpc_dictionary_create_reply(message) : nil
| `- warning: capture of 'handler' with non-sendable type 'any XPCHandlerSync' in an isolated closure; this is an error in the Swift 6 language mode
394 | do {
395 | try handler.handle(request: request, server: self, connection: connection, reply: &reply)
:
703 | // MARK: sync handler function wrappers
704 |
705 | fileprivate protocol XPCHandlerSync: XPCHandler {
| `- note: protocol 'XPCHandlerSync' does not conform to the 'Sendable' protocol
706 | func handle(request: Request, server: XPCServer, connection: xpc_connection_t, reply: inout xpc_object_t?) throws
707 | }
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCServer.swift:393:89: warning: capture of 'message' with non-sendable type 'xpc_object_t' (aka 'any OS_xpc_object') in an isolated closure; this is an error in the Swift 6 language mode
391 | self.handlerQueue.async {
392 | XPCServer.ClientIdentity.setForCurrentThread(connection: connection, message: message) {
393 | var reply = handler.shouldCreateReply ? xpc_dictionary_create_reply(message) : nil
| `- warning: capture of 'message' with non-sendable type 'xpc_object_t' (aka 'any OS_xpc_object') in an isolated closure; this is an error in the Swift 6 language mode
394 | do {
395 | try handler.handle(request: request, server: self, connection: connection, reply: &reply)
XPC.OS_xpc_object:1:17: note: protocol 'OS_xpc_object' does not conform to the 'Sendable' protocol
1 | public protocol OS_xpc_object : NSObjectProtocol {
| `- note: protocol 'OS_xpc_object' does not conform to the 'Sendable' protocol
2 | }
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCServer.swift:395:53: warning: capture of 'request' with non-sendable type 'Request' in an isolated closure; this is an error in the Swift 6 language mode
393 | var reply = handler.shouldCreateReply ? xpc_dictionary_create_reply(message) : nil
394 | do {
395 | try handler.handle(request: request, server: self, connection: connection, reply: &reply)
| `- warning: capture of 'request' with non-sendable type 'Request' in an isolated closure; this is an error in the Swift 6 language mode
396 | try self.maybeSendReply(&reply, request: request, connection: connection)
397 | } catch {
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Request.swift:13:8: note: consider making struct 'Request' conform to the 'Sendable' protocol
11 | ///
12 | /// A request always contains a route and optionally contains a payload.
13 | struct Request {
| `- note: consider making struct 'Request' conform to the 'Sendable' protocol
14 | private enum RequestKeys {
15 | static let route: XPCDictionaryKey = const("__route")
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCServer.swift:395:70: warning: capture of 'self' with non-sendable type 'XPCServer' in an isolated closure; this is an error in the Swift 6 language mode
133 | /// - ``connectionDescriptor``
134 | /// - ``endpoint``
135 | public class XPCServer {
| `- note: class 'XPCServer' does not conform to the 'Sendable' protocol
136 |
137 | /// The queue used to run synchronous handlers associated with registered routes.
:
393 | var reply = handler.shouldCreateReply ? xpc_dictionary_create_reply(message) : nil
394 | do {
395 | try handler.handle(request: request, server: self, connection: connection, reply: &reply)
| `- warning: capture of 'self' with non-sendable type 'XPCServer' in an isolated closure; this is an error in the Swift 6 language mode
396 | try self.maybeSendReply(&reply, request: request, connection: connection)
397 | } catch {
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCServer.swift:395:88: warning: capture of 'connection' with non-sendable type 'xpc_connection_t' (aka 'any OS_xpc_object') in an isolated closure; this is an error in the Swift 6 language mode
393 | var reply = handler.shouldCreateReply ? xpc_dictionary_create_reply(message) : nil
394 | do {
395 | try handler.handle(request: request, server: self, connection: connection, reply: &reply)
| `- warning: capture of 'connection' with non-sendable type 'xpc_connection_t' (aka 'any OS_xpc_object') in an isolated closure; this is an error in the Swift 6 language mode
396 | try self.maybeSendReply(&reply, request: request, connection: connection)
397 | } catch {
XPC.OS_xpc_object:1:17: note: protocol 'OS_xpc_object' does not conform to the 'Sendable' protocol
1 | public protocol OS_xpc_object : NSObjectProtocol {
| `- note: protocol 'OS_xpc_object' does not conform to the 'Sendable' protocol
2 | }
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCServiceServer.swift:25:24: warning: static property 'service' is not concurrency-safe because non-'Sendable' type 'XPCServiceServer' may have shared mutable state; this is an error in the Swift 6 language mode
11 | ///
12 | /// In the case of this framework, the XPC service is expected to be communicated with by an `XPCServiceClient`.
13 | internal class XPCServiceServer: XPCServer {
| `- note: class 'XPCServiceServer' does not conform to the 'Sendable' protocol
14 |
15 | internal static var isThisProcessAnXPCService: Bool {
:
23 |
24 | /// The server itself, there can only ever be one per process as there is only ever one named connection that exists for an XPC service
25 | private static let service = XPCServiceServer(clientRequirement: .alwaysAccepting)
| |- warning: static property 'service' is not concurrency-safe because non-'Sendable' type 'XPCServiceServer' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'service' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
26 |
27 | /// Whether this server has been started.
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCServer.swift:907:21: warning: task-isolated value of type '() async -> Void' passed as a strongly transferred parameter; later accesses could race; this is an error in the Swift 6 language mode
905 | case .async(let handler):
906 | if #available(macOS 10.15, *) {
907 | Task {
| `- warning: task-isolated value of type '() async -> Void' passed as a strongly transferred parameter; later accesses could race; this is an error in the Swift 6 language mode
908 | await handler(error)
909 | }
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCServer.swift:417:17: warning: task-isolated value of type '() async -> ()' passed as a strongly transferred parameter; later accesses could race; this is an error in the Swift 6 language mode
415 | // consistent ordering of received events due to the asynchronous behavior of how they're sent by the
416 | // XPCClient. If an API user wants consistent ordering, that needs to be done at the application layer.
417 | Task {
| `- warning: task-isolated value of type '() async -> ()' passed as a strongly transferred parameter; later accesses could race; this is an error in the Swift 6 language mode
418 | var reply = handler.shouldCreateReply ? xpc_dictionary_create_reply(message) : nil
419 | do {
[27/50] Compiling SecureXPC XPCMachServer.swift
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCMachServer.swift:89:24: warning: static property 'machServerCache' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
87 | /// This exists for correctness reasons, not as a performance optimization. Only one listener connection for a named service can exist simultaneously, so it's
88 | /// important this invariant be upheld when returning `XPCServer` instances.
89 | private static var machServerCache = [String : XPCMachServer]()
| |- warning: static property 'machServerCache' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
| |- note: convert 'machServerCache' to a 'let' constant to make 'Sendable' shared state immutable
| |- note: annotate 'machServerCache' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
90 |
91 | /// Prevents race conditions for creating and retrieving cached Mach servers
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/PackageInternalRoutes.swift:15:16: warning: static property 'noopRoute' is not concurrency-safe because non-'Sendable' type 'XPCRouteWithoutMessageWithoutReply' may have shared mutable state; this is an error in the Swift 6 language mode
13 | ///
14 | /// This is useful because the client can use this to know the server exists and get information about it such as its `SecCode`.
15 | static let noopRoute = XPCRoute.named("noop").packageInternal
| |- warning: static property 'noopRoute' is not concurrency-safe because non-'Sendable' type 'XPCRouteWithoutMessageWithoutReply' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'noopRoute' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
16 | }
17 |
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Routes.swift:224:15: note: consider making struct 'XPCRouteWithoutMessageWithoutReply' conform to the 'Sendable' protocol
222 | ///
223 | /// See ``XPCRoute`` for how to create a route.
224 | public struct XPCRouteWithoutMessageWithoutReply {
| `- note: consider making struct 'XPCRouteWithoutMessageWithoutReply' conform to the 'Sendable' protocol
225 | let route: XPCRoute
226 |
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCServer.swift:392:74: warning: capture of 'connection' with non-sendable type 'xpc_connection_t' (aka 'any OS_xpc_object') in a `@Sendable` closure; this is an error in the Swift 6 language mode
390 | // concurrent. (Although if an API user sets the target queue to be serial that's supported too.)
391 | self.handlerQueue.async {
392 | XPCServer.ClientIdentity.setForCurrentThread(connection: connection, message: message) {
| `- warning: capture of 'connection' with non-sendable type 'xpc_connection_t' (aka 'any OS_xpc_object') in a `@Sendable` closure; this is an error in the Swift 6 language mode
393 | var reply = handler.shouldCreateReply ? xpc_dictionary_create_reply(message) : nil
394 | do {
XPC.OS_xpc_object:1:17: note: protocol 'OS_xpc_object' does not conform to the 'Sendable' protocol
1 | public protocol OS_xpc_object : NSObjectProtocol {
| `- note: protocol 'OS_xpc_object' does not conform to the 'Sendable' protocol
2 | }
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCServer.swift:8:1: warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'XPC'
6 | //
7 |
8 | import Foundation
| `- warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'XPC'
9 |
10 | /// An XPC server to receive requests from and send responses to an ``XPCClient``.
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCServer.swift:392:95: warning: capture of 'message' with non-sendable type 'xpc_object_t' (aka 'any OS_xpc_object') in a `@Sendable` closure; this is an error in the Swift 6 language mode
390 | // concurrent. (Although if an API user sets the target queue to be serial that's supported too.)
391 | self.handlerQueue.async {
392 | XPCServer.ClientIdentity.setForCurrentThread(connection: connection, message: message) {
| `- warning: capture of 'message' with non-sendable type 'xpc_object_t' (aka 'any OS_xpc_object') in a `@Sendable` closure; this is an error in the Swift 6 language mode
393 | var reply = handler.shouldCreateReply ? xpc_dictionary_create_reply(message) : nil
394 | do {
XPC.OS_xpc_object:1:17: note: protocol 'OS_xpc_object' does not conform to the 'Sendable' protocol
1 | public protocol OS_xpc_object : NSObjectProtocol {
| `- note: protocol 'OS_xpc_object' does not conform to the 'Sendable' protocol
2 | }
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCServer.swift:393:33: warning: capture of 'handler' with non-sendable type 'any XPCHandlerSync' in a `@Sendable` closure; this is an error in the Swift 6 language mode
391 | self.handlerQueue.async {
392 | XPCServer.ClientIdentity.setForCurrentThread(connection: connection, message: message) {
393 | var reply = handler.shouldCreateReply ? xpc_dictionary_create_reply(message) : nil
| `- warning: capture of 'handler' with non-sendable type 'any XPCHandlerSync' in a `@Sendable` closure; this is an error in the Swift 6 language mode
394 | do {
395 | try handler.handle(request: request, server: self, connection: connection, reply: &reply)
:
703 | // MARK: sync handler function wrappers
704 |
705 | fileprivate protocol XPCHandlerSync: XPCHandler {
| `- note: protocol 'XPCHandlerSync' does not conform to the 'Sendable' protocol
706 | func handle(request: Request, server: XPCServer, connection: xpc_connection_t, reply: inout xpc_object_t?) throws
707 | }
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCServer.swift:395:53: warning: capture of 'request' with non-sendable type 'Request' in a `@Sendable` closure; this is an error in the Swift 6 language mode
393 | var reply = handler.shouldCreateReply ? xpc_dictionary_create_reply(message) : nil
394 | do {
395 | try handler.handle(request: request, server: self, connection: connection, reply: &reply)
| `- warning: capture of 'request' with non-sendable type 'Request' in a `@Sendable` closure; this is an error in the Swift 6 language mode
396 | try self.maybeSendReply(&reply, request: request, connection: connection)
397 | } catch {
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Request.swift:13:8: note: consider making struct 'Request' conform to the 'Sendable' protocol
11 | ///
12 | /// A request always contains a route and optionally contains a payload.
13 | struct Request {
| `- note: consider making struct 'Request' conform to the 'Sendable' protocol
14 | private enum RequestKeys {
15 | static let route: XPCDictionaryKey = const("__route")
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCServer.swift:395:70: warning: capture of 'self' with non-sendable type 'XPCServer' in a `@Sendable` closure; this is an error in the Swift 6 language mode
133 | /// - ``connectionDescriptor``
134 | /// - ``endpoint``
135 | public class XPCServer {
| `- note: class 'XPCServer' does not conform to the 'Sendable' protocol
136 |
137 | /// The queue used to run synchronous handlers associated with registered routes.
:
393 | var reply = handler.shouldCreateReply ? xpc_dictionary_create_reply(message) : nil
394 | do {
395 | try handler.handle(request: request, server: self, connection: connection, reply: &reply)
| `- warning: capture of 'self' with non-sendable type 'XPCServer' in a `@Sendable` closure; this is an error in the Swift 6 language mode
396 | try self.maybeSendReply(&reply, request: request, connection: connection)
397 | } catch {
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCServer.swift:393:33: warning: capture of 'handler' with non-sendable type 'any XPCHandlerSync' in an isolated closure; this is an error in the Swift 6 language mode
391 | self.handlerQueue.async {
392 | XPCServer.ClientIdentity.setForCurrentThread(connection: connection, message: message) {
393 | var reply = handler.shouldCreateReply ? xpc_dictionary_create_reply(message) : nil
| `- warning: capture of 'handler' with non-sendable type 'any XPCHandlerSync' in an isolated closure; this is an error in the Swift 6 language mode
394 | do {
395 | try handler.handle(request: request, server: self, connection: connection, reply: &reply)
:
703 | // MARK: sync handler function wrappers
704 |
705 | fileprivate protocol XPCHandlerSync: XPCHandler {
| `- note: protocol 'XPCHandlerSync' does not conform to the 'Sendable' protocol
706 | func handle(request: Request, server: XPCServer, connection: xpc_connection_t, reply: inout xpc_object_t?) throws
707 | }
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCServer.swift:393:89: warning: capture of 'message' with non-sendable type 'xpc_object_t' (aka 'any OS_xpc_object') in an isolated closure; this is an error in the Swift 6 language mode
391 | self.handlerQueue.async {
392 | XPCServer.ClientIdentity.setForCurrentThread(connection: connection, message: message) {
393 | var reply = handler.shouldCreateReply ? xpc_dictionary_create_reply(message) : nil
| `- warning: capture of 'message' with non-sendable type 'xpc_object_t' (aka 'any OS_xpc_object') in an isolated closure; this is an error in the Swift 6 language mode
394 | do {
395 | try handler.handle(request: request, server: self, connection: connection, reply: &reply)
XPC.OS_xpc_object:1:17: note: protocol 'OS_xpc_object' does not conform to the 'Sendable' protocol
1 | public protocol OS_xpc_object : NSObjectProtocol {
| `- note: protocol 'OS_xpc_object' does not conform to the 'Sendable' protocol
2 | }
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCServer.swift:395:53: warning: capture of 'request' with non-sendable type 'Request' in an isolated closure; this is an error in the Swift 6 language mode
393 | var reply = handler.shouldCreateReply ? xpc_dictionary_create_reply(message) : nil
394 | do {
395 | try handler.handle(request: request, server: self, connection: connection, reply: &reply)
| `- warning: capture of 'request' with non-sendable type 'Request' in an isolated closure; this is an error in the Swift 6 language mode
396 | try self.maybeSendReply(&reply, request: request, connection: connection)
397 | } catch {
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Request.swift:13:8: note: consider making struct 'Request' conform to the 'Sendable' protocol
11 | ///
12 | /// A request always contains a route and optionally contains a payload.
13 | struct Request {
| `- note: consider making struct 'Request' conform to the 'Sendable' protocol
14 | private enum RequestKeys {
15 | static let route: XPCDictionaryKey = const("__route")
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCServer.swift:395:70: warning: capture of 'self' with non-sendable type 'XPCServer' in an isolated closure; this is an error in the Swift 6 language mode
133 | /// - ``connectionDescriptor``
134 | /// - ``endpoint``
135 | public class XPCServer {
| `- note: class 'XPCServer' does not conform to the 'Sendable' protocol
136 |
137 | /// The queue used to run synchronous handlers associated with registered routes.
:
393 | var reply = handler.shouldCreateReply ? xpc_dictionary_create_reply(message) : nil
394 | do {
395 | try handler.handle(request: request, server: self, connection: connection, reply: &reply)
| `- warning: capture of 'self' with non-sendable type 'XPCServer' in an isolated closure; this is an error in the Swift 6 language mode
396 | try self.maybeSendReply(&reply, request: request, connection: connection)
397 | } catch {
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCServer.swift:395:88: warning: capture of 'connection' with non-sendable type 'xpc_connection_t' (aka 'any OS_xpc_object') in an isolated closure; this is an error in the Swift 6 language mode
393 | var reply = handler.shouldCreateReply ? xpc_dictionary_create_reply(message) : nil
394 | do {
395 | try handler.handle(request: request, server: self, connection: connection, reply: &reply)
| `- warning: capture of 'connection' with non-sendable type 'xpc_connection_t' (aka 'any OS_xpc_object') in an isolated closure; this is an error in the Swift 6 language mode
396 | try self.maybeSendReply(&reply, request: request, connection: connection)
397 | } catch {
XPC.OS_xpc_object:1:17: note: protocol 'OS_xpc_object' does not conform to the 'Sendable' protocol
1 | public protocol OS_xpc_object : NSObjectProtocol {
| `- note: protocol 'OS_xpc_object' does not conform to the 'Sendable' protocol
2 | }
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCServiceServer.swift:25:24: warning: static property 'service' is not concurrency-safe because non-'Sendable' type 'XPCServiceServer' may have shared mutable state; this is an error in the Swift 6 language mode
11 | ///
12 | /// In the case of this framework, the XPC service is expected to be communicated with by an `XPCServiceClient`.
13 | internal class XPCServiceServer: XPCServer {
| `- note: class 'XPCServiceServer' does not conform to the 'Sendable' protocol
14 |
15 | internal static var isThisProcessAnXPCService: Bool {
:
23 |
24 | /// The server itself, there can only ever be one per process as there is only ever one named connection that exists for an XPC service
25 | private static let service = XPCServiceServer(clientRequirement: .alwaysAccepting)
| |- warning: static property 'service' is not concurrency-safe because non-'Sendable' type 'XPCServiceServer' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'service' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
26 |
27 | /// Whether this server has been started.
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCServer.swift:907:21: warning: task-isolated value of type '() async -> Void' passed as a strongly transferred parameter; later accesses could race; this is an error in the Swift 6 language mode
905 | case .async(let handler):
906 | if #available(macOS 10.15, *) {
907 | Task {
| `- warning: task-isolated value of type '() async -> Void' passed as a strongly transferred parameter; later accesses could race; this is an error in the Swift 6 language mode
908 | await handler(error)
909 | }
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCServer.swift:417:17: warning: task-isolated value of type '() async -> ()' passed as a strongly transferred parameter; later accesses could race; this is an error in the Swift 6 language mode
415 | // consistent ordering of received events due to the asynchronous behavior of how they're sent by the
416 | // XPCClient. If an API user wants consistent ordering, that needs to be done at the application layer.
417 | Task {
| `- warning: task-isolated value of type '() async -> ()' passed as a strongly transferred parameter; later accesses could race; this is an error in the Swift 6 language mode
418 | var reply = handler.shouldCreateReply ? xpc_dictionary_create_reply(message) : nil
419 | do {
[28/50] Compiling SecureXPC XPCServer.swift
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCMachServer.swift:89:24: warning: static property 'machServerCache' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
87 | /// This exists for correctness reasons, not as a performance optimization. Only one listener connection for a named service can exist simultaneously, so it's
88 | /// important this invariant be upheld when returning `XPCServer` instances.
89 | private static var machServerCache = [String : XPCMachServer]()
| |- warning: static property 'machServerCache' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
| |- note: convert 'machServerCache' to a 'let' constant to make 'Sendable' shared state immutable
| |- note: annotate 'machServerCache' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
90 |
91 | /// Prevents race conditions for creating and retrieving cached Mach servers
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/PackageInternalRoutes.swift:15:16: warning: static property 'noopRoute' is not concurrency-safe because non-'Sendable' type 'XPCRouteWithoutMessageWithoutReply' may have shared mutable state; this is an error in the Swift 6 language mode
13 | ///
14 | /// This is useful because the client can use this to know the server exists and get information about it such as its `SecCode`.
15 | static let noopRoute = XPCRoute.named("noop").packageInternal
| |- warning: static property 'noopRoute' is not concurrency-safe because non-'Sendable' type 'XPCRouteWithoutMessageWithoutReply' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'noopRoute' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
16 | }
17 |
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Routes.swift:224:15: note: consider making struct 'XPCRouteWithoutMessageWithoutReply' conform to the 'Sendable' protocol
222 | ///
223 | /// See ``XPCRoute`` for how to create a route.
224 | public struct XPCRouteWithoutMessageWithoutReply {
| `- note: consider making struct 'XPCRouteWithoutMessageWithoutReply' conform to the 'Sendable' protocol
225 | let route: XPCRoute
226 |
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCServer.swift:392:74: warning: capture of 'connection' with non-sendable type 'xpc_connection_t' (aka 'any OS_xpc_object') in a `@Sendable` closure; this is an error in the Swift 6 language mode
390 | // concurrent. (Although if an API user sets the target queue to be serial that's supported too.)
391 | self.handlerQueue.async {
392 | XPCServer.ClientIdentity.setForCurrentThread(connection: connection, message: message) {
| `- warning: capture of 'connection' with non-sendable type 'xpc_connection_t' (aka 'any OS_xpc_object') in a `@Sendable` closure; this is an error in the Swift 6 language mode
393 | var reply = handler.shouldCreateReply ? xpc_dictionary_create_reply(message) : nil
394 | do {
XPC.OS_xpc_object:1:17: note: protocol 'OS_xpc_object' does not conform to the 'Sendable' protocol
1 | public protocol OS_xpc_object : NSObjectProtocol {
| `- note: protocol 'OS_xpc_object' does not conform to the 'Sendable' protocol
2 | }
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCServer.swift:8:1: warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'XPC'
6 | //
7 |
8 | import Foundation
| `- warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'XPC'
9 |
10 | /// An XPC server to receive requests from and send responses to an ``XPCClient``.
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCServer.swift:392:95: warning: capture of 'message' with non-sendable type 'xpc_object_t' (aka 'any OS_xpc_object') in a `@Sendable` closure; this is an error in the Swift 6 language mode
390 | // concurrent. (Although if an API user sets the target queue to be serial that's supported too.)
391 | self.handlerQueue.async {
392 | XPCServer.ClientIdentity.setForCurrentThread(connection: connection, message: message) {
| `- warning: capture of 'message' with non-sendable type 'xpc_object_t' (aka 'any OS_xpc_object') in a `@Sendable` closure; this is an error in the Swift 6 language mode
393 | var reply = handler.shouldCreateReply ? xpc_dictionary_create_reply(message) : nil
394 | do {
XPC.OS_xpc_object:1:17: note: protocol 'OS_xpc_object' does not conform to the 'Sendable' protocol
1 | public protocol OS_xpc_object : NSObjectProtocol {
| `- note: protocol 'OS_xpc_object' does not conform to the 'Sendable' protocol
2 | }
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCServer.swift:393:33: warning: capture of 'handler' with non-sendable type 'any XPCHandlerSync' in a `@Sendable` closure; this is an error in the Swift 6 language mode
391 | self.handlerQueue.async {
392 | XPCServer.ClientIdentity.setForCurrentThread(connection: connection, message: message) {
393 | var reply = handler.shouldCreateReply ? xpc_dictionary_create_reply(message) : nil
| `- warning: capture of 'handler' with non-sendable type 'any XPCHandlerSync' in a `@Sendable` closure; this is an error in the Swift 6 language mode
394 | do {
395 | try handler.handle(request: request, server: self, connection: connection, reply: &reply)
:
703 | // MARK: sync handler function wrappers
704 |
705 | fileprivate protocol XPCHandlerSync: XPCHandler {
| `- note: protocol 'XPCHandlerSync' does not conform to the 'Sendable' protocol
706 | func handle(request: Request, server: XPCServer, connection: xpc_connection_t, reply: inout xpc_object_t?) throws
707 | }
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCServer.swift:395:53: warning: capture of 'request' with non-sendable type 'Request' in a `@Sendable` closure; this is an error in the Swift 6 language mode
393 | var reply = handler.shouldCreateReply ? xpc_dictionary_create_reply(message) : nil
394 | do {
395 | try handler.handle(request: request, server: self, connection: connection, reply: &reply)
| `- warning: capture of 'request' with non-sendable type 'Request' in a `@Sendable` closure; this is an error in the Swift 6 language mode
396 | try self.maybeSendReply(&reply, request: request, connection: connection)
397 | } catch {
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Request.swift:13:8: note: consider making struct 'Request' conform to the 'Sendable' protocol
11 | ///
12 | /// A request always contains a route and optionally contains a payload.
13 | struct Request {
| `- note: consider making struct 'Request' conform to the 'Sendable' protocol
14 | private enum RequestKeys {
15 | static let route: XPCDictionaryKey = const("__route")
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCServer.swift:395:70: warning: capture of 'self' with non-sendable type 'XPCServer' in a `@Sendable` closure; this is an error in the Swift 6 language mode
133 | /// - ``connectionDescriptor``
134 | /// - ``endpoint``
135 | public class XPCServer {
| `- note: class 'XPCServer' does not conform to the 'Sendable' protocol
136 |
137 | /// The queue used to run synchronous handlers associated with registered routes.
:
393 | var reply = handler.shouldCreateReply ? xpc_dictionary_create_reply(message) : nil
394 | do {
395 | try handler.handle(request: request, server: self, connection: connection, reply: &reply)
| `- warning: capture of 'self' with non-sendable type 'XPCServer' in a `@Sendable` closure; this is an error in the Swift 6 language mode
396 | try self.maybeSendReply(&reply, request: request, connection: connection)
397 | } catch {
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCServer.swift:393:33: warning: capture of 'handler' with non-sendable type 'any XPCHandlerSync' in an isolated closure; this is an error in the Swift 6 language mode
391 | self.handlerQueue.async {
392 | XPCServer.ClientIdentity.setForCurrentThread(connection: connection, message: message) {
393 | var reply = handler.shouldCreateReply ? xpc_dictionary_create_reply(message) : nil
| `- warning: capture of 'handler' with non-sendable type 'any XPCHandlerSync' in an isolated closure; this is an error in the Swift 6 language mode
394 | do {
395 | try handler.handle(request: request, server: self, connection: connection, reply: &reply)
:
703 | // MARK: sync handler function wrappers
704 |
705 | fileprivate protocol XPCHandlerSync: XPCHandler {
| `- note: protocol 'XPCHandlerSync' does not conform to the 'Sendable' protocol
706 | func handle(request: Request, server: XPCServer, connection: xpc_connection_t, reply: inout xpc_object_t?) throws
707 | }
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCServer.swift:393:89: warning: capture of 'message' with non-sendable type 'xpc_object_t' (aka 'any OS_xpc_object') in an isolated closure; this is an error in the Swift 6 language mode
391 | self.handlerQueue.async {
392 | XPCServer.ClientIdentity.setForCurrentThread(connection: connection, message: message) {
393 | var reply = handler.shouldCreateReply ? xpc_dictionary_create_reply(message) : nil
| `- warning: capture of 'message' with non-sendable type 'xpc_object_t' (aka 'any OS_xpc_object') in an isolated closure; this is an error in the Swift 6 language mode
394 | do {
395 | try handler.handle(request: request, server: self, connection: connection, reply: &reply)
XPC.OS_xpc_object:1:17: note: protocol 'OS_xpc_object' does not conform to the 'Sendable' protocol
1 | public protocol OS_xpc_object : NSObjectProtocol {
| `- note: protocol 'OS_xpc_object' does not conform to the 'Sendable' protocol
2 | }
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCServer.swift:395:53: warning: capture of 'request' with non-sendable type 'Request' in an isolated closure; this is an error in the Swift 6 language mode
393 | var reply = handler.shouldCreateReply ? xpc_dictionary_create_reply(message) : nil
394 | do {
395 | try handler.handle(request: request, server: self, connection: connection, reply: &reply)
| `- warning: capture of 'request' with non-sendable type 'Request' in an isolated closure; this is an error in the Swift 6 language mode
396 | try self.maybeSendReply(&reply, request: request, connection: connection)
397 | } catch {
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Request.swift:13:8: note: consider making struct 'Request' conform to the 'Sendable' protocol
11 | ///
12 | /// A request always contains a route and optionally contains a payload.
13 | struct Request {
| `- note: consider making struct 'Request' conform to the 'Sendable' protocol
14 | private enum RequestKeys {
15 | static let route: XPCDictionaryKey = const("__route")
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCServer.swift:395:70: warning: capture of 'self' with non-sendable type 'XPCServer' in an isolated closure; this is an error in the Swift 6 language mode
133 | /// - ``connectionDescriptor``
134 | /// - ``endpoint``
135 | public class XPCServer {
| `- note: class 'XPCServer' does not conform to the 'Sendable' protocol
136 |
137 | /// The queue used to run synchronous handlers associated with registered routes.
:
393 | var reply = handler.shouldCreateReply ? xpc_dictionary_create_reply(message) : nil
394 | do {
395 | try handler.handle(request: request, server: self, connection: connection, reply: &reply)
| `- warning: capture of 'self' with non-sendable type 'XPCServer' in an isolated closure; this is an error in the Swift 6 language mode
396 | try self.maybeSendReply(&reply, request: request, connection: connection)
397 | } catch {
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCServer.swift:395:88: warning: capture of 'connection' with non-sendable type 'xpc_connection_t' (aka 'any OS_xpc_object') in an isolated closure; this is an error in the Swift 6 language mode
393 | var reply = handler.shouldCreateReply ? xpc_dictionary_create_reply(message) : nil
394 | do {
395 | try handler.handle(request: request, server: self, connection: connection, reply: &reply)
| `- warning: capture of 'connection' with non-sendable type 'xpc_connection_t' (aka 'any OS_xpc_object') in an isolated closure; this is an error in the Swift 6 language mode
396 | try self.maybeSendReply(&reply, request: request, connection: connection)
397 | } catch {
XPC.OS_xpc_object:1:17: note: protocol 'OS_xpc_object' does not conform to the 'Sendable' protocol
1 | public protocol OS_xpc_object : NSObjectProtocol {
| `- note: protocol 'OS_xpc_object' does not conform to the 'Sendable' protocol
2 | }
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCServiceServer.swift:25:24: warning: static property 'service' is not concurrency-safe because non-'Sendable' type 'XPCServiceServer' may have shared mutable state; this is an error in the Swift 6 language mode
11 | ///
12 | /// In the case of this framework, the XPC service is expected to be communicated with by an `XPCServiceClient`.
13 | internal class XPCServiceServer: XPCServer {
| `- note: class 'XPCServiceServer' does not conform to the 'Sendable' protocol
14 |
15 | internal static var isThisProcessAnXPCService: Bool {
:
23 |
24 | /// The server itself, there can only ever be one per process as there is only ever one named connection that exists for an XPC service
25 | private static let service = XPCServiceServer(clientRequirement: .alwaysAccepting)
| |- warning: static property 'service' is not concurrency-safe because non-'Sendable' type 'XPCServiceServer' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'service' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
26 |
27 | /// Whether this server has been started.
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCServer.swift:907:21: warning: task-isolated value of type '() async -> Void' passed as a strongly transferred parameter; later accesses could race; this is an error in the Swift 6 language mode
905 | case .async(let handler):
906 | if #available(macOS 10.15, *) {
907 | Task {
| `- warning: task-isolated value of type '() async -> Void' passed as a strongly transferred parameter; later accesses could race; this is an error in the Swift 6 language mode
908 | await handler(error)
909 | }
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCServer.swift:417:17: warning: task-isolated value of type '() async -> ()' passed as a strongly transferred parameter; later accesses could race; this is an error in the Swift 6 language mode
415 | // consistent ordering of received events due to the asynchronous behavior of how they're sent by the
416 | // XPCClient. If an API user wants consistent ordering, that needs to be done at the application layer.
417 | Task {
| `- warning: task-isolated value of type '() async -> ()' passed as a strongly transferred parameter; later accesses could race; this is an error in the Swift 6 language mode
418 | var reply = handler.shouldCreateReply ? xpc_dictionary_create_reply(message) : nil
419 | do {
[29/50] Compiling SecureXPC XPCServiceServer.swift
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCMachServer.swift:89:24: warning: static property 'machServerCache' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
87 | /// This exists for correctness reasons, not as a performance optimization. Only one listener connection for a named service can exist simultaneously, so it's
88 | /// important this invariant be upheld when returning `XPCServer` instances.
89 | private static var machServerCache = [String : XPCMachServer]()
| |- warning: static property 'machServerCache' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
| |- note: convert 'machServerCache' to a 'let' constant to make 'Sendable' shared state immutable
| |- note: annotate 'machServerCache' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
90 |
91 | /// Prevents race conditions for creating and retrieving cached Mach servers
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/PackageInternalRoutes.swift:15:16: warning: static property 'noopRoute' is not concurrency-safe because non-'Sendable' type 'XPCRouteWithoutMessageWithoutReply' may have shared mutable state; this is an error in the Swift 6 language mode
13 | ///
14 | /// This is useful because the client can use this to know the server exists and get information about it such as its `SecCode`.
15 | static let noopRoute = XPCRoute.named("noop").packageInternal
| |- warning: static property 'noopRoute' is not concurrency-safe because non-'Sendable' type 'XPCRouteWithoutMessageWithoutReply' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'noopRoute' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
16 | }
17 |
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Routes.swift:224:15: note: consider making struct 'XPCRouteWithoutMessageWithoutReply' conform to the 'Sendable' protocol
222 | ///
223 | /// See ``XPCRoute`` for how to create a route.
224 | public struct XPCRouteWithoutMessageWithoutReply {
| `- note: consider making struct 'XPCRouteWithoutMessageWithoutReply' conform to the 'Sendable' protocol
225 | let route: XPCRoute
226 |
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCServer.swift:392:74: warning: capture of 'connection' with non-sendable type 'xpc_connection_t' (aka 'any OS_xpc_object') in a `@Sendable` closure; this is an error in the Swift 6 language mode
390 | // concurrent. (Although if an API user sets the target queue to be serial that's supported too.)
391 | self.handlerQueue.async {
392 | XPCServer.ClientIdentity.setForCurrentThread(connection: connection, message: message) {
| `- warning: capture of 'connection' with non-sendable type 'xpc_connection_t' (aka 'any OS_xpc_object') in a `@Sendable` closure; this is an error in the Swift 6 language mode
393 | var reply = handler.shouldCreateReply ? xpc_dictionary_create_reply(message) : nil
394 | do {
XPC.OS_xpc_object:1:17: note: protocol 'OS_xpc_object' does not conform to the 'Sendable' protocol
1 | public protocol OS_xpc_object : NSObjectProtocol {
| `- note: protocol 'OS_xpc_object' does not conform to the 'Sendable' protocol
2 | }
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCServer.swift:8:1: warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'XPC'
6 | //
7 |
8 | import Foundation
| `- warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'XPC'
9 |
10 | /// An XPC server to receive requests from and send responses to an ``XPCClient``.
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCServer.swift:392:95: warning: capture of 'message' with non-sendable type 'xpc_object_t' (aka 'any OS_xpc_object') in a `@Sendable` closure; this is an error in the Swift 6 language mode
390 | // concurrent. (Although if an API user sets the target queue to be serial that's supported too.)
391 | self.handlerQueue.async {
392 | XPCServer.ClientIdentity.setForCurrentThread(connection: connection, message: message) {
| `- warning: capture of 'message' with non-sendable type 'xpc_object_t' (aka 'any OS_xpc_object') in a `@Sendable` closure; this is an error in the Swift 6 language mode
393 | var reply = handler.shouldCreateReply ? xpc_dictionary_create_reply(message) : nil
394 | do {
XPC.OS_xpc_object:1:17: note: protocol 'OS_xpc_object' does not conform to the 'Sendable' protocol
1 | public protocol OS_xpc_object : NSObjectProtocol {
| `- note: protocol 'OS_xpc_object' does not conform to the 'Sendable' protocol
2 | }
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCServer.swift:393:33: warning: capture of 'handler' with non-sendable type 'any XPCHandlerSync' in a `@Sendable` closure; this is an error in the Swift 6 language mode
391 | self.handlerQueue.async {
392 | XPCServer.ClientIdentity.setForCurrentThread(connection: connection, message: message) {
393 | var reply = handler.shouldCreateReply ? xpc_dictionary_create_reply(message) : nil
| `- warning: capture of 'handler' with non-sendable type 'any XPCHandlerSync' in a `@Sendable` closure; this is an error in the Swift 6 language mode
394 | do {
395 | try handler.handle(request: request, server: self, connection: connection, reply: &reply)
:
703 | // MARK: sync handler function wrappers
704 |
705 | fileprivate protocol XPCHandlerSync: XPCHandler {
| `- note: protocol 'XPCHandlerSync' does not conform to the 'Sendable' protocol
706 | func handle(request: Request, server: XPCServer, connection: xpc_connection_t, reply: inout xpc_object_t?) throws
707 | }
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCServer.swift:395:53: warning: capture of 'request' with non-sendable type 'Request' in a `@Sendable` closure; this is an error in the Swift 6 language mode
393 | var reply = handler.shouldCreateReply ? xpc_dictionary_create_reply(message) : nil
394 | do {
395 | try handler.handle(request: request, server: self, connection: connection, reply: &reply)
| `- warning: capture of 'request' with non-sendable type 'Request' in a `@Sendable` closure; this is an error in the Swift 6 language mode
396 | try self.maybeSendReply(&reply, request: request, connection: connection)
397 | } catch {
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Request.swift:13:8: note: consider making struct 'Request' conform to the 'Sendable' protocol
11 | ///
12 | /// A request always contains a route and optionally contains a payload.
13 | struct Request {
| `- note: consider making struct 'Request' conform to the 'Sendable' protocol
14 | private enum RequestKeys {
15 | static let route: XPCDictionaryKey = const("__route")
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCServer.swift:395:70: warning: capture of 'self' with non-sendable type 'XPCServer' in a `@Sendable` closure; this is an error in the Swift 6 language mode
133 | /// - ``connectionDescriptor``
134 | /// - ``endpoint``
135 | public class XPCServer {
| `- note: class 'XPCServer' does not conform to the 'Sendable' protocol
136 |
137 | /// The queue used to run synchronous handlers associated with registered routes.
:
393 | var reply = handler.shouldCreateReply ? xpc_dictionary_create_reply(message) : nil
394 | do {
395 | try handler.handle(request: request, server: self, connection: connection, reply: &reply)
| `- warning: capture of 'self' with non-sendable type 'XPCServer' in a `@Sendable` closure; this is an error in the Swift 6 language mode
396 | try self.maybeSendReply(&reply, request: request, connection: connection)
397 | } catch {
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCServer.swift:393:33: warning: capture of 'handler' with non-sendable type 'any XPCHandlerSync' in an isolated closure; this is an error in the Swift 6 language mode
391 | self.handlerQueue.async {
392 | XPCServer.ClientIdentity.setForCurrentThread(connection: connection, message: message) {
393 | var reply = handler.shouldCreateReply ? xpc_dictionary_create_reply(message) : nil
| `- warning: capture of 'handler' with non-sendable type 'any XPCHandlerSync' in an isolated closure; this is an error in the Swift 6 language mode
394 | do {
395 | try handler.handle(request: request, server: self, connection: connection, reply: &reply)
:
703 | // MARK: sync handler function wrappers
704 |
705 | fileprivate protocol XPCHandlerSync: XPCHandler {
| `- note: protocol 'XPCHandlerSync' does not conform to the 'Sendable' protocol
706 | func handle(request: Request, server: XPCServer, connection: xpc_connection_t, reply: inout xpc_object_t?) throws
707 | }
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCServer.swift:393:89: warning: capture of 'message' with non-sendable type 'xpc_object_t' (aka 'any OS_xpc_object') in an isolated closure; this is an error in the Swift 6 language mode
391 | self.handlerQueue.async {
392 | XPCServer.ClientIdentity.setForCurrentThread(connection: connection, message: message) {
393 | var reply = handler.shouldCreateReply ? xpc_dictionary_create_reply(message) : nil
| `- warning: capture of 'message' with non-sendable type 'xpc_object_t' (aka 'any OS_xpc_object') in an isolated closure; this is an error in the Swift 6 language mode
394 | do {
395 | try handler.handle(request: request, server: self, connection: connection, reply: &reply)
XPC.OS_xpc_object:1:17: note: protocol 'OS_xpc_object' does not conform to the 'Sendable' protocol
1 | public protocol OS_xpc_object : NSObjectProtocol {
| `- note: protocol 'OS_xpc_object' does not conform to the 'Sendable' protocol
2 | }
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCServer.swift:395:53: warning: capture of 'request' with non-sendable type 'Request' in an isolated closure; this is an error in the Swift 6 language mode
393 | var reply = handler.shouldCreateReply ? xpc_dictionary_create_reply(message) : nil
394 | do {
395 | try handler.handle(request: request, server: self, connection: connection, reply: &reply)
| `- warning: capture of 'request' with non-sendable type 'Request' in an isolated closure; this is an error in the Swift 6 language mode
396 | try self.maybeSendReply(&reply, request: request, connection: connection)
397 | } catch {
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Request.swift:13:8: note: consider making struct 'Request' conform to the 'Sendable' protocol
11 | ///
12 | /// A request always contains a route and optionally contains a payload.
13 | struct Request {
| `- note: consider making struct 'Request' conform to the 'Sendable' protocol
14 | private enum RequestKeys {
15 | static let route: XPCDictionaryKey = const("__route")
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCServer.swift:395:70: warning: capture of 'self' with non-sendable type 'XPCServer' in an isolated closure; this is an error in the Swift 6 language mode
133 | /// - ``connectionDescriptor``
134 | /// - ``endpoint``
135 | public class XPCServer {
| `- note: class 'XPCServer' does not conform to the 'Sendable' protocol
136 |
137 | /// The queue used to run synchronous handlers associated with registered routes.
:
393 | var reply = handler.shouldCreateReply ? xpc_dictionary_create_reply(message) : nil
394 | do {
395 | try handler.handle(request: request, server: self, connection: connection, reply: &reply)
| `- warning: capture of 'self' with non-sendable type 'XPCServer' in an isolated closure; this is an error in the Swift 6 language mode
396 | try self.maybeSendReply(&reply, request: request, connection: connection)
397 | } catch {
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCServer.swift:395:88: warning: capture of 'connection' with non-sendable type 'xpc_connection_t' (aka 'any OS_xpc_object') in an isolated closure; this is an error in the Swift 6 language mode
393 | var reply = handler.shouldCreateReply ? xpc_dictionary_create_reply(message) : nil
394 | do {
395 | try handler.handle(request: request, server: self, connection: connection, reply: &reply)
| `- warning: capture of 'connection' with non-sendable type 'xpc_connection_t' (aka 'any OS_xpc_object') in an isolated closure; this is an error in the Swift 6 language mode
396 | try self.maybeSendReply(&reply, request: request, connection: connection)
397 | } catch {
XPC.OS_xpc_object:1:17: note: protocol 'OS_xpc_object' does not conform to the 'Sendable' protocol
1 | public protocol OS_xpc_object : NSObjectProtocol {
| `- note: protocol 'OS_xpc_object' does not conform to the 'Sendable' protocol
2 | }
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCServiceServer.swift:25:24: warning: static property 'service' is not concurrency-safe because non-'Sendable' type 'XPCServiceServer' may have shared mutable state; this is an error in the Swift 6 language mode
11 | ///
12 | /// In the case of this framework, the XPC service is expected to be communicated with by an `XPCServiceClient`.
13 | internal class XPCServiceServer: XPCServer {
| `- note: class 'XPCServiceServer' does not conform to the 'Sendable' protocol
14 |
15 | internal static var isThisProcessAnXPCService: Bool {
:
23 |
24 | /// The server itself, there can only ever be one per process as there is only ever one named connection that exists for an XPC service
25 | private static let service = XPCServiceServer(clientRequirement: .alwaysAccepting)
| |- warning: static property 'service' is not concurrency-safe because non-'Sendable' type 'XPCServiceServer' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'service' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
26 |
27 | /// Whether this server has been started.
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCServer.swift:907:21: warning: task-isolated value of type '() async -> Void' passed as a strongly transferred parameter; later accesses could race; this is an error in the Swift 6 language mode
905 | case .async(let handler):
906 | if #available(macOS 10.15, *) {
907 | Task {
| `- warning: task-isolated value of type '() async -> Void' passed as a strongly transferred parameter; later accesses could race; this is an error in the Swift 6 language mode
908 | await handler(error)
909 | }
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCServer.swift:417:17: warning: task-isolated value of type '() async -> ()' passed as a strongly transferred parameter; later accesses could race; this is an error in the Swift 6 language mode
415 | // consistent ordering of received events due to the asynchronous behavior of how they're sent by the
416 | // XPCClient. If an API user wants consistent ordering, that needs to be done at the application layer.
417 | Task {
| `- warning: task-isolated value of type '() async -> ()' passed as a strongly transferred parameter; later accesses could race; this is an error in the Swift 6 language mode
418 | var reply = handler.shouldCreateReply ? xpc_dictionary_create_reply(message) : nil
419 | do {
[30/50] Compiling SecureXPC SharedMemory.swift
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCMachServer.swift:89:24: warning: static property 'machServerCache' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
87 | /// This exists for correctness reasons, not as a performance optimization. Only one listener connection for a named service can exist simultaneously, so it's
88 | /// important this invariant be upheld when returning `XPCServer` instances.
89 | private static var machServerCache = [String : XPCMachServer]()
| |- warning: static property 'machServerCache' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
| |- note: convert 'machServerCache' to a 'let' constant to make 'Sendable' shared state immutable
| |- note: annotate 'machServerCache' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
90 |
91 | /// Prevents race conditions for creating and retrieving cached Mach servers
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/PackageInternalRoutes.swift:15:16: warning: static property 'noopRoute' is not concurrency-safe because non-'Sendable' type 'XPCRouteWithoutMessageWithoutReply' may have shared mutable state; this is an error in the Swift 6 language mode
13 | ///
14 | /// This is useful because the client can use this to know the server exists and get information about it such as its `SecCode`.
15 | static let noopRoute = XPCRoute.named("noop").packageInternal
| |- warning: static property 'noopRoute' is not concurrency-safe because non-'Sendable' type 'XPCRouteWithoutMessageWithoutReply' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'noopRoute' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
16 | }
17 |
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Routes.swift:224:15: note: consider making struct 'XPCRouteWithoutMessageWithoutReply' conform to the 'Sendable' protocol
222 | ///
223 | /// See ``XPCRoute`` for how to create a route.
224 | public struct XPCRouteWithoutMessageWithoutReply {
| `- note: consider making struct 'XPCRouteWithoutMessageWithoutReply' conform to the 'Sendable' protocol
225 | let route: XPCRoute
226 |
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCServer.swift:392:74: warning: capture of 'connection' with non-sendable type 'xpc_connection_t' (aka 'any OS_xpc_object') in a `@Sendable` closure; this is an error in the Swift 6 language mode
390 | // concurrent. (Although if an API user sets the target queue to be serial that's supported too.)
391 | self.handlerQueue.async {
392 | XPCServer.ClientIdentity.setForCurrentThread(connection: connection, message: message) {
| `- warning: capture of 'connection' with non-sendable type 'xpc_connection_t' (aka 'any OS_xpc_object') in a `@Sendable` closure; this is an error in the Swift 6 language mode
393 | var reply = handler.shouldCreateReply ? xpc_dictionary_create_reply(message) : nil
394 | do {
XPC.OS_xpc_object:1:17: note: protocol 'OS_xpc_object' does not conform to the 'Sendable' protocol
1 | public protocol OS_xpc_object : NSObjectProtocol {
| `- note: protocol 'OS_xpc_object' does not conform to the 'Sendable' protocol
2 | }
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCServer.swift:8:1: warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'XPC'
6 | //
7 |
8 | import Foundation
| `- warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'XPC'
9 |
10 | /// An XPC server to receive requests from and send responses to an ``XPCClient``.
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCServer.swift:392:95: warning: capture of 'message' with non-sendable type 'xpc_object_t' (aka 'any OS_xpc_object') in a `@Sendable` closure; this is an error in the Swift 6 language mode
390 | // concurrent. (Although if an API user sets the target queue to be serial that's supported too.)
391 | self.handlerQueue.async {
392 | XPCServer.ClientIdentity.setForCurrentThread(connection: connection, message: message) {
| `- warning: capture of 'message' with non-sendable type 'xpc_object_t' (aka 'any OS_xpc_object') in a `@Sendable` closure; this is an error in the Swift 6 language mode
393 | var reply = handler.shouldCreateReply ? xpc_dictionary_create_reply(message) : nil
394 | do {
XPC.OS_xpc_object:1:17: note: protocol 'OS_xpc_object' does not conform to the 'Sendable' protocol
1 | public protocol OS_xpc_object : NSObjectProtocol {
| `- note: protocol 'OS_xpc_object' does not conform to the 'Sendable' protocol
2 | }
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCServer.swift:393:33: warning: capture of 'handler' with non-sendable type 'any XPCHandlerSync' in a `@Sendable` closure; this is an error in the Swift 6 language mode
391 | self.handlerQueue.async {
392 | XPCServer.ClientIdentity.setForCurrentThread(connection: connection, message: message) {
393 | var reply = handler.shouldCreateReply ? xpc_dictionary_create_reply(message) : nil
| `- warning: capture of 'handler' with non-sendable type 'any XPCHandlerSync' in a `@Sendable` closure; this is an error in the Swift 6 language mode
394 | do {
395 | try handler.handle(request: request, server: self, connection: connection, reply: &reply)
:
703 | // MARK: sync handler function wrappers
704 |
705 | fileprivate protocol XPCHandlerSync: XPCHandler {
| `- note: protocol 'XPCHandlerSync' does not conform to the 'Sendable' protocol
706 | func handle(request: Request, server: XPCServer, connection: xpc_connection_t, reply: inout xpc_object_t?) throws
707 | }
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCServer.swift:395:53: warning: capture of 'request' with non-sendable type 'Request' in a `@Sendable` closure; this is an error in the Swift 6 language mode
393 | var reply = handler.shouldCreateReply ? xpc_dictionary_create_reply(message) : nil
394 | do {
395 | try handler.handle(request: request, server: self, connection: connection, reply: &reply)
| `- warning: capture of 'request' with non-sendable type 'Request' in a `@Sendable` closure; this is an error in the Swift 6 language mode
396 | try self.maybeSendReply(&reply, request: request, connection: connection)
397 | } catch {
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Request.swift:13:8: note: consider making struct 'Request' conform to the 'Sendable' protocol
11 | ///
12 | /// A request always contains a route and optionally contains a payload.
13 | struct Request {
| `- note: consider making struct 'Request' conform to the 'Sendable' protocol
14 | private enum RequestKeys {
15 | static let route: XPCDictionaryKey = const("__route")
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCServer.swift:395:70: warning: capture of 'self' with non-sendable type 'XPCServer' in a `@Sendable` closure; this is an error in the Swift 6 language mode
133 | /// - ``connectionDescriptor``
134 | /// - ``endpoint``
135 | public class XPCServer {
| `- note: class 'XPCServer' does not conform to the 'Sendable' protocol
136 |
137 | /// The queue used to run synchronous handlers associated with registered routes.
:
393 | var reply = handler.shouldCreateReply ? xpc_dictionary_create_reply(message) : nil
394 | do {
395 | try handler.handle(request: request, server: self, connection: connection, reply: &reply)
| `- warning: capture of 'self' with non-sendable type 'XPCServer' in a `@Sendable` closure; this is an error in the Swift 6 language mode
396 | try self.maybeSendReply(&reply, request: request, connection: connection)
397 | } catch {
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCServer.swift:393:33: warning: capture of 'handler' with non-sendable type 'any XPCHandlerSync' in an isolated closure; this is an error in the Swift 6 language mode
391 | self.handlerQueue.async {
392 | XPCServer.ClientIdentity.setForCurrentThread(connection: connection, message: message) {
393 | var reply = handler.shouldCreateReply ? xpc_dictionary_create_reply(message) : nil
| `- warning: capture of 'handler' with non-sendable type 'any XPCHandlerSync' in an isolated closure; this is an error in the Swift 6 language mode
394 | do {
395 | try handler.handle(request: request, server: self, connection: connection, reply: &reply)
:
703 | // MARK: sync handler function wrappers
704 |
705 | fileprivate protocol XPCHandlerSync: XPCHandler {
| `- note: protocol 'XPCHandlerSync' does not conform to the 'Sendable' protocol
706 | func handle(request: Request, server: XPCServer, connection: xpc_connection_t, reply: inout xpc_object_t?) throws
707 | }
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCServer.swift:393:89: warning: capture of 'message' with non-sendable type 'xpc_object_t' (aka 'any OS_xpc_object') in an isolated closure; this is an error in the Swift 6 language mode
391 | self.handlerQueue.async {
392 | XPCServer.ClientIdentity.setForCurrentThread(connection: connection, message: message) {
393 | var reply = handler.shouldCreateReply ? xpc_dictionary_create_reply(message) : nil
| `- warning: capture of 'message' with non-sendable type 'xpc_object_t' (aka 'any OS_xpc_object') in an isolated closure; this is an error in the Swift 6 language mode
394 | do {
395 | try handler.handle(request: request, server: self, connection: connection, reply: &reply)
XPC.OS_xpc_object:1:17: note: protocol 'OS_xpc_object' does not conform to the 'Sendable' protocol
1 | public protocol OS_xpc_object : NSObjectProtocol {
| `- note: protocol 'OS_xpc_object' does not conform to the 'Sendable' protocol
2 | }
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCServer.swift:395:53: warning: capture of 'request' with non-sendable type 'Request' in an isolated closure; this is an error in the Swift 6 language mode
393 | var reply = handler.shouldCreateReply ? xpc_dictionary_create_reply(message) : nil
394 | do {
395 | try handler.handle(request: request, server: self, connection: connection, reply: &reply)
| `- warning: capture of 'request' with non-sendable type 'Request' in an isolated closure; this is an error in the Swift 6 language mode
396 | try self.maybeSendReply(&reply, request: request, connection: connection)
397 | } catch {
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Request.swift:13:8: note: consider making struct 'Request' conform to the 'Sendable' protocol
11 | ///
12 | /// A request always contains a route and optionally contains a payload.
13 | struct Request {
| `- note: consider making struct 'Request' conform to the 'Sendable' protocol
14 | private enum RequestKeys {
15 | static let route: XPCDictionaryKey = const("__route")
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCServer.swift:395:70: warning: capture of 'self' with non-sendable type 'XPCServer' in an isolated closure; this is an error in the Swift 6 language mode
133 | /// - ``connectionDescriptor``
134 | /// - ``endpoint``
135 | public class XPCServer {
| `- note: class 'XPCServer' does not conform to the 'Sendable' protocol
136 |
137 | /// The queue used to run synchronous handlers associated with registered routes.
:
393 | var reply = handler.shouldCreateReply ? xpc_dictionary_create_reply(message) : nil
394 | do {
395 | try handler.handle(request: request, server: self, connection: connection, reply: &reply)
| `- warning: capture of 'self' with non-sendable type 'XPCServer' in an isolated closure; this is an error in the Swift 6 language mode
396 | try self.maybeSendReply(&reply, request: request, connection: connection)
397 | } catch {
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCServer.swift:395:88: warning: capture of 'connection' with non-sendable type 'xpc_connection_t' (aka 'any OS_xpc_object') in an isolated closure; this is an error in the Swift 6 language mode
393 | var reply = handler.shouldCreateReply ? xpc_dictionary_create_reply(message) : nil
394 | do {
395 | try handler.handle(request: request, server: self, connection: connection, reply: &reply)
| `- warning: capture of 'connection' with non-sendable type 'xpc_connection_t' (aka 'any OS_xpc_object') in an isolated closure; this is an error in the Swift 6 language mode
396 | try self.maybeSendReply(&reply, request: request, connection: connection)
397 | } catch {
XPC.OS_xpc_object:1:17: note: protocol 'OS_xpc_object' does not conform to the 'Sendable' protocol
1 | public protocol OS_xpc_object : NSObjectProtocol {
| `- note: protocol 'OS_xpc_object' does not conform to the 'Sendable' protocol
2 | }
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCServiceServer.swift:25:24: warning: static property 'service' is not concurrency-safe because non-'Sendable' type 'XPCServiceServer' may have shared mutable state; this is an error in the Swift 6 language mode
11 | ///
12 | /// In the case of this framework, the XPC service is expected to be communicated with by an `XPCServiceClient`.
13 | internal class XPCServiceServer: XPCServer {
| `- note: class 'XPCServiceServer' does not conform to the 'Sendable' protocol
14 |
15 | internal static var isThisProcessAnXPCService: Bool {
:
23 |
24 | /// The server itself, there can only ever be one per process as there is only ever one named connection that exists for an XPC service
25 | private static let service = XPCServiceServer(clientRequirement: .alwaysAccepting)
| |- warning: static property 'service' is not concurrency-safe because non-'Sendable' type 'XPCServiceServer' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'service' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
26 |
27 | /// Whether this server has been started.
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCServer.swift:907:21: warning: task-isolated value of type '() async -> Void' passed as a strongly transferred parameter; later accesses could race; this is an error in the Swift 6 language mode
905 | case .async(let handler):
906 | if #available(macOS 10.15, *) {
907 | Task {
| `- warning: task-isolated value of type '() async -> Void' passed as a strongly transferred parameter; later accesses could race; this is an error in the Swift 6 language mode
908 | await handler(error)
909 | }
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/XPCServer.swift:417:17: warning: task-isolated value of type '() async -> ()' passed as a strongly transferred parameter; later accesses could race; this is an error in the Swift 6 language mode
415 | // consistent ordering of received events due to the asynchronous behavior of how they're sent by the
416 | // XPCClient. If an API user wants consistent ordering, that needs to be done at the application layer.
417 | Task {
| `- warning: task-isolated value of type '() async -> ()' passed as a strongly transferred parameter; later accesses could race; this is an error in the Swift 6 language mode
418 | var reply = handler.shouldCreateReply ? xpc_dictionary_create_reply(message) : nil
419 | do {
[31/50] Compiling SecureXPC Transformation functions.swift
<unknown>:0: note: a function type must be marked '@Sendable' to conform to 'Sendable'
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/XPC Coders/XPCDecoder/Transformation functions.swift:76:14: warning: let 'floatTransform' is not concurrency-safe because non-'Sendable' type '(xpc_object_t) -> Float' (aka '(any OS_xpc_object) -> Float') may have shared mutable state; this is an error in the Swift 6 language mode
74 | }
75 |
76 | internal let floatTransform = { (object: xpc_object_t) -> Float in
| |- warning: let 'floatTransform' is not concurrency-safe because non-'Sendable' type '(xpc_object_t) -> Float' (aka '(any OS_xpc_object) -> Float') may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'floatTransform' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
77 | // Double.signalingNaN is not converted to Float.signalingNaN when calling Float(...) with a Double so this needs
78 | // to be done manually
[32/50] Compiling SecureXPC XPCDecoder.swift
<unknown>:0: note: a function type must be marked '@Sendable' to conform to 'Sendable'
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/XPC Coders/XPCDecoder/Transformation functions.swift:76:14: warning: let 'floatTransform' is not concurrency-safe because non-'Sendable' type '(xpc_object_t) -> Float' (aka '(any OS_xpc_object) -> Float') may have shared mutable state; this is an error in the Swift 6 language mode
74 | }
75 |
76 | internal let floatTransform = { (object: xpc_object_t) -> Float in
| |- warning: let 'floatTransform' is not concurrency-safe because non-'Sendable' type '(xpc_object_t) -> Float' (aka '(any OS_xpc_object) -> Float') may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'floatTransform' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
77 | // Double.signalingNaN is not converted to Float.signalingNaN when calling Float(...) with a Double so this needs
78 | // to be done manually
[33/50] Compiling SecureXPC XPCDecoderImpl.swift
<unknown>:0: note: a function type must be marked '@Sendable' to conform to 'Sendable'
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/XPC Coders/XPCDecoder/Transformation functions.swift:76:14: warning: let 'floatTransform' is not concurrency-safe because non-'Sendable' type '(xpc_object_t) -> Float' (aka '(any OS_xpc_object) -> Float') may have shared mutable state; this is an error in the Swift 6 language mode
74 | }
75 |
76 | internal let floatTransform = { (object: xpc_object_t) -> Float in
| |- warning: let 'floatTransform' is not concurrency-safe because non-'Sendable' type '(xpc_object_t) -> Float' (aka '(any OS_xpc_object) -> Float') may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'floatTransform' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
77 | // Double.signalingNaN is not converted to Float.signalingNaN when calling Float(...) with a Double so this needs
78 | // to be done manually
[34/50] Compiling SecureXPC XPCKeyedDecodingContainer.swift
<unknown>:0: note: a function type must be marked '@Sendable' to conform to 'Sendable'
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/XPC Coders/XPCDecoder/Transformation functions.swift:76:14: warning: let 'floatTransform' is not concurrency-safe because non-'Sendable' type '(xpc_object_t) -> Float' (aka '(any OS_xpc_object) -> Float') may have shared mutable state; this is an error in the Swift 6 language mode
74 | }
75 |
76 | internal let floatTransform = { (object: xpc_object_t) -> Float in
| |- warning: let 'floatTransform' is not concurrency-safe because non-'Sendable' type '(xpc_object_t) -> Float' (aka '(any OS_xpc_object) -> Float') may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'floatTransform' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
77 | // Double.signalingNaN is not converted to Float.signalingNaN when calling Float(...) with a Double so this needs
78 | // to be done manually
[35/50] Compiling SecureXPC XPCSingleValueDecodingContainer.swift
<unknown>:0: note: a function type must be marked '@Sendable' to conform to 'Sendable'
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/XPC Coders/XPCDecoder/Transformation functions.swift:76:14: warning: let 'floatTransform' is not concurrency-safe because non-'Sendable' type '(xpc_object_t) -> Float' (aka '(any OS_xpc_object) -> Float') may have shared mutable state; this is an error in the Swift 6 language mode
74 | }
75 |
76 | internal let floatTransform = { (object: xpc_object_t) -> Float in
| |- warning: let 'floatTransform' is not concurrency-safe because non-'Sendable' type '(xpc_object_t) -> Float' (aka '(any OS_xpc_object) -> Float') may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'floatTransform' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
77 | // Double.signalingNaN is not converted to Float.signalingNaN when calling Float(...) with a Double so this needs
78 | // to be done manually
[36/50] Compiling SecureXPC SequentialResult.swift
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/SequentialResultProvider.swift:125:16: warning: capture of 'self' with non-sendable type 'SequentialResultProvider<S>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
35 | /// - ``failure(error:)``
36 | /// - ``isFinished``
37 | public class SequentialResultProvider<S: Encodable> {
| `- note: generic class 'SequentialResultProvider' does not conform to the 'Sendable' protocol
38 | private let request: Request
39 | private weak var server: XPCServer?
:
123 | private func sendResponse(isFinished: Bool, encodingWork: @escaping (inout xpc_object_t) throws -> Void) {
124 | self.serialQueue.async {
125 | if self.isFinished {
| `- warning: capture of 'self' with non-sendable type 'SequentialResultProvider<S>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
126 | self.sendToServerErrorHandler(XPCError.sequenceFinished)
127 | return
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/SequentialResultProvider.swift:142:25: warning: capture of 'encodingWork' with non-sendable type '(inout xpc_object_t) throws -> Void' (aka '(inout any OS_xpc_object) throws -> ()') in a `@Sendable` closure; this is an error in the Swift 6 language mode
140 |
141 | do {
142 | try encodingWork(&response)
| |- warning: capture of 'encodingWork' with non-sendable type '(inout xpc_object_t) throws -> Void' (aka '(inout any OS_xpc_object) throws -> ()') in a `@Sendable` closure; this is an error in the Swift 6 language mode
| `- note: a function type must be marked '@Sendable' to conform to 'Sendable'
143 | xpc_connection_send_message(connection, response)
144 | } catch {
macro expansion @TaskLocal:1:20: warning: static property '$currentForTask' is not concurrency-safe because non-'Sendable' type 'TaskLocal<XPCServer.ClientIdentity?>' may have shared mutable state; this is an error in the Swift 6 language mode
`- /Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/ClientIdentity.swift:34:69: note: expanded code originates here
19 | /// - ``effectiveUserID``
20 | /// - ``effectiveGroupID``
21 | class ClientIdentity {
| `- note: class 'ClientIdentity' does not conform to the 'Sendable' protocol
22 | private let connection: xpc_connection_t
23 | private let message: xpc_object_t
:
32 | @available(macOS 10.15.0, *)
33 | @TaskLocal
34 | private static var currentForTask: XPCServer.ClientIdentity?
+--- macro expansion @TaskLocal ------------------------------------
|1 | private static let $currentForTask: TaskLocal<XPCServer.ClientIdentity?> = TaskLocal(wrappedValue: nil)
| | |- warning: static property '$currentForTask' is not concurrency-safe because non-'Sendable' type 'TaskLocal<XPCServer.ClientIdentity?>' may have shared mutable state; this is an error in the Swift 6 language mode
| | |- note: annotate '$currentForTask' with '@MainActor' if property should only be accessed from the main actor
| | `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
+-------------------------------------------------------------------
35 |
36 | @available(macOS 10.15.0, *)
macro expansion @TaskLocal:1:20: warning: type 'XPCServer.ClientIdentity' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
`- /Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/ClientIdentity.swift:34:69: note: expanded code originates here
19 | /// - ``effectiveUserID``
20 | /// - ``effectiveGroupID``
21 | class ClientIdentity {
| `- note: class 'ClientIdentity' does not conform to the 'Sendable' protocol
22 | private let connection: xpc_connection_t
23 | private let message: xpc_object_t
:
32 | @available(macOS 10.15.0, *)
33 | @TaskLocal
34 | private static var currentForTask: XPCServer.ClientIdentity?
+--- macro expansion @TaskLocal ------------------------------------
|1 | private static let $currentForTask: TaskLocal<XPCServer.ClientIdentity?> = TaskLocal(wrappedValue: nil)
| | `- warning: type 'XPCServer.ClientIdentity' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
+-------------------------------------------------------------------
35 |
36 | @available(macOS 10.15.0, *)
macro expansion @TaskLocal:1:76: warning: type 'XPCServer.ClientIdentity' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
`- /Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/ClientIdentity.swift:34:69: note: expanded code originates here
19 | /// - ``effectiveUserID``
20 | /// - ``effectiveGroupID``
21 | class ClientIdentity {
| `- note: class 'ClientIdentity' does not conform to the 'Sendable' protocol
22 | private let connection: xpc_connection_t
23 | private let message: xpc_object_t
:
32 | @available(macOS 10.15.0, *)
33 | @TaskLocal
34 | private static var currentForTask: XPCServer.ClientIdentity?
+--- macro expansion @TaskLocal ------------------------------------
|1 | private static let $currentForTask: TaskLocal<XPCServer.ClientIdentity?> = TaskLocal(wrappedValue: nil)
| | `- warning: type 'XPCServer.ClientIdentity' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
+-------------------------------------------------------------------
35 |
36 | @available(macOS 10.15.0, *)
macro expansion @TaskLocal:1:76: warning: type 'XPCServer.ClientIdentity' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
`- /Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/ClientIdentity.swift:34:69: note: expanded code originates here
19 | /// - ``effectiveUserID``
20 | /// - ``effectiveGroupID``
21 | class ClientIdentity {
| `- note: class 'ClientIdentity' does not conform to the 'Sendable' protocol
22 | private let connection: xpc_connection_t
23 | private let message: xpc_object_t
:
32 | @available(macOS 10.15.0, *)
33 | @TaskLocal
34 | private static var currentForTask: XPCServer.ClientIdentity?
+--- macro expansion @TaskLocal ------------------------------------
|1 | private static let $currentForTask: TaskLocal<XPCServer.ClientIdentity?> = TaskLocal(wrappedValue: nil)
| | `- warning: type 'XPCServer.ClientIdentity' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
+-------------------------------------------------------------------
35 |
36 | @available(macOS 10.15.0, *)
macro expansion @TaskLocal:3:25: warning: type 'XPCServer.ClientIdentity' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
`- /Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/ClientIdentity.swift:34:69: note: expanded code originates here
19 | /// - ``effectiveUserID``
20 | /// - ``effectiveGroupID``
21 | class ClientIdentity {
| `- note: class 'ClientIdentity' does not conform to the 'Sendable' protocol
22 | private let connection: xpc_connection_t
23 | private let message: xpc_object_t
:
32 | @available(macOS 10.15.0, *)
33 | @TaskLocal
34 | private static var currentForTask: XPCServer.ClientIdentity?
+--- macro expansion @TaskLocal ------------------------------------
|1 | {
|2 | get {
|3 | $currentForTask.get()
| | `- warning: type 'XPCServer.ClientIdentity' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
|4 | }
|5 | }
+-------------------------------------------------------------------
35 |
36 | @available(macOS 10.15.0, *)
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/ClientIdentity.swift:42:33: warning: type 'XPCServer.ClientIdentity' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
19 | /// - ``effectiveUserID``
20 | /// - ``effectiveGroupID``
21 | class ClientIdentity {
| `- note: class 'ClientIdentity' does not conform to the 'Sendable' protocol
22 | private let connection: xpc_connection_t
23 | private let message: xpc_object_t
:
40 | operation: () throws -> Task<Success, Failure>
41 | ) rethrows -> Task<Success, Failure> {
42 | try $currentForTask.withValue(XPCServer.ClientIdentity(connection: connection, message: message)) {
| `- warning: type 'XPCServer.ClientIdentity' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
43 | try operation()
44 | }
[37/50] Compiling SecureXPC SequentialResultProvider.swift
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/SequentialResultProvider.swift:125:16: warning: capture of 'self' with non-sendable type 'SequentialResultProvider<S>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
35 | /// - ``failure(error:)``
36 | /// - ``isFinished``
37 | public class SequentialResultProvider<S: Encodable> {
| `- note: generic class 'SequentialResultProvider' does not conform to the 'Sendable' protocol
38 | private let request: Request
39 | private weak var server: XPCServer?
:
123 | private func sendResponse(isFinished: Bool, encodingWork: @escaping (inout xpc_object_t) throws -> Void) {
124 | self.serialQueue.async {
125 | if self.isFinished {
| `- warning: capture of 'self' with non-sendable type 'SequentialResultProvider<S>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
126 | self.sendToServerErrorHandler(XPCError.sequenceFinished)
127 | return
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/SequentialResultProvider.swift:142:25: warning: capture of 'encodingWork' with non-sendable type '(inout xpc_object_t) throws -> Void' (aka '(inout any OS_xpc_object) throws -> ()') in a `@Sendable` closure; this is an error in the Swift 6 language mode
140 |
141 | do {
142 | try encodingWork(&response)
| |- warning: capture of 'encodingWork' with non-sendable type '(inout xpc_object_t) throws -> Void' (aka '(inout any OS_xpc_object) throws -> ()') in a `@Sendable` closure; this is an error in the Swift 6 language mode
| `- note: a function type must be marked '@Sendable' to conform to 'Sendable'
143 | xpc_connection_send_message(connection, response)
144 | } catch {
macro expansion @TaskLocal:1:20: warning: static property '$currentForTask' is not concurrency-safe because non-'Sendable' type 'TaskLocal<XPCServer.ClientIdentity?>' may have shared mutable state; this is an error in the Swift 6 language mode
`- /Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/ClientIdentity.swift:34:69: note: expanded code originates here
19 | /// - ``effectiveUserID``
20 | /// - ``effectiveGroupID``
21 | class ClientIdentity {
| `- note: class 'ClientIdentity' does not conform to the 'Sendable' protocol
22 | private let connection: xpc_connection_t
23 | private let message: xpc_object_t
:
32 | @available(macOS 10.15.0, *)
33 | @TaskLocal
34 | private static var currentForTask: XPCServer.ClientIdentity?
+--- macro expansion @TaskLocal ------------------------------------
|1 | private static let $currentForTask: TaskLocal<XPCServer.ClientIdentity?> = TaskLocal(wrappedValue: nil)
| | |- warning: static property '$currentForTask' is not concurrency-safe because non-'Sendable' type 'TaskLocal<XPCServer.ClientIdentity?>' may have shared mutable state; this is an error in the Swift 6 language mode
| | |- note: annotate '$currentForTask' with '@MainActor' if property should only be accessed from the main actor
| | `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
+-------------------------------------------------------------------
35 |
36 | @available(macOS 10.15.0, *)
macro expansion @TaskLocal:1:20: warning: type 'XPCServer.ClientIdentity' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
`- /Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/ClientIdentity.swift:34:69: note: expanded code originates here
19 | /// - ``effectiveUserID``
20 | /// - ``effectiveGroupID``
21 | class ClientIdentity {
| `- note: class 'ClientIdentity' does not conform to the 'Sendable' protocol
22 | private let connection: xpc_connection_t
23 | private let message: xpc_object_t
:
32 | @available(macOS 10.15.0, *)
33 | @TaskLocal
34 | private static var currentForTask: XPCServer.ClientIdentity?
+--- macro expansion @TaskLocal ------------------------------------
|1 | private static let $currentForTask: TaskLocal<XPCServer.ClientIdentity?> = TaskLocal(wrappedValue: nil)
| | `- warning: type 'XPCServer.ClientIdentity' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
+-------------------------------------------------------------------
35 |
36 | @available(macOS 10.15.0, *)
macro expansion @TaskLocal:1:76: warning: type 'XPCServer.ClientIdentity' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
`- /Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/ClientIdentity.swift:34:69: note: expanded code originates here
19 | /// - ``effectiveUserID``
20 | /// - ``effectiveGroupID``
21 | class ClientIdentity {
| `- note: class 'ClientIdentity' does not conform to the 'Sendable' protocol
22 | private let connection: xpc_connection_t
23 | private let message: xpc_object_t
:
32 | @available(macOS 10.15.0, *)
33 | @TaskLocal
34 | private static var currentForTask: XPCServer.ClientIdentity?
+--- macro expansion @TaskLocal ------------------------------------
|1 | private static let $currentForTask: TaskLocal<XPCServer.ClientIdentity?> = TaskLocal(wrappedValue: nil)
| | `- warning: type 'XPCServer.ClientIdentity' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
+-------------------------------------------------------------------
35 |
36 | @available(macOS 10.15.0, *)
macro expansion @TaskLocal:1:76: warning: type 'XPCServer.ClientIdentity' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
`- /Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/ClientIdentity.swift:34:69: note: expanded code originates here
19 | /// - ``effectiveUserID``
20 | /// - ``effectiveGroupID``
21 | class ClientIdentity {
| `- note: class 'ClientIdentity' does not conform to the 'Sendable' protocol
22 | private let connection: xpc_connection_t
23 | private let message: xpc_object_t
:
32 | @available(macOS 10.15.0, *)
33 | @TaskLocal
34 | private static var currentForTask: XPCServer.ClientIdentity?
+--- macro expansion @TaskLocal ------------------------------------
|1 | private static let $currentForTask: TaskLocal<XPCServer.ClientIdentity?> = TaskLocal(wrappedValue: nil)
| | `- warning: type 'XPCServer.ClientIdentity' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
+-------------------------------------------------------------------
35 |
36 | @available(macOS 10.15.0, *)
macro expansion @TaskLocal:3:25: warning: type 'XPCServer.ClientIdentity' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
`- /Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/ClientIdentity.swift:34:69: note: expanded code originates here
19 | /// - ``effectiveUserID``
20 | /// - ``effectiveGroupID``
21 | class ClientIdentity {
| `- note: class 'ClientIdentity' does not conform to the 'Sendable' protocol
22 | private let connection: xpc_connection_t
23 | private let message: xpc_object_t
:
32 | @available(macOS 10.15.0, *)
33 | @TaskLocal
34 | private static var currentForTask: XPCServer.ClientIdentity?
+--- macro expansion @TaskLocal ------------------------------------
|1 | {
|2 | get {
|3 | $currentForTask.get()
| | `- warning: type 'XPCServer.ClientIdentity' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
|4 | }
|5 | }
+-------------------------------------------------------------------
35 |
36 | @available(macOS 10.15.0, *)
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/ClientIdentity.swift:42:33: warning: type 'XPCServer.ClientIdentity' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
19 | /// - ``effectiveUserID``
20 | /// - ``effectiveGroupID``
21 | class ClientIdentity {
| `- note: class 'ClientIdentity' does not conform to the 'Sendable' protocol
22 | private let connection: xpc_connection_t
23 | private let message: xpc_object_t
:
40 | operation: () throws -> Task<Success, Failure>
41 | ) rethrows -> Task<Success, Failure> {
42 | try $currentForTask.withValue(XPCServer.ClientIdentity(connection: connection, message: message)) {
| `- warning: type 'XPCServer.ClientIdentity' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
43 | try operation()
44 | }
[38/50] Compiling SecureXPC ClientIdentity.swift
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/SequentialResultProvider.swift:125:16: warning: capture of 'self' with non-sendable type 'SequentialResultProvider<S>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
35 | /// - ``failure(error:)``
36 | /// - ``isFinished``
37 | public class SequentialResultProvider<S: Encodable> {
| `- note: generic class 'SequentialResultProvider' does not conform to the 'Sendable' protocol
38 | private let request: Request
39 | private weak var server: XPCServer?
:
123 | private func sendResponse(isFinished: Bool, encodingWork: @escaping (inout xpc_object_t) throws -> Void) {
124 | self.serialQueue.async {
125 | if self.isFinished {
| `- warning: capture of 'self' with non-sendable type 'SequentialResultProvider<S>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
126 | self.sendToServerErrorHandler(XPCError.sequenceFinished)
127 | return
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/SequentialResultProvider.swift:142:25: warning: capture of 'encodingWork' with non-sendable type '(inout xpc_object_t) throws -> Void' (aka '(inout any OS_xpc_object) throws -> ()') in a `@Sendable` closure; this is an error in the Swift 6 language mode
140 |
141 | do {
142 | try encodingWork(&response)
| |- warning: capture of 'encodingWork' with non-sendable type '(inout xpc_object_t) throws -> Void' (aka '(inout any OS_xpc_object) throws -> ()') in a `@Sendable` closure; this is an error in the Swift 6 language mode
| `- note: a function type must be marked '@Sendable' to conform to 'Sendable'
143 | xpc_connection_send_message(connection, response)
144 | } catch {
macro expansion @TaskLocal:1:20: warning: static property '$currentForTask' is not concurrency-safe because non-'Sendable' type 'TaskLocal<XPCServer.ClientIdentity?>' may have shared mutable state; this is an error in the Swift 6 language mode
`- /Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/ClientIdentity.swift:34:69: note: expanded code originates here
19 | /// - ``effectiveUserID``
20 | /// - ``effectiveGroupID``
21 | class ClientIdentity {
| `- note: class 'ClientIdentity' does not conform to the 'Sendable' protocol
22 | private let connection: xpc_connection_t
23 | private let message: xpc_object_t
:
32 | @available(macOS 10.15.0, *)
33 | @TaskLocal
34 | private static var currentForTask: XPCServer.ClientIdentity?
+--- macro expansion @TaskLocal ------------------------------------
|1 | private static let $currentForTask: TaskLocal<XPCServer.ClientIdentity?> = TaskLocal(wrappedValue: nil)
| | |- warning: static property '$currentForTask' is not concurrency-safe because non-'Sendable' type 'TaskLocal<XPCServer.ClientIdentity?>' may have shared mutable state; this is an error in the Swift 6 language mode
| | |- note: annotate '$currentForTask' with '@MainActor' if property should only be accessed from the main actor
| | `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
+-------------------------------------------------------------------
35 |
36 | @available(macOS 10.15.0, *)
macro expansion @TaskLocal:1:20: warning: type 'XPCServer.ClientIdentity' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
`- /Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/ClientIdentity.swift:34:69: note: expanded code originates here
19 | /// - ``effectiveUserID``
20 | /// - ``effectiveGroupID``
21 | class ClientIdentity {
| `- note: class 'ClientIdentity' does not conform to the 'Sendable' protocol
22 | private let connection: xpc_connection_t
23 | private let message: xpc_object_t
:
32 | @available(macOS 10.15.0, *)
33 | @TaskLocal
34 | private static var currentForTask: XPCServer.ClientIdentity?
+--- macro expansion @TaskLocal ------------------------------------
|1 | private static let $currentForTask: TaskLocal<XPCServer.ClientIdentity?> = TaskLocal(wrappedValue: nil)
| | `- warning: type 'XPCServer.ClientIdentity' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
+-------------------------------------------------------------------
35 |
36 | @available(macOS 10.15.0, *)
macro expansion @TaskLocal:1:76: warning: type 'XPCServer.ClientIdentity' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
`- /Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/ClientIdentity.swift:34:69: note: expanded code originates here
19 | /// - ``effectiveUserID``
20 | /// - ``effectiveGroupID``
21 | class ClientIdentity {
| `- note: class 'ClientIdentity' does not conform to the 'Sendable' protocol
22 | private let connection: xpc_connection_t
23 | private let message: xpc_object_t
:
32 | @available(macOS 10.15.0, *)
33 | @TaskLocal
34 | private static var currentForTask: XPCServer.ClientIdentity?
+--- macro expansion @TaskLocal ------------------------------------
|1 | private static let $currentForTask: TaskLocal<XPCServer.ClientIdentity?> = TaskLocal(wrappedValue: nil)
| | `- warning: type 'XPCServer.ClientIdentity' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
+-------------------------------------------------------------------
35 |
36 | @available(macOS 10.15.0, *)
macro expansion @TaskLocal:1:76: warning: type 'XPCServer.ClientIdentity' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
`- /Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/ClientIdentity.swift:34:69: note: expanded code originates here
19 | /// - ``effectiveUserID``
20 | /// - ``effectiveGroupID``
21 | class ClientIdentity {
| `- note: class 'ClientIdentity' does not conform to the 'Sendable' protocol
22 | private let connection: xpc_connection_t
23 | private let message: xpc_object_t
:
32 | @available(macOS 10.15.0, *)
33 | @TaskLocal
34 | private static var currentForTask: XPCServer.ClientIdentity?
+--- macro expansion @TaskLocal ------------------------------------
|1 | private static let $currentForTask: TaskLocal<XPCServer.ClientIdentity?> = TaskLocal(wrappedValue: nil)
| | `- warning: type 'XPCServer.ClientIdentity' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
+-------------------------------------------------------------------
35 |
36 | @available(macOS 10.15.0, *)
macro expansion @TaskLocal:3:25: warning: type 'XPCServer.ClientIdentity' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
`- /Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/ClientIdentity.swift:34:69: note: expanded code originates here
19 | /// - ``effectiveUserID``
20 | /// - ``effectiveGroupID``
21 | class ClientIdentity {
| `- note: class 'ClientIdentity' does not conform to the 'Sendable' protocol
22 | private let connection: xpc_connection_t
23 | private let message: xpc_object_t
:
32 | @available(macOS 10.15.0, *)
33 | @TaskLocal
34 | private static var currentForTask: XPCServer.ClientIdentity?
+--- macro expansion @TaskLocal ------------------------------------
|1 | {
|2 | get {
|3 | $currentForTask.get()
| | `- warning: type 'XPCServer.ClientIdentity' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
|4 | }
|5 | }
+-------------------------------------------------------------------
35 |
36 | @available(macOS 10.15.0, *)
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/ClientIdentity.swift:42:33: warning: type 'XPCServer.ClientIdentity' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
19 | /// - ``effectiveUserID``
20 | /// - ``effectiveGroupID``
21 | class ClientIdentity {
| `- note: class 'ClientIdentity' does not conform to the 'Sendable' protocol
22 | private let connection: xpc_connection_t
23 | private let message: xpc_object_t
:
40 | operation: () throws -> Task<Success, Failure>
41 | ) rethrows -> Task<Success, Failure> {
42 | try $currentForTask.withValue(XPCServer.ClientIdentity(connection: connection, message: message)) {
| `- warning: type 'XPCServer.ClientIdentity' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
43 | try operation()
44 | }
[39/50] Compiling SecureXPC ClientRequirement.swift
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/SequentialResultProvider.swift:125:16: warning: capture of 'self' with non-sendable type 'SequentialResultProvider<S>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
35 | /// - ``failure(error:)``
36 | /// - ``isFinished``
37 | public class SequentialResultProvider<S: Encodable> {
| `- note: generic class 'SequentialResultProvider' does not conform to the 'Sendable' protocol
38 | private let request: Request
39 | private weak var server: XPCServer?
:
123 | private func sendResponse(isFinished: Bool, encodingWork: @escaping (inout xpc_object_t) throws -> Void) {
124 | self.serialQueue.async {
125 | if self.isFinished {
| `- warning: capture of 'self' with non-sendable type 'SequentialResultProvider<S>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
126 | self.sendToServerErrorHandler(XPCError.sequenceFinished)
127 | return
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/SequentialResultProvider.swift:142:25: warning: capture of 'encodingWork' with non-sendable type '(inout xpc_object_t) throws -> Void' (aka '(inout any OS_xpc_object) throws -> ()') in a `@Sendable` closure; this is an error in the Swift 6 language mode
140 |
141 | do {
142 | try encodingWork(&response)
| |- warning: capture of 'encodingWork' with non-sendable type '(inout xpc_object_t) throws -> Void' (aka '(inout any OS_xpc_object) throws -> ()') in a `@Sendable` closure; this is an error in the Swift 6 language mode
| `- note: a function type must be marked '@Sendable' to conform to 'Sendable'
143 | xpc_connection_send_message(connection, response)
144 | } catch {
macro expansion @TaskLocal:1:20: warning: static property '$currentForTask' is not concurrency-safe because non-'Sendable' type 'TaskLocal<XPCServer.ClientIdentity?>' may have shared mutable state; this is an error in the Swift 6 language mode
`- /Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/ClientIdentity.swift:34:69: note: expanded code originates here
19 | /// - ``effectiveUserID``
20 | /// - ``effectiveGroupID``
21 | class ClientIdentity {
| `- note: class 'ClientIdentity' does not conform to the 'Sendable' protocol
22 | private let connection: xpc_connection_t
23 | private let message: xpc_object_t
:
32 | @available(macOS 10.15.0, *)
33 | @TaskLocal
34 | private static var currentForTask: XPCServer.ClientIdentity?
+--- macro expansion @TaskLocal ------------------------------------
|1 | private static let $currentForTask: TaskLocal<XPCServer.ClientIdentity?> = TaskLocal(wrappedValue: nil)
| | |- warning: static property '$currentForTask' is not concurrency-safe because non-'Sendable' type 'TaskLocal<XPCServer.ClientIdentity?>' may have shared mutable state; this is an error in the Swift 6 language mode
| | |- note: annotate '$currentForTask' with '@MainActor' if property should only be accessed from the main actor
| | `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
+-------------------------------------------------------------------
35 |
36 | @available(macOS 10.15.0, *)
macro expansion @TaskLocal:1:20: warning: type 'XPCServer.ClientIdentity' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
`- /Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/ClientIdentity.swift:34:69: note: expanded code originates here
19 | /// - ``effectiveUserID``
20 | /// - ``effectiveGroupID``
21 | class ClientIdentity {
| `- note: class 'ClientIdentity' does not conform to the 'Sendable' protocol
22 | private let connection: xpc_connection_t
23 | private let message: xpc_object_t
:
32 | @available(macOS 10.15.0, *)
33 | @TaskLocal
34 | private static var currentForTask: XPCServer.ClientIdentity?
+--- macro expansion @TaskLocal ------------------------------------
|1 | private static let $currentForTask: TaskLocal<XPCServer.ClientIdentity?> = TaskLocal(wrappedValue: nil)
| | `- warning: type 'XPCServer.ClientIdentity' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
+-------------------------------------------------------------------
35 |
36 | @available(macOS 10.15.0, *)
macro expansion @TaskLocal:1:76: warning: type 'XPCServer.ClientIdentity' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
`- /Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/ClientIdentity.swift:34:69: note: expanded code originates here
19 | /// - ``effectiveUserID``
20 | /// - ``effectiveGroupID``
21 | class ClientIdentity {
| `- note: class 'ClientIdentity' does not conform to the 'Sendable' protocol
22 | private let connection: xpc_connection_t
23 | private let message: xpc_object_t
:
32 | @available(macOS 10.15.0, *)
33 | @TaskLocal
34 | private static var currentForTask: XPCServer.ClientIdentity?
+--- macro expansion @TaskLocal ------------------------------------
|1 | private static let $currentForTask: TaskLocal<XPCServer.ClientIdentity?> = TaskLocal(wrappedValue: nil)
| | `- warning: type 'XPCServer.ClientIdentity' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
+-------------------------------------------------------------------
35 |
36 | @available(macOS 10.15.0, *)
macro expansion @TaskLocal:1:76: warning: type 'XPCServer.ClientIdentity' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
`- /Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/ClientIdentity.swift:34:69: note: expanded code originates here
19 | /// - ``effectiveUserID``
20 | /// - ``effectiveGroupID``
21 | class ClientIdentity {
| `- note: class 'ClientIdentity' does not conform to the 'Sendable' protocol
22 | private let connection: xpc_connection_t
23 | private let message: xpc_object_t
:
32 | @available(macOS 10.15.0, *)
33 | @TaskLocal
34 | private static var currentForTask: XPCServer.ClientIdentity?
+--- macro expansion @TaskLocal ------------------------------------
|1 | private static let $currentForTask: TaskLocal<XPCServer.ClientIdentity?> = TaskLocal(wrappedValue: nil)
| | `- warning: type 'XPCServer.ClientIdentity' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
+-------------------------------------------------------------------
35 |
36 | @available(macOS 10.15.0, *)
macro expansion @TaskLocal:3:25: warning: type 'XPCServer.ClientIdentity' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
`- /Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/ClientIdentity.swift:34:69: note: expanded code originates here
19 | /// - ``effectiveUserID``
20 | /// - ``effectiveGroupID``
21 | class ClientIdentity {
| `- note: class 'ClientIdentity' does not conform to the 'Sendable' protocol
22 | private let connection: xpc_connection_t
23 | private let message: xpc_object_t
:
32 | @available(macOS 10.15.0, *)
33 | @TaskLocal
34 | private static var currentForTask: XPCServer.ClientIdentity?
+--- macro expansion @TaskLocal ------------------------------------
|1 | {
|2 | get {
|3 | $currentForTask.get()
| | `- warning: type 'XPCServer.ClientIdentity' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
|4 | }
|5 | }
+-------------------------------------------------------------------
35 |
36 | @available(macOS 10.15.0, *)
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/ClientIdentity.swift:42:33: warning: type 'XPCServer.ClientIdentity' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
19 | /// - ``effectiveUserID``
20 | /// - ``effectiveGroupID``
21 | class ClientIdentity {
| `- note: class 'ClientIdentity' does not conform to the 'Sendable' protocol
22 | private let connection: xpc_connection_t
23 | private let message: xpc_object_t
:
40 | operation: () throws -> Task<Success, Failure>
41 | ) rethrows -> Task<Success, Failure> {
42 | try $currentForTask.withValue(XPCServer.ClientIdentity(connection: connection, message: message)) {
| `- warning: type 'XPCServer.ClientIdentity' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
43 | try operation()
44 | }
[40/50] Compiling SecureXPC MachServiceCriteria.swift
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/SequentialResultProvider.swift:125:16: warning: capture of 'self' with non-sendable type 'SequentialResultProvider<S>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
35 | /// - ``failure(error:)``
36 | /// - ``isFinished``
37 | public class SequentialResultProvider<S: Encodable> {
| `- note: generic class 'SequentialResultProvider' does not conform to the 'Sendable' protocol
38 | private let request: Request
39 | private weak var server: XPCServer?
:
123 | private func sendResponse(isFinished: Bool, encodingWork: @escaping (inout xpc_object_t) throws -> Void) {
124 | self.serialQueue.async {
125 | if self.isFinished {
| `- warning: capture of 'self' with non-sendable type 'SequentialResultProvider<S>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
126 | self.sendToServerErrorHandler(XPCError.sequenceFinished)
127 | return
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/SequentialResultProvider.swift:142:25: warning: capture of 'encodingWork' with non-sendable type '(inout xpc_object_t) throws -> Void' (aka '(inout any OS_xpc_object) throws -> ()') in a `@Sendable` closure; this is an error in the Swift 6 language mode
140 |
141 | do {
142 | try encodingWork(&response)
| |- warning: capture of 'encodingWork' with non-sendable type '(inout xpc_object_t) throws -> Void' (aka '(inout any OS_xpc_object) throws -> ()') in a `@Sendable` closure; this is an error in the Swift 6 language mode
| `- note: a function type must be marked '@Sendable' to conform to 'Sendable'
143 | xpc_connection_send_message(connection, response)
144 | } catch {
macro expansion @TaskLocal:1:20: warning: static property '$currentForTask' is not concurrency-safe because non-'Sendable' type 'TaskLocal<XPCServer.ClientIdentity?>' may have shared mutable state; this is an error in the Swift 6 language mode
`- /Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/ClientIdentity.swift:34:69: note: expanded code originates here
19 | /// - ``effectiveUserID``
20 | /// - ``effectiveGroupID``
21 | class ClientIdentity {
| `- note: class 'ClientIdentity' does not conform to the 'Sendable' protocol
22 | private let connection: xpc_connection_t
23 | private let message: xpc_object_t
:
32 | @available(macOS 10.15.0, *)
33 | @TaskLocal
34 | private static var currentForTask: XPCServer.ClientIdentity?
+--- macro expansion @TaskLocal ------------------------------------
|1 | private static let $currentForTask: TaskLocal<XPCServer.ClientIdentity?> = TaskLocal(wrappedValue: nil)
| | |- warning: static property '$currentForTask' is not concurrency-safe because non-'Sendable' type 'TaskLocal<XPCServer.ClientIdentity?>' may have shared mutable state; this is an error in the Swift 6 language mode
| | |- note: annotate '$currentForTask' with '@MainActor' if property should only be accessed from the main actor
| | `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
+-------------------------------------------------------------------
35 |
36 | @available(macOS 10.15.0, *)
macro expansion @TaskLocal:1:20: warning: type 'XPCServer.ClientIdentity' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
`- /Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/ClientIdentity.swift:34:69: note: expanded code originates here
19 | /// - ``effectiveUserID``
20 | /// - ``effectiveGroupID``
21 | class ClientIdentity {
| `- note: class 'ClientIdentity' does not conform to the 'Sendable' protocol
22 | private let connection: xpc_connection_t
23 | private let message: xpc_object_t
:
32 | @available(macOS 10.15.0, *)
33 | @TaskLocal
34 | private static var currentForTask: XPCServer.ClientIdentity?
+--- macro expansion @TaskLocal ------------------------------------
|1 | private static let $currentForTask: TaskLocal<XPCServer.ClientIdentity?> = TaskLocal(wrappedValue: nil)
| | `- warning: type 'XPCServer.ClientIdentity' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
+-------------------------------------------------------------------
35 |
36 | @available(macOS 10.15.0, *)
macro expansion @TaskLocal:1:76: warning: type 'XPCServer.ClientIdentity' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
`- /Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/ClientIdentity.swift:34:69: note: expanded code originates here
19 | /// - ``effectiveUserID``
20 | /// - ``effectiveGroupID``
21 | class ClientIdentity {
| `- note: class 'ClientIdentity' does not conform to the 'Sendable' protocol
22 | private let connection: xpc_connection_t
23 | private let message: xpc_object_t
:
32 | @available(macOS 10.15.0, *)
33 | @TaskLocal
34 | private static var currentForTask: XPCServer.ClientIdentity?
+--- macro expansion @TaskLocal ------------------------------------
|1 | private static let $currentForTask: TaskLocal<XPCServer.ClientIdentity?> = TaskLocal(wrappedValue: nil)
| | `- warning: type 'XPCServer.ClientIdentity' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
+-------------------------------------------------------------------
35 |
36 | @available(macOS 10.15.0, *)
macro expansion @TaskLocal:1:76: warning: type 'XPCServer.ClientIdentity' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
`- /Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/ClientIdentity.swift:34:69: note: expanded code originates here
19 | /// - ``effectiveUserID``
20 | /// - ``effectiveGroupID``
21 | class ClientIdentity {
| `- note: class 'ClientIdentity' does not conform to the 'Sendable' protocol
22 | private let connection: xpc_connection_t
23 | private let message: xpc_object_t
:
32 | @available(macOS 10.15.0, *)
33 | @TaskLocal
34 | private static var currentForTask: XPCServer.ClientIdentity?
+--- macro expansion @TaskLocal ------------------------------------
|1 | private static let $currentForTask: TaskLocal<XPCServer.ClientIdentity?> = TaskLocal(wrappedValue: nil)
| | `- warning: type 'XPCServer.ClientIdentity' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
+-------------------------------------------------------------------
35 |
36 | @available(macOS 10.15.0, *)
macro expansion @TaskLocal:3:25: warning: type 'XPCServer.ClientIdentity' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
`- /Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/ClientIdentity.swift:34:69: note: expanded code originates here
19 | /// - ``effectiveUserID``
20 | /// - ``effectiveGroupID``
21 | class ClientIdentity {
| `- note: class 'ClientIdentity' does not conform to the 'Sendable' protocol
22 | private let connection: xpc_connection_t
23 | private let message: xpc_object_t
:
32 | @available(macOS 10.15.0, *)
33 | @TaskLocal
34 | private static var currentForTask: XPCServer.ClientIdentity?
+--- macro expansion @TaskLocal ------------------------------------
|1 | {
|2 | get {
|3 | $currentForTask.get()
| | `- warning: type 'XPCServer.ClientIdentity' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
|4 | }
|5 | }
+-------------------------------------------------------------------
35 |
36 | @available(macOS 10.15.0, *)
/Users/admin/builder/spi-builder-workspace/Sources/SecureXPC/Server/ClientIdentity.swift:42:33: warning: type 'XPCServer.ClientIdentity' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
19 | /// - ``effectiveUserID``
20 | /// - ``effectiveGroupID``
21 | class ClientIdentity {
| `- note: class 'ClientIdentity' does not conform to the 'Sendable' protocol
22 | private let connection: xpc_connection_t
23 | private let message: xpc_object_t
:
40 | operation: () throws -> Task<Success, Failure>
41 | ) rethrows -> Task<Success, Failure> {
42 | try $currentForTask.withValue(XPCServer.ClientIdentity(connection: connection, message: message)) {
| `- warning: type 'XPCServer.ClientIdentity' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
43 | try operation()
44 | }
[41/50] Compiling SecureXPC SharedRawMemory.swift
[42/50] Compiling SecureXPC SharedSemaphore.swift
[43/50] Compiling SecureXPC SharedTrivial.swift
[44/50] Compiling SecureXPC Trivial.swift
[45/50] Compiling SecureXPC XPCCoderError.swift
[46/50] Compiling SecureXPC XPCServiceClient.swift
[47/50] Compiling SecureXPC ArrayOptimizedForXPC.swift
[48/50] Compiling SecureXPC DataOptimizedForXPC.swift
[49/50] Compiling SecureXPC File Descriptor XPC Wrappers.swift
[50/50] Compiling SecureXPC IOSurfaceForXPC.swift
Build complete! (18.24s)
Build complete.
{
"dependencies" : [
],
"manifest_display_name" : "SecureXPC",
"name" : "SecureXPC",
"path" : "/Users/admin/builder/spi-builder-workspace",
"platforms" : [
{
"name" : "macos",
"version" : "10.10"
}
],
"products" : [
{
"name" : "SecureXPC",
"targets" : [
"SecureXPC"
],
"type" : {
"library" : [
"automatic"
]
}
}
],
"targets" : [
{
"c99name" : "SecureXPCTests",
"module_type" : "SwiftTarget",
"name" : "SecureXPCTests",
"path" : "Tests/SecureXPCTests",
"sources" : [
"Client & Server/Endpoint Tests.swift",
"Client & Server/Error Integration Tests.swift",
"Client & Server/RequestContext Tests.swift",
"Client & Server/Round-trip Integration Test.swift",
"Client & Server/Sequential Result Tests.swift",
"Client & Server/Server Concurrency Tests.swift",
"Client & Server/Server Error Handler Test.swift",
"Client & Server/Server Identity Tests.swift",
"Client & Server/XPCServer Creation.swift",
"Encoder & Decoder/Round Trip/Array roundtrip tests.swift",
"Encoder & Decoder/Round Trip/ArrayOptimizedForXPC Tests.swift",
"Encoder & Decoder/Round Trip/Class round trip tests.swift",
"Encoder & Decoder/Round Trip/DataOptimizedForXPC Tests.swift",
"Encoder & Decoder/Round Trip/Dictionary roundtrip tests.swift",
"Encoder & Decoder/Round Trip/Endpoint roundtrip tests.swift",
"Encoder & Decoder/Round Trip/File Descriptor XPC Wrapper Tests.swift",
"Encoder & Decoder/Round Trip/IOSurfaceForXPC Tests.swift",
"Encoder & Decoder/Round Trip/Scalar roundtrip tests.swift",
"Encoder & Decoder/Round Trip/Unkeyed container roundtrip tests.swift",
"Encoder & Decoder/TestHelpers.swift",
"Encoder & Decoder/XPCDecoder/Array decoding tests.swift",
"Encoder & Decoder/XPCDecoder/Dictionary decoding tests.swift",
"Encoder & Decoder/XPCDecoder/Scalar decoding tests.swift",
"Encoder & Decoder/XPCEncoder/Array encoding tests.swift",
"Encoder & Decoder/XPCEncoder/Dictionary encoding tests.swift",
"Encoder & Decoder/XPCEncoder/Scalar encoding tests.swift",
"Multiprocess Client & Server/LaunchAgent Tests.swift",
"Multiprocess Client & Server/LaunchAgent/LaunchAgent.swift",
"Multiprocess Client & Server/LaunchAgent/Shared.swift",
"Multiprocess Client & Server/LaunchAgent/main.swift"
],
"target_dependencies" : [
"SecureXPC"
],
"type" : "test"
},
{
"c99name" : "SecureXPC",
"module_type" : "SwiftTarget",
"name" : "SecureXPC",
"path" : "Sources/SecureXPC",
"product_memberships" : [
"SecureXPC"
],
"sources" : [
"Client/ServerIdentity.swift",
"Client/ServerRequirement.swift",
"Client/XPCClient.swift",
"Client/XPCEndpointClient.swift",
"Client/XPCMachClient.swift",
"Client/XPCServiceClient.swift",
"Codable Types/ArrayOptimizedForXPC.swift",
"Codable Types/DataOptimizedForXPC.swift",
"Codable Types/File Descriptor XPC Wrappers.swift",
"Codable Types/IOSurfaceForXPC.swift",
"HandlerError.swift",
"PackageInternalRoutes.swift",
"Request.swift",
"Response.swift",
"Routes.swift",
"SequentialResult.swift",
"SequentialResultProvider.swift",
"Server/ClientIdentity.swift",
"Server/ClientRequirement.swift",
"Server/MachServiceCriteria.swift",
"Server/XPCAnonymousServer.swift",
"Server/XPCMachServer.swift",
"Server/XPCServer.swift",
"Server/XPCServiceServer.swift",
"Shared Memory/SharedMemory.swift",
"Shared Memory/SharedRawMemory.swift",
"Shared Memory/SharedSemaphore.swift",
"Shared Memory/SharedTrivial.swift",
"Trivial.swift",
"XPC Coders/XPCCoderError.swift",
"XPC Coders/XPCDecoder/Transformation functions.swift",
"XPC Coders/XPCDecoder/XPCDecoder.swift",
"XPC Coders/XPCDecoder/XPCDecoderImpl.swift",
"XPC Coders/XPCDecoder/XPCKeyedDecodingContainer.swift",
"XPC Coders/XPCDecoder/XPCSingleValueDecodingContainer.swift",
"XPC Coders/XPCDecoder/XPCUnkeyedDecodingContainer.swift",
"XPC Coders/XPCEncoder/XPCContainer.swift",
"XPC Coders/XPCEncoder/XPCEncoder.swift",
"XPC Coders/XPCEncoder/XPCEncoderImpl.swift",
"XPC Coders/XPCEncoder/XPCKeyedEncodingContainer.swift",
"XPC Coders/XPCEncoder/XPCSingleValueEncodingContainer.swift",
"XPC Coders/XPCEncoder/XPCUnkeyedEncodingContainer.swift",
"XPC Coders/xpc_type_t+description.swift",
"XPCCommon.swift",
"XPCConnectionDescriptor.swift",
"XPCError.swift",
"XPCServerEndpoint.swift"
],
"type" : "library"
}
],
"tools_version" : "5.5"
}
Done.