Correct build failures while updating to 6.2 swift build modes

phausler · phausler · commit f5a80d436833 · 2025-09-08T08:56:15.000-07:00
diff --git a/Package.swift b/Package.swift
@@ -1,4 +1,4 @@
-// swift-tools-version: 5.8
+// swift-tools-version: 6.2
 
 import PackageDescription
 import CompilerPluginSupport
diff --git a/Sources/AsyncAlgorithms/Buffer/AsyncBufferSequence.swift b/Sources/AsyncAlgorithms/Buffer/AsyncBufferSequence.swift
@@ -121,9 +121,9 @@ public struct AsyncBufferSequence<Base: AsyncSequence & Sendable>: AsyncSequence
         self.storageType = .transparent(iterator)
         return element
       case .bounded(let storage):
-        return try await storage.next()?._rethrowGet()
+        return try await storage.next().wrapped?._rethrowGet()
       case .unbounded(let storage):
-        return try await storage.next()?._rethrowGet()
+        return try await storage.next().wrapped?._rethrowGet()
       }
     }
   }
diff --git a/Sources/AsyncAlgorithms/Buffer/BoundedBufferStateMachine.swift b/Sources/AsyncAlgorithms/Buffer/BoundedBufferStateMachine.swift
@@ -15,7 +15,7 @@ import DequeModule
 struct BoundedBufferStateMachine<Base: AsyncSequence> {
   typealias Element = Base.Element
   typealias SuspendedProducer = UnsafeContinuation<Void, Never>
-  typealias SuspendedConsumer = UnsafeContinuation<Result<Base.Element, Error>?, Never>
+  typealias SuspendedConsumer = UnsafeContinuation<UnsafeTransfer<Result<Base.Element, Error>?>, Never>
 
   // We are using UnsafeTransfer here since we have to get the elements from the task
   // into the consumer task. This is a transfer but we cannot prove this to the compiler at this point
@@ -137,7 +137,7 @@ struct BoundedBufferStateMachine<Base: AsyncSequence> {
 
   enum ElementProducedAction {
     case none
-    case resumeConsumer(continuation: SuspendedConsumer, result: Result<Element, Error>)
+    case resumeConsumer(continuation: SuspendedConsumer, result: UnsafeTransfer<Result<Base.Element, Error>?>)
   }
 
   mutating func elementProduced(element: Element) -> ElementProducedAction {
@@ -161,7 +161,7 @@ struct BoundedBufferStateMachine<Base: AsyncSequence> {
       // we have an awaiting consumer, we can resume it with the element and exit
       precondition(buffer.isEmpty, "Invalid state. The buffer should be empty.")
       self.state = .buffering(task: task, buffer: buffer, suspendedProducer: nil, suspendedConsumer: nil)
-      return .resumeConsumer(continuation: suspendedConsumer, result: .success(element))
+      return .resumeConsumer(continuation: suspendedConsumer, result: UnsafeTransfer(.success(element)))
 
     case .buffering(_, _, .some, _):
       preconditionFailure("Invalid state. There should not be a suspended producer.")
@@ -177,7 +177,7 @@ struct BoundedBufferStateMachine<Base: AsyncSequence> {
   enum FinishAction {
     case none
     case resumeConsumer(
-      continuation: UnsafeContinuation<Result<Base.Element, Error>?, Never>?
+      continuation: UnsafeContinuation<UnsafeTransfer<Result<Base.Element, Error>?>, Never>?
     )
   }
 
@@ -295,7 +295,7 @@ struct BoundedBufferStateMachine<Base: AsyncSequence> {
     case resumeProducerAndConsumer(
       task: Task<Void, Never>,
       producerContinuation: UnsafeContinuation<Void, Never>?,
-      consumerContinuation: UnsafeContinuation<Result<Base.Element, Error>?, Never>?
+      consumerContinuation: UnsafeContinuation<UnsafeTransfer<Result<Base.Element, Error>?>, Never>?
     )
   }
 
diff --git a/Sources/AsyncAlgorithms/Buffer/BoundedBufferStorage.swift b/Sources/AsyncAlgorithms/Buffer/BoundedBufferStorage.swift
@@ -17,7 +17,7 @@ final class BoundedBufferStorage<Base: AsyncSequence>: Sendable where Base: Send
     self.stateMachine = ManagedCriticalState(BoundedBufferStateMachine(base: base, limit: limit))
   }
 
-  func next() async -> Result<Base.Element, Error>? {
+  func next() async -> UnsafeTransfer<Result<Base.Element, Error>?> {
     return await withTaskCancellationHandler {
       let action: BoundedBufferStateMachine<Base>.NextAction? = self.stateMachine.withCriticalRegion {
         stateMachine in
@@ -45,14 +45,14 @@ final class BoundedBufferStorage<Base: AsyncSequence>: Sendable where Base: Send
 
       case .returnResult(let producerContinuation, let result):
         producerContinuation?.resume()
-        return result
+        return UnsafeTransfer(result)
 
       case .none:
         break
       }
 
       return await withUnsafeContinuation {
-        (continuation: UnsafeContinuation<Result<Base.Element, Error>?, Never>) in
+        (continuation: UnsafeContinuation<UnsafeTransfer<Result<Base.Element, Error>?>, Never>) in
         let action = self.stateMachine.withCriticalRegion { stateMachine in
           stateMachine.nextSuspended(continuation: continuation)
         }
@@ -61,7 +61,7 @@ final class BoundedBufferStorage<Base: AsyncSequence>: Sendable where Base: Send
           break
         case .returnResult(let producerContinuation, let result):
           producerContinuation?.resume()
-          continuation.resume(returning: result)
+          continuation.resume(returning: UnsafeTransfer(result))
         }
       }
     } onCancel: {
@@ -109,6 +109,7 @@ final class BoundedBufferStorage<Base: AsyncSequence>: Sendable where Base: Send
           case .none:
             break
           case .resumeConsumer(let continuation, let result):
+            
             continuation.resume(returning: result)
           }
         }
@@ -120,7 +121,7 @@ final class BoundedBufferStorage<Base: AsyncSequence>: Sendable where Base: Send
         case .none:
           break
         case .resumeConsumer(let continuation):
-          continuation?.resume(returning: nil)
+          continuation?.resume(returning: UnsafeTransfer(nil))
         }
       } catch {
         let action = self.stateMachine.withCriticalRegion { stateMachine in
@@ -130,7 +131,7 @@ final class BoundedBufferStorage<Base: AsyncSequence>: Sendable where Base: Send
         case .none:
           break
         case .resumeConsumer(let continuation):
-          continuation?.resume(returning: .failure(error))
+          continuation?.resume(returning: UnsafeTransfer(Result<Base.Element, Error>.failure(error)))
         }
       }
     }
@@ -148,7 +149,7 @@ final class BoundedBufferStorage<Base: AsyncSequence>: Sendable where Base: Send
     case .resumeProducerAndConsumer(let task, let producerContinuation, let consumerContinuation):
       task.cancel()
       producerContinuation?.resume()
-      consumerContinuation?.resume(returning: nil)
+      consumerContinuation?.resume(returning: UnsafeTransfer(nil))
     }
   }
 
diff --git a/Sources/AsyncAlgorithms/Buffer/UnboundedBufferStateMachine.swift b/Sources/AsyncAlgorithms/Buffer/UnboundedBufferStateMachine.swift
@@ -14,7 +14,7 @@ import DequeModule
 @available(AsyncAlgorithms 1.0, *)
 struct UnboundedBufferStateMachine<Base: AsyncSequence> {
   typealias Element = Base.Element
-  typealias SuspendedConsumer = UnsafeContinuation<Result<Element, Error>?, Never>
+  typealias SuspendedConsumer = UnsafeContinuation<UnsafeTransfer<Result<Element, Error>?>, Never>
 
   enum Policy {
     case unlimited
@@ -73,7 +73,7 @@ struct UnboundedBufferStateMachine<Base: AsyncSequence> {
     case none
     case resumeConsumer(
       continuation: SuspendedConsumer,
-      result: Result<Element, Error>
+      result: UnsafeTransfer<Result<Element, Error>?>
     )
   }
 
@@ -108,7 +108,7 @@ struct UnboundedBufferStateMachine<Base: AsyncSequence> {
       self.state = .buffering(task: task, buffer: buffer, suspendedConsumer: nil)
       return .resumeConsumer(
         continuation: suspendedConsumer,
-        result: .success(element)
+        result: UnsafeTransfer(.success(element))
       )
 
     case .modifying:
diff --git a/Sources/AsyncAlgorithms/Buffer/UnboundedBufferStorage.swift b/Sources/AsyncAlgorithms/Buffer/UnboundedBufferStorage.swift
@@ -17,7 +17,7 @@ final class UnboundedBufferStorage<Base: AsyncSequence>: Sendable where Base: Se
     self.stateMachine = ManagedCriticalState(UnboundedBufferStateMachine<Base>(base: base, policy: policy))
   }
 
-  func next() async -> Result<Base.Element, Error>? {
+  func next() async -> UnsafeTransfer<Result<Base.Element, Error>?> {
     return await withTaskCancellationHandler {
 
       let action: UnboundedBufferStateMachine<Base>.NextAction? = self.stateMachine.withCriticalRegion {
@@ -42,21 +42,21 @@ final class UnboundedBufferStorage<Base: AsyncSequence>: Sendable where Base: Se
       case .suspend:
         break
       case .returnResult(let result):
-        return result
+        return UnsafeTransfer(result)
       case .none:
         break
       }
 
       return await withUnsafeContinuation {
-        (continuation: UnsafeContinuation<Result<Base.Element, Error>?, Never>) in
+        (continuation: UnsafeContinuation<UnsafeTransfer<Result<Base.Element, Error>?>, Never>) in
         let action = self.stateMachine.withCriticalRegion { stateMachine in
           stateMachine.nextSuspended(continuation: continuation)
         }
         switch action {
         case .none:
           break
         case .resumeConsumer(let result):
-          continuation.resume(returning: result)
+          continuation.resume(returning: UnsafeTransfer(result))
         }
       }
     } onCancel: {
@@ -89,7 +89,7 @@ final class UnboundedBufferStorage<Base: AsyncSequence>: Sendable where Base: Se
         case .none:
           break
         case .resumeConsumer(let continuation):
-          continuation?.resume(returning: nil)
+          continuation?.resume(returning: UnsafeTransfer(nil))
         }
       } catch {
         let action = self.stateMachine.withCriticalRegion { stateMachine in
@@ -99,7 +99,7 @@ final class UnboundedBufferStorage<Base: AsyncSequence>: Sendable where Base: Se
         case .none:
           break
         case .resumeConsumer(let continuation):
-          continuation?.resume(returning: .failure(error))
+          continuation?.resume(returning: UnsafeTransfer(Result<Base.Element, Error>.failure(error)))
         }
       }
     }
@@ -116,7 +116,7 @@ final class UnboundedBufferStorage<Base: AsyncSequence>: Sendable where Base: Se
       break
     case .resumeConsumer(let task, let continuation):
       task.cancel()
-      continuation?.resume(returning: nil)
+      continuation?.resume(returning: UnsafeTransfer(nil))
     }
   }
 
diff --git a/Sources/AsyncSequenceValidation/Clock.swift b/Sources/AsyncSequenceValidation/Clock.swift
@@ -13,7 +13,7 @@ import AsyncAlgorithms
 
 @available(AsyncAlgorithms 1.0, *)
 extension AsyncSequenceValidationDiagram {
-  public struct Clock {
+  public struct Clock: Sendable {
     let queue: WorkQueue
 
     init(queue: WorkQueue) {
diff --git a/Sources/AsyncSequenceValidation/TaskDriver.swift b/Sources/AsyncSequenceValidation/TaskDriver.swift
@@ -50,18 +50,18 @@ func start_thread(_ raw: UnsafeMutableRawPointer) -> UnsafeMutableRawPointer {
 #endif
 
 @available(AsyncAlgorithms 1.0, *)
-final class TaskDriver {
-  let work: (TaskDriver) -> Void
+final class TaskDriver: Sendable {
+  let work: @Sendable (TaskDriver) -> Void
   let queue: WorkQueue
-  #if canImport(Darwin) || canImport(wasi_pthread)
-  var thread: pthread_t?
+  #if canImport(Darwin)
+  nonisolated(unsafe) var thread: pthread_t?
   #elseif canImport(Glibc) || canImport(Musl) || canImport(Bionic)
-  var thread = pthread_t()
+  nonisolated(unsafe) var thread = pthread_t()
   #elseif canImport(WinSDK)
   #error("TODO: Port TaskDriver threading to windows")
   #endif
 
-  init(queue: WorkQueue, _ work: @escaping (TaskDriver) -> Void) {
+  init(queue: WorkQueue, _ work: @Sendable @escaping (TaskDriver) -> Void) {
     self.queue = queue
     self.work = work
   }
diff --git a/Sources/AsyncSequenceValidation/Test.swift b/Sources/AsyncSequenceValidation/Test.swift
@@ -122,7 +122,7 @@ extension AsyncSequenceValidationDiagram {
       }
     }
 
-    private static let _executor: AnyObject = {
+    private static let _executor: AnyObject & Sendable = {
       guard #available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *) else {
         return ClockExecutor_Pre5_9()
       }
@@ -134,13 +134,13 @@ extension AsyncSequenceValidationDiagram {
     }
     #endif
 
-    static var clock: Clock?
+    nonisolated(unsafe) static var clock: Clock?
 
-    static var driver: TaskDriver?
+    nonisolated(unsafe) static var driver: TaskDriver?
 
-    static var currentJob: Job?
+    nonisolated(unsafe) static var currentJob: Job?
 
-    static var specificationFailures = [ExpectationFailure]()
+    nonisolated(unsafe) static var specificationFailures = [ExpectationFailure]()
   }
 
   enum ActualResult {
diff --git a/Sources/_CAsyncSequenceValidationSupport/_CAsyncSequenceValidationSupport.h b/Sources/_CAsyncSequenceValidationSupport/_CAsyncSequenceValidationSupport.h
@@ -241,8 +241,10 @@
 
 typedef struct _Job* JobRef;
 
+#define NONISOLATED_UNSAFE __attribute__((swift_attr("nonisolated(unsafe)")))
+
 typedef SWIFT_CC(swift) void (*swift_task_enqueueGlobal_original)(JobRef _Nonnull job);
 SWIFT_EXPORT_FROM(swift_Concurrency)
-SWIFT_CC(swift) void (* _Nullable swift_task_enqueueGlobal_hook)(
+NONISOLATED_UNSAFE SWIFT_CC(swift) void (* _Nullable swift_task_enqueueGlobal_hook)(
   JobRef _Nonnull job, swift_task_enqueueGlobal_original _Nonnull original);
 

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-// swift-tools-version: 5.8`
	`1`	`+// swift-tools-version: 6.2`
`2`	`2`
`3`	`3`	`import PackageDescription`
`4`	`4`	`import CompilerPluginSupport`
Original file line number	Diff line number	Diff line change
`@@ -121,9 +121,9 @@ public struct AsyncBufferSequence<Base: AsyncSequence & Sendable>: AsyncSequence`
`121`	`121`	`self.storageType = .transparent(iterator)`
`122`	`122`	`return element`
`123`	`123`	`case .bounded(let storage):`
`124`		`- return try await storage.next()?._rethrowGet()`
	`124`	`+ return try await storage.next().wrapped?._rethrowGet()`
`125`	`125`	`case .unbounded(let storage):`
`126`		`- return try await storage.next()?._rethrowGet()`
	`126`	`+ return try await storage.next().wrapped?._rethrowGet()`
`127`	`127`	`}`
`128`	`128`	`}`
`129`	`129`	`}`
Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@ final class BoundedBufferStorage<Base: AsyncSequence>: Sendable where Base: Send`
`17`	`17`	`self.stateMachine = ManagedCriticalState(BoundedBufferStateMachine(base: base, limit: limit))`
`18`	`18`	`}`
`19`	`19`
`20`		`- func next() async -> Result<Base.Element, Error>? {`
	`20`	`+ func next() async -> UnsafeTransfer<Result<Base.Element, Error>?> {`
`21`	`21`	`return await withTaskCancellationHandler {`
`22`	`22`	`let action: BoundedBufferStateMachine<Base>.NextAction? = self.stateMachine.withCriticalRegion {`
`23`	`23`	`stateMachine in`
`@@ -45,14 +45,14 @@ final class BoundedBufferStorage<Base: AsyncSequence>: Sendable where Base: Send`
`45`	`45`
`46`	`46`	`case .returnResult(let producerContinuation, let result):`
`47`	`47`	`producerContinuation?.resume()`
`48`		`- return result`
	`48`	`+ return UnsafeTransfer(result)`
`49`	`49`
`50`	`50`	`case .none:`
`51`	`51`	`break`
`52`	`52`	`}`
`53`	`53`
`54`	`54`	`return await withUnsafeContinuation {`
`55`		`- (continuation: UnsafeContinuation<Result<Base.Element, Error>?, Never>) in`
	`55`	`+ (continuation: UnsafeContinuation<UnsafeTransfer<Result<Base.Element, Error>?>, Never>) in`
`56`	`56`	`let action = self.stateMachine.withCriticalRegion { stateMachine in`
`57`	`57`	`stateMachine.nextSuspended(continuation: continuation)`
`58`	`58`	`}`
`@@ -61,7 +61,7 @@ final class BoundedBufferStorage<Base: AsyncSequence>: Sendable where Base: Send`
`61`	`61`	`break`
`62`	`62`	`case .returnResult(let producerContinuation, let result):`
`63`	`63`	`producerContinuation?.resume()`
`64`		`- continuation.resume(returning: result)`
	`64`	`+ continuation.resume(returning: UnsafeTransfer(result))`
`65`	`65`	`}`
`66`	`66`	`}`
`67`	`67`	`} onCancel: {`
`@@ -109,6 +109,7 @@ final class BoundedBufferStorage<Base: AsyncSequence>: Sendable where Base: Send`
`109`	`109`	`case .none:`
`110`	`110`	`break`
`111`	`111`	`case .resumeConsumer(let continuation, let result):`
	`112`	`+`
`112`	`113`	`continuation.resume(returning: result)`
`113`	`114`	`}`
`114`	`115`	`}`
`@@ -120,7 +121,7 @@ final class BoundedBufferStorage<Base: AsyncSequence>: Sendable where Base: Send`
`120`	`121`	`case .none:`
`121`	`122`	`break`
`122`	`123`	`case .resumeConsumer(let continuation):`
`123`		`- continuation?.resume(returning: nil)`
	`124`	`+ continuation?.resume(returning: UnsafeTransfer(nil))`
`124`	`125`	`}`
`125`	`126`	`} catch {`
`126`	`127`	`let action = self.stateMachine.withCriticalRegion { stateMachine in`
`@@ -130,7 +131,7 @@ final class BoundedBufferStorage<Base: AsyncSequence>: Sendable where Base: Send`
`130`	`131`	`case .none:`
`131`	`132`	`break`
`132`	`133`	`case .resumeConsumer(let continuation):`
`133`		`- continuation?.resume(returning: .failure(error))`
	`134`	`+ continuation?.resume(returning: UnsafeTransfer(Result<Base.Element, Error>.failure(error)))`
`134`	`135`	`}`
`135`	`136`	`}`
`136`	`137`	`}`
`@@ -148,7 +149,7 @@ final class BoundedBufferStorage<Base: AsyncSequence>: Sendable where Base: Send`
`148`	`149`	`case .resumeProducerAndConsumer(let task, let producerContinuation, let consumerContinuation):`
`149`	`150`	`task.cancel()`
`150`	`151`	`producerContinuation?.resume()`
`151`		`- consumerContinuation?.resume(returning: nil)`
	`152`	`+ consumerContinuation?.resume(returning: UnsafeTransfer(nil))`
`152`	`153`	`}`
`153`	`154`	`}`
`154`	`155`
Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@ final class UnboundedBufferStorage<Base: AsyncSequence>: Sendable where Base: Se`
`17`	`17`	`self.stateMachine = ManagedCriticalState(UnboundedBufferStateMachine<Base>(base: base, policy: policy))`
`18`	`18`	`}`
`19`	`19`
`20`		`- func next() async -> Result<Base.Element, Error>? {`
	`20`	`+ func next() async -> UnsafeTransfer<Result<Base.Element, Error>?> {`
`21`	`21`	`return await withTaskCancellationHandler {`
`22`	`22`
`23`	`23`	`let action: UnboundedBufferStateMachine<Base>.NextAction? = self.stateMachine.withCriticalRegion {`
`@@ -42,21 +42,21 @@ final class UnboundedBufferStorage<Base: AsyncSequence>: Sendable where Base: Se`
`42`	`42`	`case .suspend:`
`43`	`43`	`break`
`44`	`44`	`case .returnResult(let result):`
`45`		`- return result`
	`45`	`+ return UnsafeTransfer(result)`
`46`	`46`	`case .none:`
`47`	`47`	`break`
`48`	`48`	`}`
`49`	`49`
`50`	`50`	`return await withUnsafeContinuation {`
`51`		`- (continuation: UnsafeContinuation<Result<Base.Element, Error>?, Never>) in`
	`51`	`+ (continuation: UnsafeContinuation<UnsafeTransfer<Result<Base.Element, Error>?>, Never>) in`
`52`	`52`	`let action = self.stateMachine.withCriticalRegion { stateMachine in`
`53`	`53`	`stateMachine.nextSuspended(continuation: continuation)`
`54`	`54`	`}`
`55`	`55`	`switch action {`
`56`	`56`	`case .none:`
`57`	`57`	`break`
`58`	`58`	`case .resumeConsumer(let result):`
`59`		`- continuation.resume(returning: result)`
	`59`	`+ continuation.resume(returning: UnsafeTransfer(result))`
`60`	`60`	`}`
`61`	`61`	`}`
`62`	`62`	`} onCancel: {`
`@@ -89,7 +89,7 @@ final class UnboundedBufferStorage<Base: AsyncSequence>: Sendable where Base: Se`
`89`	`89`	`case .none:`
`90`	`90`	`break`
`91`	`91`	`case .resumeConsumer(let continuation):`
`92`		`- continuation?.resume(returning: nil)`
	`92`	`+ continuation?.resume(returning: UnsafeTransfer(nil))`
`93`	`93`	`}`
`94`	`94`	`} catch {`
`95`	`95`	`let action = self.stateMachine.withCriticalRegion { stateMachine in`
`@@ -99,7 +99,7 @@ final class UnboundedBufferStorage<Base: AsyncSequence>: Sendable where Base: Se`
`99`	`99`	`case .none:`
`100`	`100`	`break`
`101`	`101`	`case .resumeConsumer(let continuation):`
`102`		`- continuation?.resume(returning: .failure(error))`
	`102`	`+ continuation?.resume(returning: UnsafeTransfer(Result<Base.Element, Error>.failure(error)))`
`103`	`103`	`}`
`104`	`104`	`}`
`105`	`105`	`}`
`@@ -116,7 +116,7 @@ final class UnboundedBufferStorage<Base: AsyncSequence>: Sendable where Base: Se`
`116`	`116`	`break`
`117`	`117`	`case .resumeConsumer(let task, let continuation):`
`118`	`118`	`task.cancel()`
`119`		`- continuation?.resume(returning: nil)`
	`119`	`+ continuation?.resume(returning: UnsafeTransfer(nil))`
`120`	`120`	`}`
`121`	`121`	`}`
`122`	`122`
Original file line number	Diff line number	Diff line change
`@@ -122,7 +122,7 @@ extension AsyncSequenceValidationDiagram {`
`122`	`122`	`}`
`123`	`123`	`}`
`124`	`124`
`125`		`- private static let _executor: AnyObject = {`
	`125`	`+ private static let _executor: AnyObject & Sendable = {`
`126`	`126`	`guard #available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *) else {`
`127`	`127`	`return ClockExecutor_Pre5_9()`
`128`	`128`	`}`
`@@ -134,13 +134,13 @@ extension AsyncSequenceValidationDiagram {`
`134`	`134`	`}`
`135`	`135`	`#endif`
`136`	`136`
`137`		`- static var clock: Clock?`
	`137`	`+ nonisolated(unsafe) static var clock: Clock?`
`138`	`138`
`139`		`- static var driver: TaskDriver?`
	`139`	`+ nonisolated(unsafe) static var driver: TaskDriver?`
`140`	`140`
`141`		`- static var currentJob: Job?`
	`141`	`+ nonisolated(unsafe) static var currentJob: Job?`
`142`	`142`
`143`		`- static var specificationFailures = [ExpectationFailure]()`
	`143`	`+ nonisolated(unsafe) static var specificationFailures = [ExpectationFailure]()`
`144`	`144`	`}`
`145`	`145`
`146`	`146`	`enum ActualResult {`