Swift Package Index

Build Information

Failed to build XCTest, reference main (de1522), with Swift 6.1 for Wasm on 20 Apr 2026 13:14:55 UTC.

Build Command

bash -c docker run --pull=always --rm -v "checkouts-4609320-0":/host -w "$PWD" -e JAVA_HOME="/root/.sdkman/candidates/java/current" -e SPI_BUILD="1" -e SPI_PROCESSING="1" registry.gitlab.com/swiftpackageindex/spi-images:wasm-6.1-latest swift build --swift-sdk wasm32-unknown-wasi 2>&1

Build Log

333 |         return await XCTWaiter().fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
334 |     }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:332:40: error: expected '{' in class
330 |     ///   provide this parameter when calling this method.
331 |     @available(macOS 12.0, *)
332 |     open class nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |                                        `- error: expected '{' in class
333 |         return await XCTWaiter().fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
334 |     }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:332:39: error: consecutive declarations on a line must be separated by ';'
330 |     ///   provide this parameter when calling this method.
331 |     @available(macOS 12.0, *)
332 |     open class nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |                                       `- error: consecutive declarations on a line must be separated by ';'
333 |         return await XCTWaiter().fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
334 |     }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestCase+Asynchronous.swift:116:5: error: unknown option 'nonsending' for attribute 'nonisolated'
114 |     /// - SeeAlso: XCTWaiter
115 |     @available(macOS 12.0, *)
116 |     nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async {
    |     `- error: unknown option 'nonsending' for attribute 'nonisolated'
117 |         let waiter = XCTWaiter(delegate: self)
118 |         await waiter.fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
[19/39] Compiling XCTest XCTestSuiteRun.swift
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:282:10: error: unknown option 'nonsending' for attribute 'nonisolated'
280 |     @available(macOS 12.0, *)
281 |     @discardableResult
282 |     open nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |          `- error: unknown option 'nonsending' for attribute 'nonisolated'
283 |         return await withCheckedContinuation { continuation in
284 |             // This function operates by blocking a background thread instead of one owned by libdispatch or by the
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:332:27: error: expected ':' to begin inheritance clause
330 |     ///   provide this parameter when calling this method.
331 |     @available(macOS 12.0, *)
332 |     open class nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |                           `- error: expected ':' to begin inheritance clause
333 |         return await XCTWaiter().fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
334 |     }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:332:40: error: expected '{' in class
330 |     ///   provide this parameter when calling this method.
331 |     @available(macOS 12.0, *)
332 |     open class nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |                                        `- error: expected '{' in class
333 |         return await XCTWaiter().fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
334 |     }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:332:39: error: consecutive declarations on a line must be separated by ';'
330 |     ///   provide this parameter when calling this method.
331 |     @available(macOS 12.0, *)
332 |     open class nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |                                       `- error: consecutive declarations on a line must be separated by ';'
333 |         return await XCTWaiter().fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
334 |     }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestCase+Asynchronous.swift:116:5: error: unknown option 'nonsending' for attribute 'nonisolated'
114 |     /// - SeeAlso: XCTWaiter
115 |     @available(macOS 12.0, *)
116 |     nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async {
    |     `- error: unknown option 'nonsending' for attribute 'nonisolated'
117 |         let waiter = XCTWaiter(delegate: self)
118 |         await waiter.fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
[20/39] Compiling XCTest XCTestCaseRun.swift
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:282:10: error: unknown option 'nonsending' for attribute 'nonisolated'
280 |     @available(macOS 12.0, *)
281 |     @discardableResult
282 |     open nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |          `- error: unknown option 'nonsending' for attribute 'nonisolated'
283 |         return await withCheckedContinuation { continuation in
284 |             // This function operates by blocking a background thread instead of one owned by libdispatch or by the
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:332:27: error: expected ':' to begin inheritance clause
330 |     ///   provide this parameter when calling this method.
331 |     @available(macOS 12.0, *)
332 |     open class nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |                           `- error: expected ':' to begin inheritance clause
333 |         return await XCTWaiter().fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
334 |     }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:332:40: error: expected '{' in class
330 |     ///   provide this parameter when calling this method.
331 |     @available(macOS 12.0, *)
332 |     open class nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |                                        `- error: expected '{' in class
333 |         return await XCTWaiter().fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
334 |     }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:332:39: error: consecutive declarations on a line must be separated by ';'
330 |     ///   provide this parameter when calling this method.
331 |     @available(macOS 12.0, *)
332 |     open class nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |                                       `- error: consecutive declarations on a line must be separated by ';'
333 |         return await XCTWaiter().fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
334 |     }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestCase+Asynchronous.swift:116:5: error: unknown option 'nonsending' for attribute 'nonisolated'
114 |     /// - SeeAlso: XCTWaiter
115 |     @available(macOS 12.0, *)
116 |     nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async {
    |     `- error: unknown option 'nonsending' for attribute 'nonisolated'
117 |         let waiter = XCTWaiter(delegate: self)
118 |         await waiter.fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
[21/39] Compiling XCTest XCTestErrors.swift
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:282:10: error: unknown option 'nonsending' for attribute 'nonisolated'
280 |     @available(macOS 12.0, *)
281 |     @discardableResult
282 |     open nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |          `- error: unknown option 'nonsending' for attribute 'nonisolated'
283 |         return await withCheckedContinuation { continuation in
284 |             // This function operates by blocking a background thread instead of one owned by libdispatch or by the
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:332:27: error: expected ':' to begin inheritance clause
330 |     ///   provide this parameter when calling this method.
331 |     @available(macOS 12.0, *)
332 |     open class nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |                           `- error: expected ':' to begin inheritance clause
333 |         return await XCTWaiter().fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
334 |     }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:332:40: error: expected '{' in class
330 |     ///   provide this parameter when calling this method.
331 |     @available(macOS 12.0, *)
332 |     open class nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |                                        `- error: expected '{' in class
333 |         return await XCTWaiter().fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
334 |     }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:332:39: error: consecutive declarations on a line must be separated by ';'
330 |     ///   provide this parameter when calling this method.
331 |     @available(macOS 12.0, *)
332 |     open class nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |                                       `- error: consecutive declarations on a line must be separated by ';'
333 |         return await XCTWaiter().fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
334 |     }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestCase+Asynchronous.swift:116:5: error: unknown option 'nonsending' for attribute 'nonisolated'
114 |     /// - SeeAlso: XCTWaiter
115 |     @available(macOS 12.0, *)
116 |     nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async {
    |     `- error: unknown option 'nonsending' for attribute 'nonisolated'
117 |         let waiter = XCTWaiter(delegate: self)
118 |         await waiter.fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
[22/39] Compiling XCTest XCTestMain.swift
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:282:10: error: unknown option 'nonsending' for attribute 'nonisolated'
280 |     @available(macOS 12.0, *)
281 |     @discardableResult
282 |     open nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |          `- error: unknown option 'nonsending' for attribute 'nonisolated'
283 |         return await withCheckedContinuation { continuation in
284 |             // This function operates by blocking a background thread instead of one owned by libdispatch or by the
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:332:27: error: expected ':' to begin inheritance clause
330 |     ///   provide this parameter when calling this method.
331 |     @available(macOS 12.0, *)
332 |     open class nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |                           `- error: expected ':' to begin inheritance clause
333 |         return await XCTWaiter().fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
334 |     }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:332:40: error: expected '{' in class
330 |     ///   provide this parameter when calling this method.
331 |     @available(macOS 12.0, *)
332 |     open class nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |                                        `- error: expected '{' in class
333 |         return await XCTWaiter().fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
334 |     }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:332:39: error: consecutive declarations on a line must be separated by ';'
330 |     ///   provide this parameter when calling this method.
331 |     @available(macOS 12.0, *)
332 |     open class nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |                                       `- error: consecutive declarations on a line must be separated by ';'
333 |         return await XCTWaiter().fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
334 |     }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestCase+Asynchronous.swift:116:5: error: unknown option 'nonsending' for attribute 'nonisolated'
114 |     /// - SeeAlso: XCTWaiter
115 |     @available(macOS 12.0, *)
116 |     nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async {
    |     `- error: unknown option 'nonsending' for attribute 'nonisolated'
117 |         let waiter = XCTWaiter(delegate: self)
118 |         await waiter.fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
[23/39] Compiling XCTest XCTestObservation.swift
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:282:10: error: unknown option 'nonsending' for attribute 'nonisolated'
280 |     @available(macOS 12.0, *)
281 |     @discardableResult
282 |     open nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |          `- error: unknown option 'nonsending' for attribute 'nonisolated'
283 |         return await withCheckedContinuation { continuation in
284 |             // This function operates by blocking a background thread instead of one owned by libdispatch or by the
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:332:27: error: expected ':' to begin inheritance clause
330 |     ///   provide this parameter when calling this method.
331 |     @available(macOS 12.0, *)
332 |     open class nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |                           `- error: expected ':' to begin inheritance clause
333 |         return await XCTWaiter().fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
334 |     }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:332:40: error: expected '{' in class
330 |     ///   provide this parameter when calling this method.
331 |     @available(macOS 12.0, *)
332 |     open class nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |                                        `- error: expected '{' in class
333 |         return await XCTWaiter().fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
334 |     }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:332:39: error: consecutive declarations on a line must be separated by ';'
330 |     ///   provide this parameter when calling this method.
331 |     @available(macOS 12.0, *)
332 |     open class nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |                                       `- error: consecutive declarations on a line must be separated by ';'
333 |         return await XCTWaiter().fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
334 |     }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestCase+Asynchronous.swift:116:5: error: unknown option 'nonsending' for attribute 'nonisolated'
114 |     /// - SeeAlso: XCTWaiter
115 |     @available(macOS 12.0, *)
116 |     nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async {
    |     `- error: unknown option 'nonsending' for attribute 'nonisolated'
117 |         let waiter = XCTWaiter(delegate: self)
118 |         await waiter.fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
[24/39] Compiling XCTest XCTAssert.swift
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:282:10: error: unknown option 'nonsending' for attribute 'nonisolated'
280 |     @available(macOS 12.0, *)
281 |     @discardableResult
282 |     open nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |          `- error: unknown option 'nonsending' for attribute 'nonisolated'
283 |         return await withCheckedContinuation { continuation in
284 |             // This function operates by blocking a background thread instead of one owned by libdispatch or by the
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:332:27: error: expected ':' to begin inheritance clause
330 |     ///   provide this parameter when calling this method.
331 |     @available(macOS 12.0, *)
332 |     open class nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |                           `- error: expected ':' to begin inheritance clause
333 |         return await XCTWaiter().fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
334 |     }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:332:40: error: expected '{' in class
330 |     ///   provide this parameter when calling this method.
331 |     @available(macOS 12.0, *)
332 |     open class nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |                                        `- error: expected '{' in class
333 |         return await XCTWaiter().fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
334 |     }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:332:39: error: consecutive declarations on a line must be separated by ';'
330 |     ///   provide this parameter when calling this method.
331 |     @available(macOS 12.0, *)
332 |     open class nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |                                       `- error: consecutive declarations on a line must be separated by ';'
333 |         return await XCTWaiter().fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
334 |     }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestCase+Asynchronous.swift:116:5: error: unknown option 'nonsending' for attribute 'nonisolated'
114 |     /// - SeeAlso: XCTWaiter
115 |     @available(macOS 12.0, *)
116 |     nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async {
    |     `- error: unknown option 'nonsending' for attribute 'nonisolated'
117 |         let waiter = XCTWaiter(delegate: self)
118 |         await waiter.fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
/host/spi-builder-workspace/Sources/XCTest/Public/XCTestCase.swift:70:32: error: cannot find type 'DispatchQueue' in scope
 68 |     }
 69 |     #else
 70 |     typealias SubsystemQueue = DispatchQueue
    |                                `- error: cannot find type 'DispatchQueue' in scope
 71 |     #endif
 72 |
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:116:42: error: cannot find 'DispatchQueue' in scope
114 |     }
115 |
116 |     internal static let subsystemQueue = DispatchQueue(label: "org.swift.XCTest.XCTWaiter")
    |                                          `- error: cannot find 'DispatchQueue' in scope
117 |
118 |     private var state = State.ready
[25/39] Compiling XCTest XCTSkip.swift
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:282:10: error: unknown option 'nonsending' for attribute 'nonisolated'
280 |     @available(macOS 12.0, *)
281 |     @discardableResult
282 |     open nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |          `- error: unknown option 'nonsending' for attribute 'nonisolated'
283 |         return await withCheckedContinuation { continuation in
284 |             // This function operates by blocking a background thread instead of one owned by libdispatch or by the
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:332:27: error: expected ':' to begin inheritance clause
330 |     ///   provide this parameter when calling this method.
331 |     @available(macOS 12.0, *)
332 |     open class nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |                           `- error: expected ':' to begin inheritance clause
333 |         return await XCTWaiter().fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
334 |     }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:332:40: error: expected '{' in class
330 |     ///   provide this parameter when calling this method.
331 |     @available(macOS 12.0, *)
332 |     open class nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |                                        `- error: expected '{' in class
333 |         return await XCTWaiter().fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
334 |     }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:332:39: error: consecutive declarations on a line must be separated by ';'
330 |     ///   provide this parameter when calling this method.
331 |     @available(macOS 12.0, *)
332 |     open class nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |                                       `- error: consecutive declarations on a line must be separated by ';'
333 |         return await XCTWaiter().fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
334 |     }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestCase+Asynchronous.swift:116:5: error: unknown option 'nonsending' for attribute 'nonisolated'
114 |     /// - SeeAlso: XCTWaiter
115 |     @available(macOS 12.0, *)
116 |     nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async {
    |     `- error: unknown option 'nonsending' for attribute 'nonisolated'
117 |         let waiter = XCTWaiter(delegate: self)
118 |         await waiter.fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
/host/spi-builder-workspace/Sources/XCTest/Public/XCTestCase.swift:70:32: error: cannot find type 'DispatchQueue' in scope
 68 |     }
 69 |     #else
 70 |     typealias SubsystemQueue = DispatchQueue
    |                                `- error: cannot find type 'DispatchQueue' in scope
 71 |     #endif
 72 |
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:116:42: error: cannot find 'DispatchQueue' in scope
114 |     }
115 |
116 |     internal static let subsystemQueue = DispatchQueue(label: "org.swift.XCTest.XCTWaiter")
    |                                          `- error: cannot find 'DispatchQueue' in scope
117 |
118 |     private var state = State.ready
[26/39] Compiling XCTest XCTestCase+Performance.swift
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:282:10: error: unknown option 'nonsending' for attribute 'nonisolated'
280 |     @available(macOS 12.0, *)
281 |     @discardableResult
282 |     open nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |          `- error: unknown option 'nonsending' for attribute 'nonisolated'
283 |         return await withCheckedContinuation { continuation in
284 |             // This function operates by blocking a background thread instead of one owned by libdispatch or by the
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:332:27: error: expected ':' to begin inheritance clause
330 |     ///   provide this parameter when calling this method.
331 |     @available(macOS 12.0, *)
332 |     open class nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |                           `- error: expected ':' to begin inheritance clause
333 |         return await XCTWaiter().fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
334 |     }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:332:40: error: expected '{' in class
330 |     ///   provide this parameter when calling this method.
331 |     @available(macOS 12.0, *)
332 |     open class nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |                                        `- error: expected '{' in class
333 |         return await XCTWaiter().fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
334 |     }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:332:39: error: consecutive declarations on a line must be separated by ';'
330 |     ///   provide this parameter when calling this method.
331 |     @available(macOS 12.0, *)
332 |     open class nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |                                       `- error: consecutive declarations on a line must be separated by ';'
333 |         return await XCTWaiter().fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
334 |     }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestCase+Asynchronous.swift:116:5: error: unknown option 'nonsending' for attribute 'nonisolated'
114 |     /// - SeeAlso: XCTWaiter
115 |     @available(macOS 12.0, *)
116 |     nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async {
    |     `- error: unknown option 'nonsending' for attribute 'nonisolated'
117 |         let waiter = XCTWaiter(delegate: self)
118 |         await waiter.fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
/host/spi-builder-workspace/Sources/XCTest/Public/XCTestCase.swift:70:32: error: cannot find type 'DispatchQueue' in scope
 68 |     }
 69 |     #else
 70 |     typealias SubsystemQueue = DispatchQueue
    |                                `- error: cannot find type 'DispatchQueue' in scope
 71 |     #endif
 72 |
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:116:42: error: cannot find 'DispatchQueue' in scope
114 |     }
115 |
116 |     internal static let subsystemQueue = DispatchQueue(label: "org.swift.XCTest.XCTWaiter")
    |                                          `- error: cannot find 'DispatchQueue' in scope
117 |
118 |     private var state = State.ready
[27/39] Compiling XCTest XCTestCase.swift
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:282:10: error: unknown option 'nonsending' for attribute 'nonisolated'
280 |     @available(macOS 12.0, *)
281 |     @discardableResult
282 |     open nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |          `- error: unknown option 'nonsending' for attribute 'nonisolated'
283 |         return await withCheckedContinuation { continuation in
284 |             // This function operates by blocking a background thread instead of one owned by libdispatch or by the
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:332:27: error: expected ':' to begin inheritance clause
330 |     ///   provide this parameter when calling this method.
331 |     @available(macOS 12.0, *)
332 |     open class nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |                           `- error: expected ':' to begin inheritance clause
333 |         return await XCTWaiter().fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
334 |     }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:332:40: error: expected '{' in class
330 |     ///   provide this parameter when calling this method.
331 |     @available(macOS 12.0, *)
332 |     open class nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |                                        `- error: expected '{' in class
333 |         return await XCTWaiter().fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
334 |     }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:332:39: error: consecutive declarations on a line must be separated by ';'
330 |     ///   provide this parameter when calling this method.
331 |     @available(macOS 12.0, *)
332 |     open class nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |                                       `- error: consecutive declarations on a line must be separated by ';'
333 |         return await XCTWaiter().fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
334 |     }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestCase+Asynchronous.swift:116:5: error: unknown option 'nonsending' for attribute 'nonisolated'
114 |     /// - SeeAlso: XCTWaiter
115 |     @available(macOS 12.0, *)
116 |     nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async {
    |     `- error: unknown option 'nonsending' for attribute 'nonisolated'
117 |         let waiter = XCTWaiter(delegate: self)
118 |         await waiter.fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
/host/spi-builder-workspace/Sources/XCTest/Public/XCTestCase.swift:70:32: error: cannot find type 'DispatchQueue' in scope
 68 |     }
 69 |     #else
 70 |     typealias SubsystemQueue = DispatchQueue
    |                                `- error: cannot find type 'DispatchQueue' in scope
 71 |     #endif
 72 |
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:116:42: error: cannot find 'DispatchQueue' in scope
114 |     }
115 |
116 |     internal static let subsystemQueue = DispatchQueue(label: "org.swift.XCTest.XCTWaiter")
    |                                          `- error: cannot find 'DispatchQueue' in scope
117 |
118 |     private var state = State.ready
[28/39] Compiling XCTest XCTWaiter.swift
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:282:10: error: unknown option 'nonsending' for attribute 'nonisolated'
280 |     @available(macOS 12.0, *)
281 |     @discardableResult
282 |     open nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |          `- error: unknown option 'nonsending' for attribute 'nonisolated'
283 |         return await withCheckedContinuation { continuation in
284 |             // This function operates by blocking a background thread instead of one owned by libdispatch or by the
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:332:27: error: expected ':' to begin inheritance clause
330 |     ///   provide this parameter when calling this method.
331 |     @available(macOS 12.0, *)
332 |     open class nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |                           `- error: expected ':' to begin inheritance clause
333 |         return await XCTWaiter().fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
334 |     }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:332:40: error: expected '{' in class
330 |     ///   provide this parameter when calling this method.
331 |     @available(macOS 12.0, *)
332 |     open class nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |                                        `- error: expected '{' in class
333 |         return await XCTWaiter().fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
334 |     }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:332:39: error: consecutive declarations on a line must be separated by ';'
330 |     ///   provide this parameter when calling this method.
331 |     @available(macOS 12.0, *)
332 |     open class nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |                                       `- error: consecutive declarations on a line must be separated by ';'
333 |         return await XCTWaiter().fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
334 |     }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestCase+Asynchronous.swift:116:5: error: unknown option 'nonsending' for attribute 'nonisolated'
114 |     /// - SeeAlso: XCTWaiter
115 |     @available(macOS 12.0, *)
116 |     nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async {
    |     `- error: unknown option 'nonsending' for attribute 'nonisolated'
117 |         let waiter = XCTWaiter(delegate: self)
118 |         await waiter.fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:116:42: error: cannot find 'DispatchQueue' in scope
114 |     }
115 |
116 |     internal static let subsystemQueue = DispatchQueue(label: "org.swift.XCTest.XCTWaiter")
    |                                          `- error: cannot find 'DispatchQueue' in scope
117 |
118 |     private var state = State.ready
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:125:33: error: cannot find 'DispatchQueue' in scope
123 |
124 |     private weak var _delegate: XCTWaiterDelegate?
125 |     private let delegateQueue = DispatchQueue(label: "org.swift.XCTest.XCTWaiter.delegate")
    |                                 `- error: cannot find 'DispatchQueue' in scope
126 |
127 |     /// The waiter delegate will be called with various events described in the `XCTWaiterDelegate` protocol documentation.
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:332:45: error: invalid redeclaration of 'fulfillment(of:timeout:enforceOrder:file:line:)'
330 |     ///   provide this parameter when calling this method.
331 |     @available(macOS 12.0, *)
332 |     open class nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |                                             `- error: invalid redeclaration of 'fulfillment(of:timeout:enforceOrder:file:line:)'
333 |         return await XCTWaiter().fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
334 |     }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:135:13: error: cannot find 'dispatchPrecondition' in scope
133 |         }
134 |         set {
135 |             dispatchPrecondition(condition: .notOnQueue(XCTWaiter.subsystemQueue))
    |             `- error: cannot find 'dispatchPrecondition' in scope
136 |             XCTWaiter.subsystemQueue.async { self._delegate = newValue }
137 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:135:46: error: cannot infer contextual base in reference to member 'notOnQueue'
133 |         }
134 |         set {
135 |             dispatchPrecondition(condition: .notOnQueue(XCTWaiter.subsystemQueue))
    |                                              `- error: cannot infer contextual base in reference to member 'notOnQueue'
136 |             XCTWaiter.subsystemQueue.async { self._delegate = newValue }
137 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:198:31: error: 'current' is unavailable: RunLoop is not available on WASI
196 |         self.timeout = timeout
197 |         waitSourceLocation = SourceLocation(file: file, line: line)
198 |         let runLoop = RunLoop.current
    |                               `- error: 'current' is unavailable: RunLoop is not available on WASI
199 |
200 |         XCTWaiter.subsystemQueue.sync {
Foundation.RunLoop.current:3:18: note: 'current' has been explicitly marked unavailable here
1 | class RunLoop {
2 | @available(*, unavailable, message: "RunLoop is not available on WASI")
3 |   open class var current: RunLoop { get }}
  |                  `- note: 'current' has been explicitly marked unavailable here
4 |
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:287:13: error: cannot find 'Thread' in scope
285 |             // Swift runtime (as used by Swift concurrency.) To ensure we use a thread owned by neither subsystem, use
286 |             // Foundation's Thread.detachNewThread(_:).
287 |             Thread.detachNewThread { [self] in
    |             `- error: cannot find 'Thread' in scope
288 |                 let result = wait(for: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
289 |                 continuation.resume(returning: result)
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:343:9: error: cannot find 'dispatchPrecondition' in scope
341 |
342 |     private func queue_configureExpectations(_ expectations: [XCTestExpectation]) {
343 |         dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |         `- error: cannot find 'dispatchPrecondition' in scope
344 |
345 |         for expectation in expectations {
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:343:42: error: cannot infer contextual base in reference to member 'onQueue'
341 |
342 |     private func queue_configureExpectations(_ expectations: [XCTestExpectation]) {
343 |         dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                          `- error: cannot infer contextual base in reference to member 'onQueue'
344 |
345 |         for expectation in expectations {
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:354:9: error: cannot find 'dispatchPrecondition' in scope
352 |
353 |     private func queue_validateExpectationFulfillment(dueToTimeout: Bool) {
354 |         dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |         `- error: cannot find 'dispatchPrecondition' in scope
355 |         guard case let .waiting(waitingState) = state else { return }
356 |
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:354:42: error: cannot infer contextual base in reference to member 'onQueue'
352 |
353 |     private func queue_validateExpectationFulfillment(dueToTimeout: Bool) {
354 |         dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                          `- error: cannot infer contextual base in reference to member 'onQueue'
355 |         guard case let .waiting(waitingState) = state else { return }
356 |
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:386:9: error: cannot find 'dispatchPrecondition' in scope
384 |
385 |     private func queue_finish(result: Result, cancelPrimitiveWait: Bool, delegateBlock: ((XCTWaiterDelegate) -> Void)? = nil) {
386 |         dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |         `- error: cannot find 'dispatchPrecondition' in scope
387 |         guard case let .waiting(waitingState) = state else { preconditionFailure("Unexpected state: \(state)") }
388 |
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:386:42: error: cannot infer contextual base in reference to member 'onQueue'
384 |
385 |     private func queue_finish(result: Result, cancelPrimitiveWait: Bool, delegateBlock: ((XCTWaiterDelegate) -> Void)? = nil) {
386 |         dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                          `- error: cannot infer contextual base in reference to member 'onQueue'
387 |         guard case let .waiting(waitingState) = state else { preconditionFailure("Unexpected state: \(state)") }
388 |
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:428:21: error: value of type 'RunLoop' has no member 'run'
426 |
427 |         // RunLoop.run(mode:before:) should have @discardableResult <rdar://problem/45371901>
428 |         _ = runLoop.run(mode: .default, before: Date(timeIntervalSinceNow: timeIntervalToRun))
    |                     `- error: value of type 'RunLoop' has no member 'run'
429 |     }
430 |
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:428:32: error: cannot infer contextual base in reference to member 'default'
426 |
427 |         // RunLoop.run(mode:before:) should have @discardableResult <rdar://problem/45371901>
428 |         _ = runLoop.run(mode: .default, before: Date(timeIntervalSinceNow: timeIntervalToRun))
    |                                `- error: cannot infer contextual base in reference to member 'default'
429 |     }
430 |
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:436:17: error: value of type 'RunLoop' has no member '_stop'
434 |         CFRunLoopStop(runLoop.getCFRunLoop())
435 | #else
436 |         runLoop._stop()
    |                 `- error: value of type 'RunLoop' has no member '_stop'
437 | #endif
438 |     }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:468:9: error: cannot find 'dispatchPrecondition' in scope
466 |
467 |     func queue_handleWatchdogTimeout() {
468 |         dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |         `- error: cannot find 'dispatchPrecondition' in scope
469 |
470 |         queue_validateExpectationFulfillment(dueToTimeout: true)
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:468:42: error: cannot infer contextual base in reference to member 'onQueue'
466 |
467 |     func queue_handleWatchdogTimeout() {
468 |         dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                          `- error: cannot infer contextual base in reference to member 'onQueue'
469 |
470 |         queue_validateExpectationFulfillment(dueToTimeout: true)
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:476:9: error: cannot find 'dispatchPrecondition' in scope
474 |
475 |     func queue_interrupt(for interruptingWaiter: XCTWaiter) {
476 |         dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |         `- error: cannot find 'dispatchPrecondition' in scope
477 |
478 |         queue_finish(result: .interrupted, cancelPrimitiveWait: true) { delegate in
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:476:42: error: cannot infer contextual base in reference to member 'onQueue'
474 |
475 |     func queue_interrupt(for interruptingWaiter: XCTWaiter) {
476 |         dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                          `- error: cannot infer contextual base in reference to member 'onQueue'
477 |
478 |         queue_finish(result: .interrupted, cancelPrimitiveWait: true) { delegate in
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestCase+Asynchronous.swift:163:134: error: cannot find type 'NotificationCenter' in scope
161 |     ///   handler to further investigate if the notification fulfills the
162 |     ///   expectation.
163 |     @discardableResult func expectation(forNotification notificationName: Notification.Name, object: Any? = nil, notificationCenter: NotificationCenter = .default, file: StaticString = #file, line: Int = #line, handler: XCTNSNotificationExpectation.Handler? = nil) -> XCTestExpectation {
    |                                                                                                                                      `- error: cannot find type 'NotificationCenter' in scope
164 |         let expectation = XCTNSNotificationExpectation(name: notificationName, object: object, notificationCenter: notificationCenter, file: file, line: line)
165 |         expectation.handler = handler
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestCase+Asynchronous.swift:184:123: error: cannot find type 'NotificationCenter' in scope
182 |     ///   handler to further investigate if the notification fulfills the
183 |     ///   expectation.
184 |     @discardableResult func expectation(forNotification notificationName: String, object: Any? = nil, notificationCenter: NotificationCenter = .default, file: StaticString = #file, line: Int = #line, handler: XCTNSNotificationExpectation.Handler? = nil) -> XCTestExpectation {
    |                                                                                                                           `- error: cannot find type 'NotificationCenter' in scope
185 |         return expectation(forNotification: Notification.Name(rawValue: notificationName), object: object, notificationCenter: notificationCenter, file: file, line: line, handler: handler)
186 |     }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestCase+Asynchronous.swift:48:22: error: cannot find 'Thread' in scope
 46 |     @preconcurrency @MainActor
 47 |     func waitForExpectations(timeout: TimeInterval, file: StaticString = #file, line: Int = #line, handler: XCWaitCompletionHandler? = nil) {
 48 |         precondition(Thread.isMainThread, "\(#function) must be called on the main thread")
    |                      `- error: cannot find 'Thread' in scope
 49 |         if currentWaiter != nil {
 50 |             return recordFailure(description: "API violation - calling wait on test case while already waiting.", at: SourceLocation(file: file, line: line), expected: false)
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTNSNotificationExpectation.swift:69:99: error: cannot find type 'NotificationCenter' in scope
 67 |     ///   number of the call to this method in the calling file. It is rare to
 68 |     ///   provide this parameter when calling this method.
 69 |     public init(name notificationName: Notification.Name, object: Any? = nil, notificationCenter: NotificationCenter = .default, file: StaticString = #file, line: Int = #line) {
    |                                                                                                   `- error: cannot find type 'NotificationCenter' in scope
 70 |         self.notificationName = notificationName
 71 |         self.observedObject = object
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestCase+Asynchronous.swift:185:27: error: extra arguments at positions #1, #2, #3 in call
183 |     ///   expectation.
184 |     @discardableResult func expectation(forNotification notificationName: String, object: Any? = nil, notificationCenter: NotificationCenter = .default, file: StaticString = #file, line: Int = #line, handler: XCTNSNotificationExpectation.Handler? = nil) -> XCTestExpectation {
185 |         return expectation(forNotification: Notification.Name(rawValue: notificationName), object: object, notificationCenter: notificationCenter, file: file, line: line, handler: handler)
    |                           `- error: extra arguments at positions #1, #2, #3 in call
186 |     }
187 |
    :
208 |     ///   the handler can override that behavior which leaves the caller
209 |     ///   responsible for fulfilling the expectation.
210 |     @discardableResult func expectation(for predicate: NSPredicate, evaluatedWith object: Any? = nil, file: StaticString = #file, line: Int = #line, handler: XCTNSPredicateExpectation.Handler? = nil) -> XCTestExpectation {
    |                             `- note: 'expectation(for:evaluatedWith:file:line:handler:)' declared here
211 |         let expectation = XCTNSPredicateExpectation(predicate: predicate, object: object, file: file, line: line)
212 |         expectation.handler = handler
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestCase+Asynchronous.swift:185:28: error: missing argument for parameter 'for' in call
183 |     ///   expectation.
184 |     @discardableResult func expectation(forNotification notificationName: String, object: Any? = nil, notificationCenter: NotificationCenter = .default, file: StaticString = #file, line: Int = #line, handler: XCTNSNotificationExpectation.Handler? = nil) -> XCTestExpectation {
185 |         return expectation(forNotification: Notification.Name(rawValue: notificationName), object: object, notificationCenter: notificationCenter, file: file, line: line, handler: handler)
    |                            `- error: missing argument for parameter 'for' in call
186 |     }
187 |
    :
208 |     ///   the handler can override that behavior which leaves the caller
209 |     ///   responsible for fulfilling the expectation.
210 |     @discardableResult func expectation(for predicate: NSPredicate, evaluatedWith object: Any? = nil, file: StaticString = #file, line: Int = #line, handler: XCTNSPredicateExpectation.Handler? = nil) -> XCTestExpectation {
    |                             `- note: 'expectation(for:evaluatedWith:file:line:handler:)' declared here
211 |         let expectation = XCTNSPredicateExpectation(predicate: predicate, object: object, file: file, line: line)
212 |         expectation.handler = handler
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestCase+Asynchronous.swift:185:181: error: cannot convert value of type 'XCTNSNotificationExpectation.Handler?' (aka 'Optional<@Sendable (Notification) -> Bool>') to expected argument type 'XCTNSPredicateExpectation.Handler?' (aka 'Optional<@Sendable () -> Bool>')
183 |     ///   expectation.
184 |     @discardableResult func expectation(forNotification notificationName: String, object: Any? = nil, notificationCenter: NotificationCenter = .default, file: StaticString = #file, line: Int = #line, handler: XCTNSNotificationExpectation.Handler? = nil) -> XCTestExpectation {
185 |         return expectation(forNotification: Notification.Name(rawValue: notificationName), object: object, notificationCenter: notificationCenter, file: file, line: line, handler: handler)
    |                                                                                                                                                                                     `- error: cannot convert value of type 'XCTNSNotificationExpectation.Handler?' (aka 'Optional<@Sendable (Notification) -> Bool>') to expected argument type 'XCTNSPredicateExpectation.Handler?' (aka 'Optional<@Sendable () -> Bool>')
186 |     }
187 |
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:19:9: error: cannot find 'dispatchPrecondition' in scope
 17 |     private static var currentMonotonicallyIncreasingToken: UInt64 = 0
 18 |     private static func queue_nextMonotonicallyIncreasingToken() -> UInt64 {
 19 |         dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |         `- error: cannot find 'dispatchPrecondition' in scope
 20 |         currentMonotonicallyIncreasingToken += 1
 21 |         return currentMonotonicallyIncreasingToken
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:19:42: error: cannot infer contextual base in reference to member 'onQueue'
 17 |     private static var currentMonotonicallyIncreasingToken: UInt64 = 0
 18 |     private static func queue_nextMonotonicallyIncreasingToken() -> UInt64 {
 19 |         dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                          `- error: cannot infer contextual base in reference to member 'onQueue'
 20 |         currentMonotonicallyIncreasingToken += 1
 21 |         return currentMonotonicallyIncreasingToken
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:152:13: error: cannot find 'dispatchPrecondition' in scope
150 |     internal var queue_expectationDescription: String {
151 |         get {
152 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |             `- error: cannot find 'dispatchPrecondition' in scope
153 |             return _expectationDescription
154 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:152:46: error: cannot infer contextual base in reference to member 'onQueue'
150 |     internal var queue_expectationDescription: String {
151 |         get {
152 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                              `- error: cannot infer contextual base in reference to member 'onQueue'
153 |             return _expectationDescription
154 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:156:13: error: cannot find 'dispatchPrecondition' in scope
154 |         }
155 |         set {
156 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |             `- error: cannot find 'dispatchPrecondition' in scope
157 |             _expectationDescription = newValue
158 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:156:46: error: cannot infer contextual base in reference to member 'onQueue'
154 |         }
155 |         set {
156 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                              `- error: cannot infer contextual base in reference to member 'onQueue'
157 |             _expectationDescription = newValue
158 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:162:13: error: cannot find 'dispatchPrecondition' in scope
160 |     internal var queue_isFulfilled: Bool {
161 |         get {
162 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |             `- error: cannot find 'dispatchPrecondition' in scope
163 |             return isFulfilled
164 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:162:46: error: cannot infer contextual base in reference to member 'onQueue'
160 |     internal var queue_isFulfilled: Bool {
161 |         get {
162 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                              `- error: cannot infer contextual base in reference to member 'onQueue'
163 |             return isFulfilled
164 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:166:13: error: cannot find 'dispatchPrecondition' in scope
164 |         }
165 |         set {
166 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |             `- error: cannot find 'dispatchPrecondition' in scope
167 |             isFulfilled = newValue
168 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:166:46: error: cannot infer contextual base in reference to member 'onQueue'
164 |         }
165 |         set {
166 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                              `- error: cannot infer contextual base in reference to member 'onQueue'
167 |             isFulfilled = newValue
168 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:172:13: error: cannot find 'dispatchPrecondition' in scope
170 |     internal var queue_fulfillmentToken: UInt64 {
171 |         get {
172 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |             `- error: cannot find 'dispatchPrecondition' in scope
173 |             return fulfillmentToken
174 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:172:46: error: cannot infer contextual base in reference to member 'onQueue'
170 |     internal var queue_fulfillmentToken: UInt64 {
171 |         get {
172 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                              `- error: cannot infer contextual base in reference to member 'onQueue'
173 |             return fulfillmentToken
174 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:176:13: error: cannot find 'dispatchPrecondition' in scope
174 |         }
175 |         set {
176 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |             `- error: cannot find 'dispatchPrecondition' in scope
177 |             fulfillmentToken = newValue
178 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:176:46: error: cannot infer contextual base in reference to member 'onQueue'
174 |         }
175 |         set {
176 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                              `- error: cannot infer contextual base in reference to member 'onQueue'
177 |             fulfillmentToken = newValue
178 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:182:13: error: cannot find 'dispatchPrecondition' in scope
180 |     internal var queue_expectedFulfillmentCount: Int {
181 |         get {
182 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |             `- error: cannot find 'dispatchPrecondition' in scope
183 |             return _expectedFulfillmentCount
184 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:182:46: error: cannot infer contextual base in reference to member 'onQueue'
180 |     internal var queue_expectedFulfillmentCount: Int {
181 |         get {
182 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                              `- error: cannot infer contextual base in reference to member 'onQueue'
183 |             return _expectedFulfillmentCount
184 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:186:13: error: cannot find 'dispatchPrecondition' in scope
184 |         }
185 |         set {
186 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |             `- error: cannot find 'dispatchPrecondition' in scope
187 |             _expectedFulfillmentCount = newValue
188 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:186:46: error: cannot infer contextual base in reference to member 'onQueue'
184 |         }
185 |         set {
186 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                              `- error: cannot infer contextual base in reference to member 'onQueue'
187 |             _expectedFulfillmentCount = newValue
188 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:192:13: error: cannot find 'dispatchPrecondition' in scope
190 |     internal var queue_isInverted: Bool {
191 |         get {
192 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |             `- error: cannot find 'dispatchPrecondition' in scope
193 |             return _isInverted
194 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:192:46: error: cannot infer contextual base in reference to member 'onQueue'
190 |     internal var queue_isInverted: Bool {
191 |         get {
192 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                              `- error: cannot infer contextual base in reference to member 'onQueue'
193 |             return _isInverted
194 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:196:13: error: cannot find 'dispatchPrecondition' in scope
194 |         }
195 |         set {
196 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |             `- error: cannot find 'dispatchPrecondition' in scope
197 |             _isInverted = newValue
198 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:196:46: error: cannot infer contextual base in reference to member 'onQueue'
194 |         }
195 |         set {
196 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                              `- error: cannot infer contextual base in reference to member 'onQueue'
197 |             _isInverted = newValue
198 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:202:13: error: cannot find 'dispatchPrecondition' in scope
200 |     internal var queue_hasBeenWaitedOn: Bool {
201 |         get {
202 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |             `- error: cannot find 'dispatchPrecondition' in scope
203 |             return _hasBeenWaitedOn
204 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:202:46: error: cannot infer contextual base in reference to member 'onQueue'
200 |     internal var queue_hasBeenWaitedOn: Bool {
201 |         get {
202 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                              `- error: cannot infer contextual base in reference to member 'onQueue'
203 |             return _hasBeenWaitedOn
204 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:206:13: error: cannot find 'dispatchPrecondition' in scope
204 |         }
205 |         set {
206 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |             `- error: cannot find 'dispatchPrecondition' in scope
207 |             _hasBeenWaitedOn = newValue
208 |
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:206:46: error: cannot infer contextual base in reference to member 'onQueue'
204 |         }
205 |         set {
206 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                              `- error: cannot infer contextual base in reference to member 'onQueue'
207 |             _hasBeenWaitedOn = newValue
208 |
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:216:13: error: cannot find 'dispatchPrecondition' in scope
214 |     internal var queue_didFulfillHandler: (() -> Void)? {
215 |         get {
216 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |             `- error: cannot find 'dispatchPrecondition' in scope
217 |             return _didFulfillHandler
218 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:216:46: error: cannot infer contextual base in reference to member 'onQueue'
214 |     internal var queue_didFulfillHandler: (() -> Void)? {
215 |         get {
216 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                              `- error: cannot infer contextual base in reference to member 'onQueue'
217 |             return _didFulfillHandler
218 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:220:13: error: cannot find 'dispatchPrecondition' in scope
218 |         }
219 |         set {
220 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |             `- error: cannot find 'dispatchPrecondition' in scope
221 |             _didFulfillHandler = newValue
222 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:220:46: error: cannot infer contextual base in reference to member 'onQueue'
218 |         }
219 |         set {
220 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                              `- error: cannot infer contextual base in reference to member 'onQueue'
221 |             _didFulfillHandler = newValue
222 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:269:24: error: 'nil' requires a contextual type
267 |                     expected: false)
268 |
269 |                 return nil
    |                        `- error: 'nil' requires a contextual type
270 |             }
271 |
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:283:9: error: cannot find 'dispatchPrecondition' in scope
281 |
282 |     private func queue_fulfill(sourceLocation: SourceLocation) -> Bool {
283 |         dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |         `- error: cannot find 'dispatchPrecondition' in scope
284 |
285 |         numberOfFulfillments += 1
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:283:42: error: cannot infer contextual base in reference to member 'onQueue'
281 |
282 |     private func queue_fulfill(sourceLocation: SourceLocation) -> Bool {
283 |         dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                          `- error: cannot infer contextual base in reference to member 'onQueue'
284 |
285 |         numberOfFulfillments += 1
[29/39] Compiling XCTest XCTestCase+Asynchronous.swift
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:282:10: error: unknown option 'nonsending' for attribute 'nonisolated'
280 |     @available(macOS 12.0, *)
281 |     @discardableResult
282 |     open nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |          `- error: unknown option 'nonsending' for attribute 'nonisolated'
283 |         return await withCheckedContinuation { continuation in
284 |             // This function operates by blocking a background thread instead of one owned by libdispatch or by the
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:332:27: error: expected ':' to begin inheritance clause
330 |     ///   provide this parameter when calling this method.
331 |     @available(macOS 12.0, *)
332 |     open class nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |                           `- error: expected ':' to begin inheritance clause
333 |         return await XCTWaiter().fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
334 |     }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:332:40: error: expected '{' in class
330 |     ///   provide this parameter when calling this method.
331 |     @available(macOS 12.0, *)
332 |     open class nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |                                        `- error: expected '{' in class
333 |         return await XCTWaiter().fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
334 |     }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:332:39: error: consecutive declarations on a line must be separated by ';'
330 |     ///   provide this parameter when calling this method.
331 |     @available(macOS 12.0, *)
332 |     open class nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |                                       `- error: consecutive declarations on a line must be separated by ';'
333 |         return await XCTWaiter().fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
334 |     }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestCase+Asynchronous.swift:116:5: error: unknown option 'nonsending' for attribute 'nonisolated'
114 |     /// - SeeAlso: XCTWaiter
115 |     @available(macOS 12.0, *)
116 |     nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async {
    |     `- error: unknown option 'nonsending' for attribute 'nonisolated'
117 |         let waiter = XCTWaiter(delegate: self)
118 |         await waiter.fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:116:42: error: cannot find 'DispatchQueue' in scope
114 |     }
115 |
116 |     internal static let subsystemQueue = DispatchQueue(label: "org.swift.XCTest.XCTWaiter")
    |                                          `- error: cannot find 'DispatchQueue' in scope
117 |
118 |     private var state = State.ready
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:125:33: error: cannot find 'DispatchQueue' in scope
123 |
124 |     private weak var _delegate: XCTWaiterDelegate?
125 |     private let delegateQueue = DispatchQueue(label: "org.swift.XCTest.XCTWaiter.delegate")
    |                                 `- error: cannot find 'DispatchQueue' in scope
126 |
127 |     /// The waiter delegate will be called with various events described in the `XCTWaiterDelegate` protocol documentation.
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:332:45: error: invalid redeclaration of 'fulfillment(of:timeout:enforceOrder:file:line:)'
330 |     ///   provide this parameter when calling this method.
331 |     @available(macOS 12.0, *)
332 |     open class nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |                                             `- error: invalid redeclaration of 'fulfillment(of:timeout:enforceOrder:file:line:)'
333 |         return await XCTWaiter().fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
334 |     }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:135:13: error: cannot find 'dispatchPrecondition' in scope
133 |         }
134 |         set {
135 |             dispatchPrecondition(condition: .notOnQueue(XCTWaiter.subsystemQueue))
    |             `- error: cannot find 'dispatchPrecondition' in scope
136 |             XCTWaiter.subsystemQueue.async { self._delegate = newValue }
137 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:135:46: error: cannot infer contextual base in reference to member 'notOnQueue'
133 |         }
134 |         set {
135 |             dispatchPrecondition(condition: .notOnQueue(XCTWaiter.subsystemQueue))
    |                                              `- error: cannot infer contextual base in reference to member 'notOnQueue'
136 |             XCTWaiter.subsystemQueue.async { self._delegate = newValue }
137 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:198:31: error: 'current' is unavailable: RunLoop is not available on WASI
196 |         self.timeout = timeout
197 |         waitSourceLocation = SourceLocation(file: file, line: line)
198 |         let runLoop = RunLoop.current
    |                               `- error: 'current' is unavailable: RunLoop is not available on WASI
199 |
200 |         XCTWaiter.subsystemQueue.sync {
Foundation.RunLoop.current:3:18: note: 'current' has been explicitly marked unavailable here
1 | class RunLoop {
2 | @available(*, unavailable, message: "RunLoop is not available on WASI")
3 |   open class var current: RunLoop { get }}
  |                  `- note: 'current' has been explicitly marked unavailable here
4 |
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:287:13: error: cannot find 'Thread' in scope
285 |             // Swift runtime (as used by Swift concurrency.) To ensure we use a thread owned by neither subsystem, use
286 |             // Foundation's Thread.detachNewThread(_:).
287 |             Thread.detachNewThread { [self] in
    |             `- error: cannot find 'Thread' in scope
288 |                 let result = wait(for: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
289 |                 continuation.resume(returning: result)
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:343:9: error: cannot find 'dispatchPrecondition' in scope
341 |
342 |     private func queue_configureExpectations(_ expectations: [XCTestExpectation]) {
343 |         dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |         `- error: cannot find 'dispatchPrecondition' in scope
344 |
345 |         for expectation in expectations {
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:343:42: error: cannot infer contextual base in reference to member 'onQueue'
341 |
342 |     private func queue_configureExpectations(_ expectations: [XCTestExpectation]) {
343 |         dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                          `- error: cannot infer contextual base in reference to member 'onQueue'
344 |
345 |         for expectation in expectations {
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:354:9: error: cannot find 'dispatchPrecondition' in scope
352 |
353 |     private func queue_validateExpectationFulfillment(dueToTimeout: Bool) {
354 |         dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |         `- error: cannot find 'dispatchPrecondition' in scope
355 |         guard case let .waiting(waitingState) = state else { return }
356 |
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:354:42: error: cannot infer contextual base in reference to member 'onQueue'
352 |
353 |     private func queue_validateExpectationFulfillment(dueToTimeout: Bool) {
354 |         dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                          `- error: cannot infer contextual base in reference to member 'onQueue'
355 |         guard case let .waiting(waitingState) = state else { return }
356 |
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:386:9: error: cannot find 'dispatchPrecondition' in scope
384 |
385 |     private func queue_finish(result: Result, cancelPrimitiveWait: Bool, delegateBlock: ((XCTWaiterDelegate) -> Void)? = nil) {
386 |         dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |         `- error: cannot find 'dispatchPrecondition' in scope
387 |         guard case let .waiting(waitingState) = state else { preconditionFailure("Unexpected state: \(state)") }
388 |
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:386:42: error: cannot infer contextual base in reference to member 'onQueue'
384 |
385 |     private func queue_finish(result: Result, cancelPrimitiveWait: Bool, delegateBlock: ((XCTWaiterDelegate) -> Void)? = nil) {
386 |         dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                          `- error: cannot infer contextual base in reference to member 'onQueue'
387 |         guard case let .waiting(waitingState) = state else { preconditionFailure("Unexpected state: \(state)") }
388 |
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:428:21: error: value of type 'RunLoop' has no member 'run'
426 |
427 |         // RunLoop.run(mode:before:) should have @discardableResult <rdar://problem/45371901>
428 |         _ = runLoop.run(mode: .default, before: Date(timeIntervalSinceNow: timeIntervalToRun))
    |                     `- error: value of type 'RunLoop' has no member 'run'
429 |     }
430 |
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:428:32: error: cannot infer contextual base in reference to member 'default'
426 |
427 |         // RunLoop.run(mode:before:) should have @discardableResult <rdar://problem/45371901>
428 |         _ = runLoop.run(mode: .default, before: Date(timeIntervalSinceNow: timeIntervalToRun))
    |                                `- error: cannot infer contextual base in reference to member 'default'
429 |     }
430 |
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:436:17: error: value of type 'RunLoop' has no member '_stop'
434 |         CFRunLoopStop(runLoop.getCFRunLoop())
435 | #else
436 |         runLoop._stop()
    |                 `- error: value of type 'RunLoop' has no member '_stop'
437 | #endif
438 |     }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:468:9: error: cannot find 'dispatchPrecondition' in scope
466 |
467 |     func queue_handleWatchdogTimeout() {
468 |         dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |         `- error: cannot find 'dispatchPrecondition' in scope
469 |
470 |         queue_validateExpectationFulfillment(dueToTimeout: true)
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:468:42: error: cannot infer contextual base in reference to member 'onQueue'
466 |
467 |     func queue_handleWatchdogTimeout() {
468 |         dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                          `- error: cannot infer contextual base in reference to member 'onQueue'
469 |
470 |         queue_validateExpectationFulfillment(dueToTimeout: true)
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:476:9: error: cannot find 'dispatchPrecondition' in scope
474 |
475 |     func queue_interrupt(for interruptingWaiter: XCTWaiter) {
476 |         dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |         `- error: cannot find 'dispatchPrecondition' in scope
477 |
478 |         queue_finish(result: .interrupted, cancelPrimitiveWait: true) { delegate in
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:476:42: error: cannot infer contextual base in reference to member 'onQueue'
474 |
475 |     func queue_interrupt(for interruptingWaiter: XCTWaiter) {
476 |         dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                          `- error: cannot infer contextual base in reference to member 'onQueue'
477 |
478 |         queue_finish(result: .interrupted, cancelPrimitiveWait: true) { delegate in
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestCase+Asynchronous.swift:163:134: error: cannot find type 'NotificationCenter' in scope
161 |     ///   handler to further investigate if the notification fulfills the
162 |     ///   expectation.
163 |     @discardableResult func expectation(forNotification notificationName: Notification.Name, object: Any? = nil, notificationCenter: NotificationCenter = .default, file: StaticString = #file, line: Int = #line, handler: XCTNSNotificationExpectation.Handler? = nil) -> XCTestExpectation {
    |                                                                                                                                      `- error: cannot find type 'NotificationCenter' in scope
164 |         let expectation = XCTNSNotificationExpectation(name: notificationName, object: object, notificationCenter: notificationCenter, file: file, line: line)
165 |         expectation.handler = handler
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestCase+Asynchronous.swift:184:123: error: cannot find type 'NotificationCenter' in scope
182 |     ///   handler to further investigate if the notification fulfills the
183 |     ///   expectation.
184 |     @discardableResult func expectation(forNotification notificationName: String, object: Any? = nil, notificationCenter: NotificationCenter = .default, file: StaticString = #file, line: Int = #line, handler: XCTNSNotificationExpectation.Handler? = nil) -> XCTestExpectation {
    |                                                                                                                           `- error: cannot find type 'NotificationCenter' in scope
185 |         return expectation(forNotification: Notification.Name(rawValue: notificationName), object: object, notificationCenter: notificationCenter, file: file, line: line, handler: handler)
186 |     }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestCase+Asynchronous.swift:48:22: error: cannot find 'Thread' in scope
 46 |     @preconcurrency @MainActor
 47 |     func waitForExpectations(timeout: TimeInterval, file: StaticString = #file, line: Int = #line, handler: XCWaitCompletionHandler? = nil) {
 48 |         precondition(Thread.isMainThread, "\(#function) must be called on the main thread")
    |                      `- error: cannot find 'Thread' in scope
 49 |         if currentWaiter != nil {
 50 |             return recordFailure(description: "API violation - calling wait on test case while already waiting.", at: SourceLocation(file: file, line: line), expected: false)
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTNSNotificationExpectation.swift:69:99: error: cannot find type 'NotificationCenter' in scope
 67 |     ///   number of the call to this method in the calling file. It is rare to
 68 |     ///   provide this parameter when calling this method.
 69 |     public init(name notificationName: Notification.Name, object: Any? = nil, notificationCenter: NotificationCenter = .default, file: StaticString = #file, line: Int = #line) {
    |                                                                                                   `- error: cannot find type 'NotificationCenter' in scope
 70 |         self.notificationName = notificationName
 71 |         self.observedObject = object
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestCase+Asynchronous.swift:185:27: error: extra arguments at positions #1, #2, #3 in call
183 |     ///   expectation.
184 |     @discardableResult func expectation(forNotification notificationName: String, object: Any? = nil, notificationCenter: NotificationCenter = .default, file: StaticString = #file, line: Int = #line, handler: XCTNSNotificationExpectation.Handler? = nil) -> XCTestExpectation {
185 |         return expectation(forNotification: Notification.Name(rawValue: notificationName), object: object, notificationCenter: notificationCenter, file: file, line: line, handler: handler)
    |                           `- error: extra arguments at positions #1, #2, #3 in call
186 |     }
187 |
    :
208 |     ///   the handler can override that behavior which leaves the caller
209 |     ///   responsible for fulfilling the expectation.
210 |     @discardableResult func expectation(for predicate: NSPredicate, evaluatedWith object: Any? = nil, file: StaticString = #file, line: Int = #line, handler: XCTNSPredicateExpectation.Handler? = nil) -> XCTestExpectation {
    |                             `- note: 'expectation(for:evaluatedWith:file:line:handler:)' declared here
211 |         let expectation = XCTNSPredicateExpectation(predicate: predicate, object: object, file: file, line: line)
212 |         expectation.handler = handler
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestCase+Asynchronous.swift:185:28: error: missing argument for parameter 'for' in call
183 |     ///   expectation.
184 |     @discardableResult func expectation(forNotification notificationName: String, object: Any? = nil, notificationCenter: NotificationCenter = .default, file: StaticString = #file, line: Int = #line, handler: XCTNSNotificationExpectation.Handler? = nil) -> XCTestExpectation {
185 |         return expectation(forNotification: Notification.Name(rawValue: notificationName), object: object, notificationCenter: notificationCenter, file: file, line: line, handler: handler)
    |                            `- error: missing argument for parameter 'for' in call
186 |     }
187 |
    :
208 |     ///   the handler can override that behavior which leaves the caller
209 |     ///   responsible for fulfilling the expectation.
210 |     @discardableResult func expectation(for predicate: NSPredicate, evaluatedWith object: Any? = nil, file: StaticString = #file, line: Int = #line, handler: XCTNSPredicateExpectation.Handler? = nil) -> XCTestExpectation {
    |                             `- note: 'expectation(for:evaluatedWith:file:line:handler:)' declared here
211 |         let expectation = XCTNSPredicateExpectation(predicate: predicate, object: object, file: file, line: line)
212 |         expectation.handler = handler
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestCase+Asynchronous.swift:185:181: error: cannot convert value of type 'XCTNSNotificationExpectation.Handler?' (aka 'Optional<@Sendable (Notification) -> Bool>') to expected argument type 'XCTNSPredicateExpectation.Handler?' (aka 'Optional<@Sendable () -> Bool>')
183 |     ///   expectation.
184 |     @discardableResult func expectation(forNotification notificationName: String, object: Any? = nil, notificationCenter: NotificationCenter = .default, file: StaticString = #file, line: Int = #line, handler: XCTNSNotificationExpectation.Handler? = nil) -> XCTestExpectation {
185 |         return expectation(forNotification: Notification.Name(rawValue: notificationName), object: object, notificationCenter: notificationCenter, file: file, line: line, handler: handler)
    |                                                                                                                                                                                     `- error: cannot convert value of type 'XCTNSNotificationExpectation.Handler?' (aka 'Optional<@Sendable (Notification) -> Bool>') to expected argument type 'XCTNSPredicateExpectation.Handler?' (aka 'Optional<@Sendable () -> Bool>')
186 |     }
187 |
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:19:9: error: cannot find 'dispatchPrecondition' in scope
 17 |     private static var currentMonotonicallyIncreasingToken: UInt64 = 0
 18 |     private static func queue_nextMonotonicallyIncreasingToken() -> UInt64 {
 19 |         dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |         `- error: cannot find 'dispatchPrecondition' in scope
 20 |         currentMonotonicallyIncreasingToken += 1
 21 |         return currentMonotonicallyIncreasingToken
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:19:42: error: cannot infer contextual base in reference to member 'onQueue'
 17 |     private static var currentMonotonicallyIncreasingToken: UInt64 = 0
 18 |     private static func queue_nextMonotonicallyIncreasingToken() -> UInt64 {
 19 |         dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                          `- error: cannot infer contextual base in reference to member 'onQueue'
 20 |         currentMonotonicallyIncreasingToken += 1
 21 |         return currentMonotonicallyIncreasingToken
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:152:13: error: cannot find 'dispatchPrecondition' in scope
150 |     internal var queue_expectationDescription: String {
151 |         get {
152 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |             `- error: cannot find 'dispatchPrecondition' in scope
153 |             return _expectationDescription
154 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:152:46: error: cannot infer contextual base in reference to member 'onQueue'
150 |     internal var queue_expectationDescription: String {
151 |         get {
152 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                              `- error: cannot infer contextual base in reference to member 'onQueue'
153 |             return _expectationDescription
154 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:156:13: error: cannot find 'dispatchPrecondition' in scope
154 |         }
155 |         set {
156 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |             `- error: cannot find 'dispatchPrecondition' in scope
157 |             _expectationDescription = newValue
158 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:156:46: error: cannot infer contextual base in reference to member 'onQueue'
154 |         }
155 |         set {
156 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                              `- error: cannot infer contextual base in reference to member 'onQueue'
157 |             _expectationDescription = newValue
158 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:162:13: error: cannot find 'dispatchPrecondition' in scope
160 |     internal var queue_isFulfilled: Bool {
161 |         get {
162 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |             `- error: cannot find 'dispatchPrecondition' in scope
163 |             return isFulfilled
164 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:162:46: error: cannot infer contextual base in reference to member 'onQueue'
160 |     internal var queue_isFulfilled: Bool {
161 |         get {
162 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                              `- error: cannot infer contextual base in reference to member 'onQueue'
163 |             return isFulfilled
164 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:166:13: error: cannot find 'dispatchPrecondition' in scope
164 |         }
165 |         set {
166 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |             `- error: cannot find 'dispatchPrecondition' in scope
167 |             isFulfilled = newValue
168 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:166:46: error: cannot infer contextual base in reference to member 'onQueue'
164 |         }
165 |         set {
166 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                              `- error: cannot infer contextual base in reference to member 'onQueue'
167 |             isFulfilled = newValue
168 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:172:13: error: cannot find 'dispatchPrecondition' in scope
170 |     internal var queue_fulfillmentToken: UInt64 {
171 |         get {
172 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |             `- error: cannot find 'dispatchPrecondition' in scope
173 |             return fulfillmentToken
174 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:172:46: error: cannot infer contextual base in reference to member 'onQueue'
170 |     internal var queue_fulfillmentToken: UInt64 {
171 |         get {
172 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                              `- error: cannot infer contextual base in reference to member 'onQueue'
173 |             return fulfillmentToken
174 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:176:13: error: cannot find 'dispatchPrecondition' in scope
174 |         }
175 |         set {
176 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |             `- error: cannot find 'dispatchPrecondition' in scope
177 |             fulfillmentToken = newValue
178 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:176:46: error: cannot infer contextual base in reference to member 'onQueue'
174 |         }
175 |         set {
176 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                              `- error: cannot infer contextual base in reference to member 'onQueue'
177 |             fulfillmentToken = newValue
178 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:182:13: error: cannot find 'dispatchPrecondition' in scope
180 |     internal var queue_expectedFulfillmentCount: Int {
181 |         get {
182 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |             `- error: cannot find 'dispatchPrecondition' in scope
183 |             return _expectedFulfillmentCount
184 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:182:46: error: cannot infer contextual base in reference to member 'onQueue'
180 |     internal var queue_expectedFulfillmentCount: Int {
181 |         get {
182 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                              `- error: cannot infer contextual base in reference to member 'onQueue'
183 |             return _expectedFulfillmentCount
184 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:186:13: error: cannot find 'dispatchPrecondition' in scope
184 |         }
185 |         set {
186 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |             `- error: cannot find 'dispatchPrecondition' in scope
187 |             _expectedFulfillmentCount = newValue
188 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:186:46: error: cannot infer contextual base in reference to member 'onQueue'
184 |         }
185 |         set {
186 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                              `- error: cannot infer contextual base in reference to member 'onQueue'
187 |             _expectedFulfillmentCount = newValue
188 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:192:13: error: cannot find 'dispatchPrecondition' in scope
190 |     internal var queue_isInverted: Bool {
191 |         get {
192 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |             `- error: cannot find 'dispatchPrecondition' in scope
193 |             return _isInverted
194 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:192:46: error: cannot infer contextual base in reference to member 'onQueue'
190 |     internal var queue_isInverted: Bool {
191 |         get {
192 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                              `- error: cannot infer contextual base in reference to member 'onQueue'
193 |             return _isInverted
194 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:196:13: error: cannot find 'dispatchPrecondition' in scope
194 |         }
195 |         set {
196 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |             `- error: cannot find 'dispatchPrecondition' in scope
197 |             _isInverted = newValue
198 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:196:46: error: cannot infer contextual base in reference to member 'onQueue'
194 |         }
195 |         set {
196 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                              `- error: cannot infer contextual base in reference to member 'onQueue'
197 |             _isInverted = newValue
198 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:202:13: error: cannot find 'dispatchPrecondition' in scope
200 |     internal var queue_hasBeenWaitedOn: Bool {
201 |         get {
202 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |             `- error: cannot find 'dispatchPrecondition' in scope
203 |             return _hasBeenWaitedOn
204 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:202:46: error: cannot infer contextual base in reference to member 'onQueue'
200 |     internal var queue_hasBeenWaitedOn: Bool {
201 |         get {
202 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                              `- error: cannot infer contextual base in reference to member 'onQueue'
203 |             return _hasBeenWaitedOn
204 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:206:13: error: cannot find 'dispatchPrecondition' in scope
204 |         }
205 |         set {
206 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |             `- error: cannot find 'dispatchPrecondition' in scope
207 |             _hasBeenWaitedOn = newValue
208 |
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:206:46: error: cannot infer contextual base in reference to member 'onQueue'
204 |         }
205 |         set {
206 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                              `- error: cannot infer contextual base in reference to member 'onQueue'
207 |             _hasBeenWaitedOn = newValue
208 |
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:216:13: error: cannot find 'dispatchPrecondition' in scope
214 |     internal var queue_didFulfillHandler: (() -> Void)? {
215 |         get {
216 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |             `- error: cannot find 'dispatchPrecondition' in scope
217 |             return _didFulfillHandler
218 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:216:46: error: cannot infer contextual base in reference to member 'onQueue'
214 |     internal var queue_didFulfillHandler: (() -> Void)? {
215 |         get {
216 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                              `- error: cannot infer contextual base in reference to member 'onQueue'
217 |             return _didFulfillHandler
218 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:220:13: error: cannot find 'dispatchPrecondition' in scope
218 |         }
219 |         set {
220 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |             `- error: cannot find 'dispatchPrecondition' in scope
221 |             _didFulfillHandler = newValue
222 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:220:46: error: cannot infer contextual base in reference to member 'onQueue'
218 |         }
219 |         set {
220 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                              `- error: cannot infer contextual base in reference to member 'onQueue'
221 |             _didFulfillHandler = newValue
222 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:269:24: error: 'nil' requires a contextual type
267 |                     expected: false)
268 |
269 |                 return nil
    |                        `- error: 'nil' requires a contextual type
270 |             }
271 |
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:283:9: error: cannot find 'dispatchPrecondition' in scope
281 |
282 |     private func queue_fulfill(sourceLocation: SourceLocation) -> Bool {
283 |         dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |         `- error: cannot find 'dispatchPrecondition' in scope
284 |
285 |         numberOfFulfillments += 1
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:283:42: error: cannot infer contextual base in reference to member 'onQueue'
281 |
282 |     private func queue_fulfill(sourceLocation: SourceLocation) -> Bool {
283 |         dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                          `- error: cannot infer contextual base in reference to member 'onQueue'
284 |
285 |         numberOfFulfillments += 1
[30/39] Compiling XCTest XCTestExpectation.swift
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:282:10: error: unknown option 'nonsending' for attribute 'nonisolated'
280 |     @available(macOS 12.0, *)
281 |     @discardableResult
282 |     open nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |          `- error: unknown option 'nonsending' for attribute 'nonisolated'
283 |         return await withCheckedContinuation { continuation in
284 |             // This function operates by blocking a background thread instead of one owned by libdispatch or by the
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:332:27: error: expected ':' to begin inheritance clause
330 |     ///   provide this parameter when calling this method.
331 |     @available(macOS 12.0, *)
332 |     open class nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |                           `- error: expected ':' to begin inheritance clause
333 |         return await XCTWaiter().fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
334 |     }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:332:40: error: expected '{' in class
330 |     ///   provide this parameter when calling this method.
331 |     @available(macOS 12.0, *)
332 |     open class nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |                                        `- error: expected '{' in class
333 |         return await XCTWaiter().fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
334 |     }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:332:39: error: consecutive declarations on a line must be separated by ';'
330 |     ///   provide this parameter when calling this method.
331 |     @available(macOS 12.0, *)
332 |     open class nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |                                       `- error: consecutive declarations on a line must be separated by ';'
333 |         return await XCTWaiter().fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
334 |     }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestCase+Asynchronous.swift:116:5: error: unknown option 'nonsending' for attribute 'nonisolated'
114 |     /// - SeeAlso: XCTWaiter
115 |     @available(macOS 12.0, *)
116 |     nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async {
    |     `- error: unknown option 'nonsending' for attribute 'nonisolated'
117 |         let waiter = XCTWaiter(delegate: self)
118 |         await waiter.fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:116:42: error: cannot find 'DispatchQueue' in scope
114 |     }
115 |
116 |     internal static let subsystemQueue = DispatchQueue(label: "org.swift.XCTest.XCTWaiter")
    |                                          `- error: cannot find 'DispatchQueue' in scope
117 |
118 |     private var state = State.ready
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:125:33: error: cannot find 'DispatchQueue' in scope
123 |
124 |     private weak var _delegate: XCTWaiterDelegate?
125 |     private let delegateQueue = DispatchQueue(label: "org.swift.XCTest.XCTWaiter.delegate")
    |                                 `- error: cannot find 'DispatchQueue' in scope
126 |
127 |     /// The waiter delegate will be called with various events described in the `XCTWaiterDelegate` protocol documentation.
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:332:45: error: invalid redeclaration of 'fulfillment(of:timeout:enforceOrder:file:line:)'
330 |     ///   provide this parameter when calling this method.
331 |     @available(macOS 12.0, *)
332 |     open class nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |                                             `- error: invalid redeclaration of 'fulfillment(of:timeout:enforceOrder:file:line:)'
333 |         return await XCTWaiter().fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
334 |     }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:135:13: error: cannot find 'dispatchPrecondition' in scope
133 |         }
134 |         set {
135 |             dispatchPrecondition(condition: .notOnQueue(XCTWaiter.subsystemQueue))
    |             `- error: cannot find 'dispatchPrecondition' in scope
136 |             XCTWaiter.subsystemQueue.async { self._delegate = newValue }
137 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:135:46: error: cannot infer contextual base in reference to member 'notOnQueue'
133 |         }
134 |         set {
135 |             dispatchPrecondition(condition: .notOnQueue(XCTWaiter.subsystemQueue))
    |                                              `- error: cannot infer contextual base in reference to member 'notOnQueue'
136 |             XCTWaiter.subsystemQueue.async { self._delegate = newValue }
137 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:198:31: error: 'current' is unavailable: RunLoop is not available on WASI
196 |         self.timeout = timeout
197 |         waitSourceLocation = SourceLocation(file: file, line: line)
198 |         let runLoop = RunLoop.current
    |                               `- error: 'current' is unavailable: RunLoop is not available on WASI
199 |
200 |         XCTWaiter.subsystemQueue.sync {
Foundation.RunLoop.current:3:18: note: 'current' has been explicitly marked unavailable here
1 | class RunLoop {
2 | @available(*, unavailable, message: "RunLoop is not available on WASI")
3 |   open class var current: RunLoop { get }}
  |                  `- note: 'current' has been explicitly marked unavailable here
4 |
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:287:13: error: cannot find 'Thread' in scope
285 |             // Swift runtime (as used by Swift concurrency.) To ensure we use a thread owned by neither subsystem, use
286 |             // Foundation's Thread.detachNewThread(_:).
287 |             Thread.detachNewThread { [self] in
    |             `- error: cannot find 'Thread' in scope
288 |                 let result = wait(for: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
289 |                 continuation.resume(returning: result)
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:343:9: error: cannot find 'dispatchPrecondition' in scope
341 |
342 |     private func queue_configureExpectations(_ expectations: [XCTestExpectation]) {
343 |         dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |         `- error: cannot find 'dispatchPrecondition' in scope
344 |
345 |         for expectation in expectations {
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:343:42: error: cannot infer contextual base in reference to member 'onQueue'
341 |
342 |     private func queue_configureExpectations(_ expectations: [XCTestExpectation]) {
343 |         dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                          `- error: cannot infer contextual base in reference to member 'onQueue'
344 |
345 |         for expectation in expectations {
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:354:9: error: cannot find 'dispatchPrecondition' in scope
352 |
353 |     private func queue_validateExpectationFulfillment(dueToTimeout: Bool) {
354 |         dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |         `- error: cannot find 'dispatchPrecondition' in scope
355 |         guard case let .waiting(waitingState) = state else { return }
356 |
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:354:42: error: cannot infer contextual base in reference to member 'onQueue'
352 |
353 |     private func queue_validateExpectationFulfillment(dueToTimeout: Bool) {
354 |         dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                          `- error: cannot infer contextual base in reference to member 'onQueue'
355 |         guard case let .waiting(waitingState) = state else { return }
356 |
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:386:9: error: cannot find 'dispatchPrecondition' in scope
384 |
385 |     private func queue_finish(result: Result, cancelPrimitiveWait: Bool, delegateBlock: ((XCTWaiterDelegate) -> Void)? = nil) {
386 |         dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |         `- error: cannot find 'dispatchPrecondition' in scope
387 |         guard case let .waiting(waitingState) = state else { preconditionFailure("Unexpected state: \(state)") }
388 |
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:386:42: error: cannot infer contextual base in reference to member 'onQueue'
384 |
385 |     private func queue_finish(result: Result, cancelPrimitiveWait: Bool, delegateBlock: ((XCTWaiterDelegate) -> Void)? = nil) {
386 |         dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                          `- error: cannot infer contextual base in reference to member 'onQueue'
387 |         guard case let .waiting(waitingState) = state else { preconditionFailure("Unexpected state: \(state)") }
388 |
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:428:21: error: value of type 'RunLoop' has no member 'run'
426 |
427 |         // RunLoop.run(mode:before:) should have @discardableResult <rdar://problem/45371901>
428 |         _ = runLoop.run(mode: .default, before: Date(timeIntervalSinceNow: timeIntervalToRun))
    |                     `- error: value of type 'RunLoop' has no member 'run'
429 |     }
430 |
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:428:32: error: cannot infer contextual base in reference to member 'default'
426 |
427 |         // RunLoop.run(mode:before:) should have @discardableResult <rdar://problem/45371901>
428 |         _ = runLoop.run(mode: .default, before: Date(timeIntervalSinceNow: timeIntervalToRun))
    |                                `- error: cannot infer contextual base in reference to member 'default'
429 |     }
430 |
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:436:17: error: value of type 'RunLoop' has no member '_stop'
434 |         CFRunLoopStop(runLoop.getCFRunLoop())
435 | #else
436 |         runLoop._stop()
    |                 `- error: value of type 'RunLoop' has no member '_stop'
437 | #endif
438 |     }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:468:9: error: cannot find 'dispatchPrecondition' in scope
466 |
467 |     func queue_handleWatchdogTimeout() {
468 |         dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |         `- error: cannot find 'dispatchPrecondition' in scope
469 |
470 |         queue_validateExpectationFulfillment(dueToTimeout: true)
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:468:42: error: cannot infer contextual base in reference to member 'onQueue'
466 |
467 |     func queue_handleWatchdogTimeout() {
468 |         dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                          `- error: cannot infer contextual base in reference to member 'onQueue'
469 |
470 |         queue_validateExpectationFulfillment(dueToTimeout: true)
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:476:9: error: cannot find 'dispatchPrecondition' in scope
474 |
475 |     func queue_interrupt(for interruptingWaiter: XCTWaiter) {
476 |         dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |         `- error: cannot find 'dispatchPrecondition' in scope
477 |
478 |         queue_finish(result: .interrupted, cancelPrimitiveWait: true) { delegate in
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:476:42: error: cannot infer contextual base in reference to member 'onQueue'
474 |
475 |     func queue_interrupt(for interruptingWaiter: XCTWaiter) {
476 |         dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                          `- error: cannot infer contextual base in reference to member 'onQueue'
477 |
478 |         queue_finish(result: .interrupted, cancelPrimitiveWait: true) { delegate in
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestCase+Asynchronous.swift:163:134: error: cannot find type 'NotificationCenter' in scope
161 |     ///   handler to further investigate if the notification fulfills the
162 |     ///   expectation.
163 |     @discardableResult func expectation(forNotification notificationName: Notification.Name, object: Any? = nil, notificationCenter: NotificationCenter = .default, file: StaticString = #file, line: Int = #line, handler: XCTNSNotificationExpectation.Handler? = nil) -> XCTestExpectation {
    |                                                                                                                                      `- error: cannot find type 'NotificationCenter' in scope
164 |         let expectation = XCTNSNotificationExpectation(name: notificationName, object: object, notificationCenter: notificationCenter, file: file, line: line)
165 |         expectation.handler = handler
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestCase+Asynchronous.swift:184:123: error: cannot find type 'NotificationCenter' in scope
182 |     ///   handler to further investigate if the notification fulfills the
183 |     ///   expectation.
184 |     @discardableResult func expectation(forNotification notificationName: String, object: Any? = nil, notificationCenter: NotificationCenter = .default, file: StaticString = #file, line: Int = #line, handler: XCTNSNotificationExpectation.Handler? = nil) -> XCTestExpectation {
    |                                                                                                                           `- error: cannot find type 'NotificationCenter' in scope
185 |         return expectation(forNotification: Notification.Name(rawValue: notificationName), object: object, notificationCenter: notificationCenter, file: file, line: line, handler: handler)
186 |     }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestCase+Asynchronous.swift:48:22: error: cannot find 'Thread' in scope
 46 |     @preconcurrency @MainActor
 47 |     func waitForExpectations(timeout: TimeInterval, file: StaticString = #file, line: Int = #line, handler: XCWaitCompletionHandler? = nil) {
 48 |         precondition(Thread.isMainThread, "\(#function) must be called on the main thread")
    |                      `- error: cannot find 'Thread' in scope
 49 |         if currentWaiter != nil {
 50 |             return recordFailure(description: "API violation - calling wait on test case while already waiting.", at: SourceLocation(file: file, line: line), expected: false)
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTNSNotificationExpectation.swift:69:99: error: cannot find type 'NotificationCenter' in scope
 67 |     ///   number of the call to this method in the calling file. It is rare to
 68 |     ///   provide this parameter when calling this method.
 69 |     public init(name notificationName: Notification.Name, object: Any? = nil, notificationCenter: NotificationCenter = .default, file: StaticString = #file, line: Int = #line) {
    |                                                                                                   `- error: cannot find type 'NotificationCenter' in scope
 70 |         self.notificationName = notificationName
 71 |         self.observedObject = object
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestCase+Asynchronous.swift:185:27: error: extra arguments at positions #1, #2, #3 in call
183 |     ///   expectation.
184 |     @discardableResult func expectation(forNotification notificationName: String, object: Any? = nil, notificationCenter: NotificationCenter = .default, file: StaticString = #file, line: Int = #line, handler: XCTNSNotificationExpectation.Handler? = nil) -> XCTestExpectation {
185 |         return expectation(forNotification: Notification.Name(rawValue: notificationName), object: object, notificationCenter: notificationCenter, file: file, line: line, handler: handler)
    |                           `- error: extra arguments at positions #1, #2, #3 in call
186 |     }
187 |
    :
208 |     ///   the handler can override that behavior which leaves the caller
209 |     ///   responsible for fulfilling the expectation.
210 |     @discardableResult func expectation(for predicate: NSPredicate, evaluatedWith object: Any? = nil, file: StaticString = #file, line: Int = #line, handler: XCTNSPredicateExpectation.Handler? = nil) -> XCTestExpectation {
    |                             `- note: 'expectation(for:evaluatedWith:file:line:handler:)' declared here
211 |         let expectation = XCTNSPredicateExpectation(predicate: predicate, object: object, file: file, line: line)
212 |         expectation.handler = handler
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestCase+Asynchronous.swift:185:28: error: missing argument for parameter 'for' in call
183 |     ///   expectation.
184 |     @discardableResult func expectation(forNotification notificationName: String, object: Any? = nil, notificationCenter: NotificationCenter = .default, file: StaticString = #file, line: Int = #line, handler: XCTNSNotificationExpectation.Handler? = nil) -> XCTestExpectation {
185 |         return expectation(forNotification: Notification.Name(rawValue: notificationName), object: object, notificationCenter: notificationCenter, file: file, line: line, handler: handler)
    |                            `- error: missing argument for parameter 'for' in call
186 |     }
187 |
    :
208 |     ///   the handler can override that behavior which leaves the caller
209 |     ///   responsible for fulfilling the expectation.
210 |     @discardableResult func expectation(for predicate: NSPredicate, evaluatedWith object: Any? = nil, file: StaticString = #file, line: Int = #line, handler: XCTNSPredicateExpectation.Handler? = nil) -> XCTestExpectation {
    |                             `- note: 'expectation(for:evaluatedWith:file:line:handler:)' declared here
211 |         let expectation = XCTNSPredicateExpectation(predicate: predicate, object: object, file: file, line: line)
212 |         expectation.handler = handler
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestCase+Asynchronous.swift:185:181: error: cannot convert value of type 'XCTNSNotificationExpectation.Handler?' (aka 'Optional<@Sendable (Notification) -> Bool>') to expected argument type 'XCTNSPredicateExpectation.Handler?' (aka 'Optional<@Sendable () -> Bool>')
183 |     ///   expectation.
184 |     @discardableResult func expectation(forNotification notificationName: String, object: Any? = nil, notificationCenter: NotificationCenter = .default, file: StaticString = #file, line: Int = #line, handler: XCTNSNotificationExpectation.Handler? = nil) -> XCTestExpectation {
185 |         return expectation(forNotification: Notification.Name(rawValue: notificationName), object: object, notificationCenter: notificationCenter, file: file, line: line, handler: handler)
    |                                                                                                                                                                                     `- error: cannot convert value of type 'XCTNSNotificationExpectation.Handler?' (aka 'Optional<@Sendable (Notification) -> Bool>') to expected argument type 'XCTNSPredicateExpectation.Handler?' (aka 'Optional<@Sendable () -> Bool>')
186 |     }
187 |
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:19:9: error: cannot find 'dispatchPrecondition' in scope
 17 |     private static var currentMonotonicallyIncreasingToken: UInt64 = 0
 18 |     private static func queue_nextMonotonicallyIncreasingToken() -> UInt64 {
 19 |         dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |         `- error: cannot find 'dispatchPrecondition' in scope
 20 |         currentMonotonicallyIncreasingToken += 1
 21 |         return currentMonotonicallyIncreasingToken
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:19:42: error: cannot infer contextual base in reference to member 'onQueue'
 17 |     private static var currentMonotonicallyIncreasingToken: UInt64 = 0
 18 |     private static func queue_nextMonotonicallyIncreasingToken() -> UInt64 {
 19 |         dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                          `- error: cannot infer contextual base in reference to member 'onQueue'
 20 |         currentMonotonicallyIncreasingToken += 1
 21 |         return currentMonotonicallyIncreasingToken
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:152:13: error: cannot find 'dispatchPrecondition' in scope
150 |     internal var queue_expectationDescription: String {
151 |         get {
152 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |             `- error: cannot find 'dispatchPrecondition' in scope
153 |             return _expectationDescription
154 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:152:46: error: cannot infer contextual base in reference to member 'onQueue'
150 |     internal var queue_expectationDescription: String {
151 |         get {
152 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                              `- error: cannot infer contextual base in reference to member 'onQueue'
153 |             return _expectationDescription
154 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:156:13: error: cannot find 'dispatchPrecondition' in scope
154 |         }
155 |         set {
156 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |             `- error: cannot find 'dispatchPrecondition' in scope
157 |             _expectationDescription = newValue
158 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:156:46: error: cannot infer contextual base in reference to member 'onQueue'
154 |         }
155 |         set {
156 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                              `- error: cannot infer contextual base in reference to member 'onQueue'
157 |             _expectationDescription = newValue
158 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:162:13: error: cannot find 'dispatchPrecondition' in scope
160 |     internal var queue_isFulfilled: Bool {
161 |         get {
162 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |             `- error: cannot find 'dispatchPrecondition' in scope
163 |             return isFulfilled
164 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:162:46: error: cannot infer contextual base in reference to member 'onQueue'
160 |     internal var queue_isFulfilled: Bool {
161 |         get {
162 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                              `- error: cannot infer contextual base in reference to member 'onQueue'
163 |             return isFulfilled
164 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:166:13: error: cannot find 'dispatchPrecondition' in scope
164 |         }
165 |         set {
166 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |             `- error: cannot find 'dispatchPrecondition' in scope
167 |             isFulfilled = newValue
168 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:166:46: error: cannot infer contextual base in reference to member 'onQueue'
164 |         }
165 |         set {
166 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                              `- error: cannot infer contextual base in reference to member 'onQueue'
167 |             isFulfilled = newValue
168 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:172:13: error: cannot find 'dispatchPrecondition' in scope
170 |     internal var queue_fulfillmentToken: UInt64 {
171 |         get {
172 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |             `- error: cannot find 'dispatchPrecondition' in scope
173 |             return fulfillmentToken
174 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:172:46: error: cannot infer contextual base in reference to member 'onQueue'
170 |     internal var queue_fulfillmentToken: UInt64 {
171 |         get {
172 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                              `- error: cannot infer contextual base in reference to member 'onQueue'
173 |             return fulfillmentToken
174 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:176:13: error: cannot find 'dispatchPrecondition' in scope
174 |         }
175 |         set {
176 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |             `- error: cannot find 'dispatchPrecondition' in scope
177 |             fulfillmentToken = newValue
178 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:176:46: error: cannot infer contextual base in reference to member 'onQueue'
174 |         }
175 |         set {
176 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                              `- error: cannot infer contextual base in reference to member 'onQueue'
177 |             fulfillmentToken = newValue
178 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:182:13: error: cannot find 'dispatchPrecondition' in scope
180 |     internal var queue_expectedFulfillmentCount: Int {
181 |         get {
182 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |             `- error: cannot find 'dispatchPrecondition' in scope
183 |             return _expectedFulfillmentCount
184 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:182:46: error: cannot infer contextual base in reference to member 'onQueue'
180 |     internal var queue_expectedFulfillmentCount: Int {
181 |         get {
182 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                              `- error: cannot infer contextual base in reference to member 'onQueue'
183 |             return _expectedFulfillmentCount
184 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:186:13: error: cannot find 'dispatchPrecondition' in scope
184 |         }
185 |         set {
186 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |             `- error: cannot find 'dispatchPrecondition' in scope
187 |             _expectedFulfillmentCount = newValue
188 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:186:46: error: cannot infer contextual base in reference to member 'onQueue'
184 |         }
185 |         set {
186 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                              `- error: cannot infer contextual base in reference to member 'onQueue'
187 |             _expectedFulfillmentCount = newValue
188 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:192:13: error: cannot find 'dispatchPrecondition' in scope
190 |     internal var queue_isInverted: Bool {
191 |         get {
192 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |             `- error: cannot find 'dispatchPrecondition' in scope
193 |             return _isInverted
194 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:192:46: error: cannot infer contextual base in reference to member 'onQueue'
190 |     internal var queue_isInverted: Bool {
191 |         get {
192 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                              `- error: cannot infer contextual base in reference to member 'onQueue'
193 |             return _isInverted
194 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:196:13: error: cannot find 'dispatchPrecondition' in scope
194 |         }
195 |         set {
196 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |             `- error: cannot find 'dispatchPrecondition' in scope
197 |             _isInverted = newValue
198 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:196:46: error: cannot infer contextual base in reference to member 'onQueue'
194 |         }
195 |         set {
196 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                              `- error: cannot infer contextual base in reference to member 'onQueue'
197 |             _isInverted = newValue
198 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:202:13: error: cannot find 'dispatchPrecondition' in scope
200 |     internal var queue_hasBeenWaitedOn: Bool {
201 |         get {
202 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |             `- error: cannot find 'dispatchPrecondition' in scope
203 |             return _hasBeenWaitedOn
204 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:202:46: error: cannot infer contextual base in reference to member 'onQueue'
200 |     internal var queue_hasBeenWaitedOn: Bool {
201 |         get {
202 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                              `- error: cannot infer contextual base in reference to member 'onQueue'
203 |             return _hasBeenWaitedOn
204 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:206:13: error: cannot find 'dispatchPrecondition' in scope
204 |         }
205 |         set {
206 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |             `- error: cannot find 'dispatchPrecondition' in scope
207 |             _hasBeenWaitedOn = newValue
208 |
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:206:46: error: cannot infer contextual base in reference to member 'onQueue'
204 |         }
205 |         set {
206 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                              `- error: cannot infer contextual base in reference to member 'onQueue'
207 |             _hasBeenWaitedOn = newValue
208 |
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:216:13: error: cannot find 'dispatchPrecondition' in scope
214 |     internal var queue_didFulfillHandler: (() -> Void)? {
215 |         get {
216 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |             `- error: cannot find 'dispatchPrecondition' in scope
217 |             return _didFulfillHandler
218 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:216:46: error: cannot infer contextual base in reference to member 'onQueue'
214 |     internal var queue_didFulfillHandler: (() -> Void)? {
215 |         get {
216 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                              `- error: cannot infer contextual base in reference to member 'onQueue'
217 |             return _didFulfillHandler
218 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:220:13: error: cannot find 'dispatchPrecondition' in scope
218 |         }
219 |         set {
220 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |             `- error: cannot find 'dispatchPrecondition' in scope
221 |             _didFulfillHandler = newValue
222 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:220:46: error: cannot infer contextual base in reference to member 'onQueue'
218 |         }
219 |         set {
220 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                              `- error: cannot infer contextual base in reference to member 'onQueue'
221 |             _didFulfillHandler = newValue
222 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:269:24: error: 'nil' requires a contextual type
267 |                     expected: false)
268 |
269 |                 return nil
    |                        `- error: 'nil' requires a contextual type
270 |             }
271 |
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:283:9: error: cannot find 'dispatchPrecondition' in scope
281 |
282 |     private func queue_fulfill(sourceLocation: SourceLocation) -> Bool {
283 |         dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |         `- error: cannot find 'dispatchPrecondition' in scope
284 |
285 |         numberOfFulfillments += 1
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:283:42: error: cannot infer contextual base in reference to member 'onQueue'
281 |
282 |     private func queue_fulfill(sourceLocation: SourceLocation) -> Bool {
283 |         dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                          `- error: cannot infer contextual base in reference to member 'onQueue'
284 |
285 |         numberOfFulfillments += 1
[31/39] Compiling XCTest XCAbstractTest.swift
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:282:10: error: unknown option 'nonsending' for attribute 'nonisolated'
280 |     @available(macOS 12.0, *)
281 |     @discardableResult
282 |     open nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |          `- error: unknown option 'nonsending' for attribute 'nonisolated'
283 |         return await withCheckedContinuation { continuation in
284 |             // This function operates by blocking a background thread instead of one owned by libdispatch or by the
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:332:27: error: expected ':' to begin inheritance clause
330 |     ///   provide this parameter when calling this method.
331 |     @available(macOS 12.0, *)
332 |     open class nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |                           `- error: expected ':' to begin inheritance clause
333 |         return await XCTWaiter().fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
334 |     }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:332:40: error: expected '{' in class
330 |     ///   provide this parameter when calling this method.
331 |     @available(macOS 12.0, *)
332 |     open class nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |                                        `- error: expected '{' in class
333 |         return await XCTWaiter().fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
334 |     }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:332:39: error: consecutive declarations on a line must be separated by ';'
330 |     ///   provide this parameter when calling this method.
331 |     @available(macOS 12.0, *)
332 |     open class nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |                                       `- error: consecutive declarations on a line must be separated by ';'
333 |         return await XCTWaiter().fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
334 |     }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestCase+Asynchronous.swift:116:5: error: unknown option 'nonsending' for attribute 'nonisolated'
114 |     /// - SeeAlso: XCTWaiter
115 |     @available(macOS 12.0, *)
116 |     nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async {
    |     `- error: unknown option 'nonsending' for attribute 'nonisolated'
117 |         let waiter = XCTWaiter(delegate: self)
118 |         await waiter.fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:116:42: error: cannot find 'DispatchQueue' in scope
114 |     }
115 |
116 |     internal static let subsystemQueue = DispatchQueue(label: "org.swift.XCTest.XCTWaiter")
    |                                          `- error: cannot find 'DispatchQueue' in scope
117 |
118 |     private var state = State.ready
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:125:33: error: cannot find 'DispatchQueue' in scope
123 |
124 |     private weak var _delegate: XCTWaiterDelegate?
125 |     private let delegateQueue = DispatchQueue(label: "org.swift.XCTest.XCTWaiter.delegate")
    |                                 `- error: cannot find 'DispatchQueue' in scope
126 |
127 |     /// The waiter delegate will be called with various events described in the `XCTWaiterDelegate` protocol documentation.
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:332:45: error: invalid redeclaration of 'fulfillment(of:timeout:enforceOrder:file:line:)'
330 |     ///   provide this parameter when calling this method.
331 |     @available(macOS 12.0, *)
332 |     open class nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |                                             `- error: invalid redeclaration of 'fulfillment(of:timeout:enforceOrder:file:line:)'
333 |         return await XCTWaiter().fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
334 |     }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:135:13: error: cannot find 'dispatchPrecondition' in scope
133 |         }
134 |         set {
135 |             dispatchPrecondition(condition: .notOnQueue(XCTWaiter.subsystemQueue))
    |             `- error: cannot find 'dispatchPrecondition' in scope
136 |             XCTWaiter.subsystemQueue.async { self._delegate = newValue }
137 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:135:46: error: cannot infer contextual base in reference to member 'notOnQueue'
133 |         }
134 |         set {
135 |             dispatchPrecondition(condition: .notOnQueue(XCTWaiter.subsystemQueue))
    |                                              `- error: cannot infer contextual base in reference to member 'notOnQueue'
136 |             XCTWaiter.subsystemQueue.async { self._delegate = newValue }
137 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:198:31: error: 'current' is unavailable: RunLoop is not available on WASI
196 |         self.timeout = timeout
197 |         waitSourceLocation = SourceLocation(file: file, line: line)
198 |         let runLoop = RunLoop.current
    |                               `- error: 'current' is unavailable: RunLoop is not available on WASI
199 |
200 |         XCTWaiter.subsystemQueue.sync {
Foundation.RunLoop.current:3:18: note: 'current' has been explicitly marked unavailable here
1 | class RunLoop {
2 | @available(*, unavailable, message: "RunLoop is not available on WASI")
3 |   open class var current: RunLoop { get }}
  |                  `- note: 'current' has been explicitly marked unavailable here
4 |
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:287:13: error: cannot find 'Thread' in scope
285 |             // Swift runtime (as used by Swift concurrency.) To ensure we use a thread owned by neither subsystem, use
286 |             // Foundation's Thread.detachNewThread(_:).
287 |             Thread.detachNewThread { [self] in
    |             `- error: cannot find 'Thread' in scope
288 |                 let result = wait(for: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
289 |                 continuation.resume(returning: result)
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:343:9: error: cannot find 'dispatchPrecondition' in scope
341 |
342 |     private func queue_configureExpectations(_ expectations: [XCTestExpectation]) {
343 |         dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |         `- error: cannot find 'dispatchPrecondition' in scope
344 |
345 |         for expectation in expectations {
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:343:42: error: cannot infer contextual base in reference to member 'onQueue'
341 |
342 |     private func queue_configureExpectations(_ expectations: [XCTestExpectation]) {
343 |         dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                          `- error: cannot infer contextual base in reference to member 'onQueue'
344 |
345 |         for expectation in expectations {
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:354:9: error: cannot find 'dispatchPrecondition' in scope
352 |
353 |     private func queue_validateExpectationFulfillment(dueToTimeout: Bool) {
354 |         dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |         `- error: cannot find 'dispatchPrecondition' in scope
355 |         guard case let .waiting(waitingState) = state else { return }
356 |
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:354:42: error: cannot infer contextual base in reference to member 'onQueue'
352 |
353 |     private func queue_validateExpectationFulfillment(dueToTimeout: Bool) {
354 |         dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                          `- error: cannot infer contextual base in reference to member 'onQueue'
355 |         guard case let .waiting(waitingState) = state else { return }
356 |
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:386:9: error: cannot find 'dispatchPrecondition' in scope
384 |
385 |     private func queue_finish(result: Result, cancelPrimitiveWait: Bool, delegateBlock: ((XCTWaiterDelegate) -> Void)? = nil) {
386 |         dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |         `- error: cannot find 'dispatchPrecondition' in scope
387 |         guard case let .waiting(waitingState) = state else { preconditionFailure("Unexpected state: \(state)") }
388 |
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:386:42: error: cannot infer contextual base in reference to member 'onQueue'
384 |
385 |     private func queue_finish(result: Result, cancelPrimitiveWait: Bool, delegateBlock: ((XCTWaiterDelegate) -> Void)? = nil) {
386 |         dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                          `- error: cannot infer contextual base in reference to member 'onQueue'
387 |         guard case let .waiting(waitingState) = state else { preconditionFailure("Unexpected state: \(state)") }
388 |
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:428:21: error: value of type 'RunLoop' has no member 'run'
426 |
427 |         // RunLoop.run(mode:before:) should have @discardableResult <rdar://problem/45371901>
428 |         _ = runLoop.run(mode: .default, before: Date(timeIntervalSinceNow: timeIntervalToRun))
    |                     `- error: value of type 'RunLoop' has no member 'run'
429 |     }
430 |
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:428:32: error: cannot infer contextual base in reference to member 'default'
426 |
427 |         // RunLoop.run(mode:before:) should have @discardableResult <rdar://problem/45371901>
428 |         _ = runLoop.run(mode: .default, before: Date(timeIntervalSinceNow: timeIntervalToRun))
    |                                `- error: cannot infer contextual base in reference to member 'default'
429 |     }
430 |
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:436:17: error: value of type 'RunLoop' has no member '_stop'
434 |         CFRunLoopStop(runLoop.getCFRunLoop())
435 | #else
436 |         runLoop._stop()
    |                 `- error: value of type 'RunLoop' has no member '_stop'
437 | #endif
438 |     }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:468:9: error: cannot find 'dispatchPrecondition' in scope
466 |
467 |     func queue_handleWatchdogTimeout() {
468 |         dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |         `- error: cannot find 'dispatchPrecondition' in scope
469 |
470 |         queue_validateExpectationFulfillment(dueToTimeout: true)
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:468:42: error: cannot infer contextual base in reference to member 'onQueue'
466 |
467 |     func queue_handleWatchdogTimeout() {
468 |         dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                          `- error: cannot infer contextual base in reference to member 'onQueue'
469 |
470 |         queue_validateExpectationFulfillment(dueToTimeout: true)
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:476:9: error: cannot find 'dispatchPrecondition' in scope
474 |
475 |     func queue_interrupt(for interruptingWaiter: XCTWaiter) {
476 |         dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |         `- error: cannot find 'dispatchPrecondition' in scope
477 |
478 |         queue_finish(result: .interrupted, cancelPrimitiveWait: true) { delegate in
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:476:42: error: cannot infer contextual base in reference to member 'onQueue'
474 |
475 |     func queue_interrupt(for interruptingWaiter: XCTWaiter) {
476 |         dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                          `- error: cannot infer contextual base in reference to member 'onQueue'
477 |
478 |         queue_finish(result: .interrupted, cancelPrimitiveWait: true) { delegate in
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestCase+Asynchronous.swift:163:134: error: cannot find type 'NotificationCenter' in scope
161 |     ///   handler to further investigate if the notification fulfills the
162 |     ///   expectation.
163 |     @discardableResult func expectation(forNotification notificationName: Notification.Name, object: Any? = nil, notificationCenter: NotificationCenter = .default, file: StaticString = #file, line: Int = #line, handler: XCTNSNotificationExpectation.Handler? = nil) -> XCTestExpectation {
    |                                                                                                                                      `- error: cannot find type 'NotificationCenter' in scope
164 |         let expectation = XCTNSNotificationExpectation(name: notificationName, object: object, notificationCenter: notificationCenter, file: file, line: line)
165 |         expectation.handler = handler
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestCase+Asynchronous.swift:184:123: error: cannot find type 'NotificationCenter' in scope
182 |     ///   handler to further investigate if the notification fulfills the
183 |     ///   expectation.
184 |     @discardableResult func expectation(forNotification notificationName: String, object: Any? = nil, notificationCenter: NotificationCenter = .default, file: StaticString = #file, line: Int = #line, handler: XCTNSNotificationExpectation.Handler? = nil) -> XCTestExpectation {
    |                                                                                                                           `- error: cannot find type 'NotificationCenter' in scope
185 |         return expectation(forNotification: Notification.Name(rawValue: notificationName), object: object, notificationCenter: notificationCenter, file: file, line: line, handler: handler)
186 |     }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestCase+Asynchronous.swift:48:22: error: cannot find 'Thread' in scope
 46 |     @preconcurrency @MainActor
 47 |     func waitForExpectations(timeout: TimeInterval, file: StaticString = #file, line: Int = #line, handler: XCWaitCompletionHandler? = nil) {
 48 |         precondition(Thread.isMainThread, "\(#function) must be called on the main thread")
    |                      `- error: cannot find 'Thread' in scope
 49 |         if currentWaiter != nil {
 50 |             return recordFailure(description: "API violation - calling wait on test case while already waiting.", at: SourceLocation(file: file, line: line), expected: false)
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTNSNotificationExpectation.swift:69:99: error: cannot find type 'NotificationCenter' in scope
 67 |     ///   number of the call to this method in the calling file. It is rare to
 68 |     ///   provide this parameter when calling this method.
 69 |     public init(name notificationName: Notification.Name, object: Any? = nil, notificationCenter: NotificationCenter = .default, file: StaticString = #file, line: Int = #line) {
    |                                                                                                   `- error: cannot find type 'NotificationCenter' in scope
 70 |         self.notificationName = notificationName
 71 |         self.observedObject = object
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestCase+Asynchronous.swift:185:27: error: extra arguments at positions #1, #2, #3 in call
183 |     ///   expectation.
184 |     @discardableResult func expectation(forNotification notificationName: String, object: Any? = nil, notificationCenter: NotificationCenter = .default, file: StaticString = #file, line: Int = #line, handler: XCTNSNotificationExpectation.Handler? = nil) -> XCTestExpectation {
185 |         return expectation(forNotification: Notification.Name(rawValue: notificationName), object: object, notificationCenter: notificationCenter, file: file, line: line, handler: handler)
    |                           `- error: extra arguments at positions #1, #2, #3 in call
186 |     }
187 |
    :
208 |     ///   the handler can override that behavior which leaves the caller
209 |     ///   responsible for fulfilling the expectation.
210 |     @discardableResult func expectation(for predicate: NSPredicate, evaluatedWith object: Any? = nil, file: StaticString = #file, line: Int = #line, handler: XCTNSPredicateExpectation.Handler? = nil) -> XCTestExpectation {
    |                             `- note: 'expectation(for:evaluatedWith:file:line:handler:)' declared here
211 |         let expectation = XCTNSPredicateExpectation(predicate: predicate, object: object, file: file, line: line)
212 |         expectation.handler = handler
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestCase+Asynchronous.swift:185:28: error: missing argument for parameter 'for' in call
183 |     ///   expectation.
184 |     @discardableResult func expectation(forNotification notificationName: String, object: Any? = nil, notificationCenter: NotificationCenter = .default, file: StaticString = #file, line: Int = #line, handler: XCTNSNotificationExpectation.Handler? = nil) -> XCTestExpectation {
185 |         return expectation(forNotification: Notification.Name(rawValue: notificationName), object: object, notificationCenter: notificationCenter, file: file, line: line, handler: handler)
    |                            `- error: missing argument for parameter 'for' in call
186 |     }
187 |
    :
208 |     ///   the handler can override that behavior which leaves the caller
209 |     ///   responsible for fulfilling the expectation.
210 |     @discardableResult func expectation(for predicate: NSPredicate, evaluatedWith object: Any? = nil, file: StaticString = #file, line: Int = #line, handler: XCTNSPredicateExpectation.Handler? = nil) -> XCTestExpectation {
    |                             `- note: 'expectation(for:evaluatedWith:file:line:handler:)' declared here
211 |         let expectation = XCTNSPredicateExpectation(predicate: predicate, object: object, file: file, line: line)
212 |         expectation.handler = handler
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestCase+Asynchronous.swift:185:181: error: cannot convert value of type 'XCTNSNotificationExpectation.Handler?' (aka 'Optional<@Sendable (Notification) -> Bool>') to expected argument type 'XCTNSPredicateExpectation.Handler?' (aka 'Optional<@Sendable () -> Bool>')
183 |     ///   expectation.
184 |     @discardableResult func expectation(forNotification notificationName: String, object: Any? = nil, notificationCenter: NotificationCenter = .default, file: StaticString = #file, line: Int = #line, handler: XCTNSNotificationExpectation.Handler? = nil) -> XCTestExpectation {
185 |         return expectation(forNotification: Notification.Name(rawValue: notificationName), object: object, notificationCenter: notificationCenter, file: file, line: line, handler: handler)
    |                                                                                                                                                                                     `- error: cannot convert value of type 'XCTNSNotificationExpectation.Handler?' (aka 'Optional<@Sendable (Notification) -> Bool>') to expected argument type 'XCTNSPredicateExpectation.Handler?' (aka 'Optional<@Sendable () -> Bool>')
186 |     }
187 |
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:19:9: error: cannot find 'dispatchPrecondition' in scope
 17 |     private static var currentMonotonicallyIncreasingToken: UInt64 = 0
 18 |     private static func queue_nextMonotonicallyIncreasingToken() -> UInt64 {
 19 |         dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |         `- error: cannot find 'dispatchPrecondition' in scope
 20 |         currentMonotonicallyIncreasingToken += 1
 21 |         return currentMonotonicallyIncreasingToken
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:19:42: error: cannot infer contextual base in reference to member 'onQueue'
 17 |     private static var currentMonotonicallyIncreasingToken: UInt64 = 0
 18 |     private static func queue_nextMonotonicallyIncreasingToken() -> UInt64 {
 19 |         dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                          `- error: cannot infer contextual base in reference to member 'onQueue'
 20 |         currentMonotonicallyIncreasingToken += 1
 21 |         return currentMonotonicallyIncreasingToken
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:152:13: error: cannot find 'dispatchPrecondition' in scope
150 |     internal var queue_expectationDescription: String {
151 |         get {
152 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |             `- error: cannot find 'dispatchPrecondition' in scope
153 |             return _expectationDescription
154 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:152:46: error: cannot infer contextual base in reference to member 'onQueue'
150 |     internal var queue_expectationDescription: String {
151 |         get {
152 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                              `- error: cannot infer contextual base in reference to member 'onQueue'
153 |             return _expectationDescription
154 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:156:13: error: cannot find 'dispatchPrecondition' in scope
154 |         }
155 |         set {
156 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |             `- error: cannot find 'dispatchPrecondition' in scope
157 |             _expectationDescription = newValue
158 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:156:46: error: cannot infer contextual base in reference to member 'onQueue'
154 |         }
155 |         set {
156 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                              `- error: cannot infer contextual base in reference to member 'onQueue'
157 |             _expectationDescription = newValue
158 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:162:13: error: cannot find 'dispatchPrecondition' in scope
160 |     internal var queue_isFulfilled: Bool {
161 |         get {
162 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |             `- error: cannot find 'dispatchPrecondition' in scope
163 |             return isFulfilled
164 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:162:46: error: cannot infer contextual base in reference to member 'onQueue'
160 |     internal var queue_isFulfilled: Bool {
161 |         get {
162 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                              `- error: cannot infer contextual base in reference to member 'onQueue'
163 |             return isFulfilled
164 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:166:13: error: cannot find 'dispatchPrecondition' in scope
164 |         }
165 |         set {
166 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |             `- error: cannot find 'dispatchPrecondition' in scope
167 |             isFulfilled = newValue
168 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:166:46: error: cannot infer contextual base in reference to member 'onQueue'
164 |         }
165 |         set {
166 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                              `- error: cannot infer contextual base in reference to member 'onQueue'
167 |             isFulfilled = newValue
168 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:172:13: error: cannot find 'dispatchPrecondition' in scope
170 |     internal var queue_fulfillmentToken: UInt64 {
171 |         get {
172 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |             `- error: cannot find 'dispatchPrecondition' in scope
173 |             return fulfillmentToken
174 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:172:46: error: cannot infer contextual base in reference to member 'onQueue'
170 |     internal var queue_fulfillmentToken: UInt64 {
171 |         get {
172 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                              `- error: cannot infer contextual base in reference to member 'onQueue'
173 |             return fulfillmentToken
174 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:176:13: error: cannot find 'dispatchPrecondition' in scope
174 |         }
175 |         set {
176 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |             `- error: cannot find 'dispatchPrecondition' in scope
177 |             fulfillmentToken = newValue
178 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:176:46: error: cannot infer contextual base in reference to member 'onQueue'
174 |         }
175 |         set {
176 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                              `- error: cannot infer contextual base in reference to member 'onQueue'
177 |             fulfillmentToken = newValue
178 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:182:13: error: cannot find 'dispatchPrecondition' in scope
180 |     internal var queue_expectedFulfillmentCount: Int {
181 |         get {
182 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |             `- error: cannot find 'dispatchPrecondition' in scope
183 |             return _expectedFulfillmentCount
184 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:182:46: error: cannot infer contextual base in reference to member 'onQueue'
180 |     internal var queue_expectedFulfillmentCount: Int {
181 |         get {
182 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                              `- error: cannot infer contextual base in reference to member 'onQueue'
183 |             return _expectedFulfillmentCount
184 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:186:13: error: cannot find 'dispatchPrecondition' in scope
184 |         }
185 |         set {
186 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |             `- error: cannot find 'dispatchPrecondition' in scope
187 |             _expectedFulfillmentCount = newValue
188 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:186:46: error: cannot infer contextual base in reference to member 'onQueue'
184 |         }
185 |         set {
186 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                              `- error: cannot infer contextual base in reference to member 'onQueue'
187 |             _expectedFulfillmentCount = newValue
188 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:192:13: error: cannot find 'dispatchPrecondition' in scope
190 |     internal var queue_isInverted: Bool {
191 |         get {
192 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |             `- error: cannot find 'dispatchPrecondition' in scope
193 |             return _isInverted
194 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:192:46: error: cannot infer contextual base in reference to member 'onQueue'
190 |     internal var queue_isInverted: Bool {
191 |         get {
192 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                              `- error: cannot infer contextual base in reference to member 'onQueue'
193 |             return _isInverted
194 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:196:13: error: cannot find 'dispatchPrecondition' in scope
194 |         }
195 |         set {
196 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |             `- error: cannot find 'dispatchPrecondition' in scope
197 |             _isInverted = newValue
198 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:196:46: error: cannot infer contextual base in reference to member 'onQueue'
194 |         }
195 |         set {
196 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                              `- error: cannot infer contextual base in reference to member 'onQueue'
197 |             _isInverted = newValue
198 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:202:13: error: cannot find 'dispatchPrecondition' in scope
200 |     internal var queue_hasBeenWaitedOn: Bool {
201 |         get {
202 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |             `- error: cannot find 'dispatchPrecondition' in scope
203 |             return _hasBeenWaitedOn
204 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:202:46: error: cannot infer contextual base in reference to member 'onQueue'
200 |     internal var queue_hasBeenWaitedOn: Bool {
201 |         get {
202 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                              `- error: cannot infer contextual base in reference to member 'onQueue'
203 |             return _hasBeenWaitedOn
204 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:206:13: error: cannot find 'dispatchPrecondition' in scope
204 |         }
205 |         set {
206 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |             `- error: cannot find 'dispatchPrecondition' in scope
207 |             _hasBeenWaitedOn = newValue
208 |
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:206:46: error: cannot infer contextual base in reference to member 'onQueue'
204 |         }
205 |         set {
206 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                              `- error: cannot infer contextual base in reference to member 'onQueue'
207 |             _hasBeenWaitedOn = newValue
208 |
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:216:13: error: cannot find 'dispatchPrecondition' in scope
214 |     internal var queue_didFulfillHandler: (() -> Void)? {
215 |         get {
216 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |             `- error: cannot find 'dispatchPrecondition' in scope
217 |             return _didFulfillHandler
218 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:216:46: error: cannot infer contextual base in reference to member 'onQueue'
214 |     internal var queue_didFulfillHandler: (() -> Void)? {
215 |         get {
216 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                              `- error: cannot infer contextual base in reference to member 'onQueue'
217 |             return _didFulfillHandler
218 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:220:13: error: cannot find 'dispatchPrecondition' in scope
218 |         }
219 |         set {
220 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |             `- error: cannot find 'dispatchPrecondition' in scope
221 |             _didFulfillHandler = newValue
222 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:220:46: error: cannot infer contextual base in reference to member 'onQueue'
218 |         }
219 |         set {
220 |             dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                              `- error: cannot infer contextual base in reference to member 'onQueue'
221 |             _didFulfillHandler = newValue
222 |         }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:269:24: error: 'nil' requires a contextual type
267 |                     expected: false)
268 |
269 |                 return nil
    |                        `- error: 'nil' requires a contextual type
270 |             }
271 |
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:283:9: error: cannot find 'dispatchPrecondition' in scope
281 |
282 |     private func queue_fulfill(sourceLocation: SourceLocation) -> Bool {
283 |         dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |         `- error: cannot find 'dispatchPrecondition' in scope
284 |
285 |         numberOfFulfillments += 1
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestExpectation.swift:283:42: error: cannot infer contextual base in reference to member 'onQueue'
281 |
282 |     private func queue_fulfill(sourceLocation: SourceLocation) -> Bool {
283 |         dispatchPrecondition(condition: .onQueue(XCTWaiter.subsystemQueue))
    |                                          `- error: cannot infer contextual base in reference to member 'onQueue'
284 |
285 |         numberOfFulfillments += 1
[32/39] Compiling XCTest PerformanceMeter.swift
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:282:10: error: unknown option 'nonsending' for attribute 'nonisolated'
280 |     @available(macOS 12.0, *)
281 |     @discardableResult
282 |     open nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |          `- error: unknown option 'nonsending' for attribute 'nonisolated'
283 |         return await withCheckedContinuation { continuation in
284 |             // This function operates by blocking a background thread instead of one owned by libdispatch or by the
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:332:27: error: expected ':' to begin inheritance clause
330 |     ///   provide this parameter when calling this method.
331 |     @available(macOS 12.0, *)
332 |     open class nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |                           `- error: expected ':' to begin inheritance clause
333 |         return await XCTWaiter().fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
334 |     }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:332:40: error: expected '{' in class
330 |     ///   provide this parameter when calling this method.
331 |     @available(macOS 12.0, *)
332 |     open class nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |                                        `- error: expected '{' in class
333 |         return await XCTWaiter().fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
334 |     }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:332:39: error: consecutive declarations on a line must be separated by ';'
330 |     ///   provide this parameter when calling this method.
331 |     @available(macOS 12.0, *)
332 |     open class nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |                                       `- error: consecutive declarations on a line must be separated by ';'
333 |         return await XCTWaiter().fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
334 |     }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestCase+Asynchronous.swift:116:5: error: unknown option 'nonsending' for attribute 'nonisolated'
114 |     /// - SeeAlso: XCTWaiter
115 |     @available(macOS 12.0, *)
116 |     nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async {
    |     `- error: unknown option 'nonsending' for attribute 'nonisolated'
117 |         let waiter = XCTWaiter(delegate: self)
118 |         await waiter.fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
[33/39] Compiling XCTest PrintObserver.swift
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:282:10: error: unknown option 'nonsending' for attribute 'nonisolated'
280 |     @available(macOS 12.0, *)
281 |     @discardableResult
282 |     open nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |          `- error: unknown option 'nonsending' for attribute 'nonisolated'
283 |         return await withCheckedContinuation { continuation in
284 |             // This function operates by blocking a background thread instead of one owned by libdispatch or by the
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:332:27: error: expected ':' to begin inheritance clause
330 |     ///   provide this parameter when calling this method.
331 |     @available(macOS 12.0, *)
332 |     open class nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |                           `- error: expected ':' to begin inheritance clause
333 |         return await XCTWaiter().fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
334 |     }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:332:40: error: expected '{' in class
330 |     ///   provide this parameter when calling this method.
331 |     @available(macOS 12.0, *)
332 |     open class nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |                                        `- error: expected '{' in class
333 |         return await XCTWaiter().fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
334 |     }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:332:39: error: consecutive declarations on a line must be separated by ';'
330 |     ///   provide this parameter when calling this method.
331 |     @available(macOS 12.0, *)
332 |     open class nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |                                       `- error: consecutive declarations on a line must be separated by ';'
333 |         return await XCTWaiter().fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
334 |     }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestCase+Asynchronous.swift:116:5: error: unknown option 'nonsending' for attribute 'nonisolated'
114 |     /// - SeeAlso: XCTWaiter
115 |     @available(macOS 12.0, *)
116 |     nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async {
    |     `- error: unknown option 'nonsending' for attribute 'nonisolated'
117 |         let waiter = XCTWaiter(delegate: self)
118 |         await waiter.fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
[34/39] Compiling XCTest SourceLocation.swift
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:282:10: error: unknown option 'nonsending' for attribute 'nonisolated'
280 |     @available(macOS 12.0, *)
281 |     @discardableResult
282 |     open nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |          `- error: unknown option 'nonsending' for attribute 'nonisolated'
283 |         return await withCheckedContinuation { continuation in
284 |             // This function operates by blocking a background thread instead of one owned by libdispatch or by the
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:332:27: error: expected ':' to begin inheritance clause
330 |     ///   provide this parameter when calling this method.
331 |     @available(macOS 12.0, *)
332 |     open class nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |                           `- error: expected ':' to begin inheritance clause
333 |         return await XCTWaiter().fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
334 |     }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:332:40: error: expected '{' in class
330 |     ///   provide this parameter when calling this method.
331 |     @available(macOS 12.0, *)
332 |     open class nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |                                        `- error: expected '{' in class
333 |         return await XCTWaiter().fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
334 |     }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:332:39: error: consecutive declarations on a line must be separated by ';'
330 |     ///   provide this parameter when calling this method.
331 |     @available(macOS 12.0, *)
332 |     open class nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |                                       `- error: consecutive declarations on a line must be separated by ';'
333 |         return await XCTWaiter().fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
334 |     }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestCase+Asynchronous.swift:116:5: error: unknown option 'nonsending' for attribute 'nonisolated'
114 |     /// - SeeAlso: XCTWaiter
115 |     @available(macOS 12.0, *)
116 |     nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async {
    |     `- error: unknown option 'nonsending' for attribute 'nonisolated'
117 |         let waiter = XCTWaiter(delegate: self)
118 |         await waiter.fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
[35/39] Compiling XCTest TestFiltering.swift
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:282:10: error: unknown option 'nonsending' for attribute 'nonisolated'
280 |     @available(macOS 12.0, *)
281 |     @discardableResult
282 |     open nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |          `- error: unknown option 'nonsending' for attribute 'nonisolated'
283 |         return await withCheckedContinuation { continuation in
284 |             // This function operates by blocking a background thread instead of one owned by libdispatch or by the
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:332:27: error: expected ':' to begin inheritance clause
330 |     ///   provide this parameter when calling this method.
331 |     @available(macOS 12.0, *)
332 |     open class nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |                           `- error: expected ':' to begin inheritance clause
333 |         return await XCTWaiter().fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
334 |     }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:332:40: error: expected '{' in class
330 |     ///   provide this parameter when calling this method.
331 |     @available(macOS 12.0, *)
332 |     open class nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |                                        `- error: expected '{' in class
333 |         return await XCTWaiter().fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
334 |     }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:332:39: error: consecutive declarations on a line must be separated by ';'
330 |     ///   provide this parameter when calling this method.
331 |     @available(macOS 12.0, *)
332 |     open class nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |                                       `- error: consecutive declarations on a line must be separated by ';'
333 |         return await XCTWaiter().fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
334 |     }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestCase+Asynchronous.swift:116:5: error: unknown option 'nonsending' for attribute 'nonisolated'
114 |     /// - SeeAlso: XCTWaiter
115 |     @available(macOS 12.0, *)
116 |     nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async {
    |     `- error: unknown option 'nonsending' for attribute 'nonisolated'
117 |         let waiter = XCTWaiter(delegate: self)
118 |         await waiter.fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
[36/39] Compiling XCTest TestListing.swift
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:282:10: error: unknown option 'nonsending' for attribute 'nonisolated'
280 |     @available(macOS 12.0, *)
281 |     @discardableResult
282 |     open nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |          `- error: unknown option 'nonsending' for attribute 'nonisolated'
283 |         return await withCheckedContinuation { continuation in
284 |             // This function operates by blocking a background thread instead of one owned by libdispatch or by the
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:332:27: error: expected ':' to begin inheritance clause
330 |     ///   provide this parameter when calling this method.
331 |     @available(macOS 12.0, *)
332 |     open class nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |                           `- error: expected ':' to begin inheritance clause
333 |         return await XCTWaiter().fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
334 |     }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:332:40: error: expected '{' in class
330 |     ///   provide this parameter when calling this method.
331 |     @available(macOS 12.0, *)
332 |     open class nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |                                        `- error: expected '{' in class
333 |         return await XCTWaiter().fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
334 |     }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTWaiter.swift:332:39: error: consecutive declarations on a line must be separated by ';'
330 |     ///   provide this parameter when calling this method.
331 |     @available(macOS 12.0, *)
332 |     open class nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async -> Result {
    |                                       `- error: consecutive declarations on a line must be separated by ';'
333 |         return await XCTWaiter().fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
334 |     }
/host/spi-builder-workspace/Sources/XCTest/Public/Asynchronous/XCTestCase+Asynchronous.swift:116:5: error: unknown option 'nonsending' for attribute 'nonisolated'
114 |     /// - SeeAlso: XCTWaiter
115 |     @available(macOS 12.0, *)
116 |     nonisolated(nonsending) func fulfillment(of expectations: [XCTestExpectation], timeout: TimeInterval, enforceOrder: Bool = false, file: StaticString = #file, line: Int = #line) async {
    |     `- error: unknown option 'nonsending' for attribute 'nonisolated'
117 |         let waiter = XCTWaiter(delegate: self)
118 |         await waiter.fulfillment(of: expectations, timeout: timeout, enforceOrder: enforceOrder, file: file, line: line)
BUILD FAILURE 6.1 wasm