Enable concurrency checking

Nimble.xcodeproj/project.pbxproj

@@ -2304,6 +2304,7 @@
 				);
 				SDKROOT = macosx;
 				SWIFT_OPTIMIZATION_LEVEL = "-Onone";
+				SWIFT_STRICT_CONCURRENCY = complete;
 				SWIFT_SWIFT3_OBJC_INFERENCE = Off;
 				SWIFT_VERSION = 5.0;
 				TVOS_DEPLOYMENT_TARGET = 13.0;
@@ -2372,6 +2373,7 @@
 				SDKROOT = macosx;
 				SWIFT_COMPILATION_MODE = wholemodule;
 				SWIFT_OPTIMIZATION_LEVEL = "-O";
+				SWIFT_STRICT_CONCURRENCY = complete;
 				SWIFT_SWIFT3_OBJC_INFERENCE = Off;
 				SWIFT_VERSION = 5.0;
 				TVOS_DEPLOYMENT_TARGET = 13.0;

Sources/Nimble/Adapters/AdapterProtocols.swift

@@ -1,5 +1,5 @@
 /// Protocol for the assertion handler that Nimble uses for all expectations.
-public protocol AssertionHandler {
+public protocol AssertionHandler: Sendable {
     func assert(_ assertion: Bool, message: FailureMessage, location: SourceLocation)
 }
 

Sources/Nimble/Adapters/AssertionDispatcher.swift

@@ -4,7 +4,7 @@
 /// @warning Does not fully dispatch if one of the handlers raises an exception.
 ///          This is possible with XCTest-based assertion handlers.
 ///
-public class AssertionDispatcher: AssertionHandler {
+public final class AssertionDispatcher: AssertionHandler {
     let handlers: [AssertionHandler]
 
     public init(handlers: [AssertionHandler]) {

Sources/Nimble/Adapters/AssertionRecorder+Async.swift

@@ -13,9 +13,6 @@ public func withAssertionHandler(_ tempAssertionHandler: AssertionHandler,
                                  closure: () async throws -> Void) async {
     let environment = NimbleEnvironment.activeInstance
     let oldRecorder = environment.assertionHandler
-    let capturer = NMBExceptionCapture(handler: nil, finally: ({
-        environment.assertionHandler = oldRecorder
-    }))
     environment.assertionHandler = tempAssertionHandler
 
     do {
@@ -26,6 +23,7 @@ public func withAssertionHandler(_ tempAssertionHandler: AssertionHandler,
         let location = SourceLocation(file: file, line: line)
         tempAssertionHandler.assert(false, message: failureMessage, location: location)
     }
+    environment.assertionHandler = oldRecorder
 }
 
 /// Captures expectations that occur in the given closure. Note that all

Sources/Nimble/Adapters/AssertionRecorder.swift

@@ -20,7 +20,7 @@ public struct AssertionRecord: CustomStringConvertible {
 /// This is useful for testing failure messages for matchers.
 ///
 /// @see AssertionHandler
-public class AssertionRecorder: AssertionHandler {
+public final class AssertionRecorder: AssertionHandler {
     /// All the assertions that were captured by this recorder
     public var assertions = [AssertionRecord]()
 

Sources/Nimble/Adapters/NimbleXCTestHandler.swift

@@ -3,7 +3,7 @@ import XCTest
 
 /// Default handler for Nimble. This assertion handler passes failures along to
 /// XCTest.
-public class NimbleXCTestHandler: AssertionHandler {
+public final class NimbleXCTestHandler: AssertionHandler, Sendable {
     public func assert(_ assertion: Bool, message: FailureMessage, location: SourceLocation) {
         if !assertion {
             recordFailure("\(message.stringValue)\n", location: location)
@@ -13,7 +13,7 @@ public class NimbleXCTestHandler: AssertionHandler {
 
 /// Alternative handler for Nimble. This assertion handler passes failures along
 /// to XCTest by attempting to reduce the failure message size.
-public class NimbleShortXCTestHandler: AssertionHandler {
+public final class NimbleShortXCTestHandler: AssertionHandler, Sendable {
     public func assert(_ assertion: Bool, message: FailureMessage, location: SourceLocation) {
         if !assertion {
             let msg: String
@@ -29,7 +29,7 @@ public class NimbleShortXCTestHandler: AssertionHandler {
 
 /// Fallback handler in case XCTest is unavailable. This assertion handler will abort
 /// the program if it is invoked.
-class NimbleXCTestUnavailableHandler: AssertionHandler {
+final class NimbleXCTestUnavailableHandler: AssertionHandler, Sendable {
     func assert(_ assertion: Bool, message: FailureMessage, location: SourceLocation) {
         fatalError("XCTest is not available and no custom assertion handler was configured. Aborting.")
     }

Sources/Nimble/Adapters/NonObjectiveC/ExceptionCapture.swift

@@ -11,7 +11,7 @@ class NSException {}
 /// A dummy reimplementation of the `NMBExceptionCapture` class to serve
 /// as a stand-in for build and runtime environments that don't support
 /// Objective C.
-internal class ExceptionCapture {
+internal final class ExceptionCapture: Sendable {
     let finally: (() -> Void)?
 
     init(handler: ((NSException) -> Void)?, finally: (() -> Void)?) {

Sources/Nimble/AsyncExpression.swift

@@ -1,12 +1,24 @@
 // Memoizes the given closure, only calling the passed
 // closure once; even if repeat calls to the returned closure
-private func memoizedClosure<T>(_ closure: @escaping () async throws -> T) -> (Bool) async throws -> T {
+public actor MemoizedClosure<T: Sendable> {
     var cache: T?
-    return { withoutCaching in
-        if withoutCaching || cache == nil {
-            cache = try await closure()
+    private let closure: @Sendable (Bool) async throws -> T?
+
+    init(_ closure: @escaping @Sendable () async throws -> T?) {
+        self.closure = { _ in try await closure() }
+    }
+
+    init(prememoized: @escaping @Sendable (Bool) async throws -> T?) {
+        self.closure = prememoized
+    }
+
+    public func evaluate(_ withoutCaching: Bool) async throws -> T? {
+        if withoutCaching == false, let cache {
+            return cache
         }
-        return cache!
+        let value = try await closure(withoutCaching)
+        cache = value
+        return value
     }
 }
 
@@ -21,8 +33,8 @@ private func memoizedClosure<T>(_ closure: @escaping () async throws -> T) -> (B
 ///
 /// This provides a common consumable API for matchers to utilize to allow
 /// Nimble to change internals to how the captured closure is managed.
-public struct AsyncExpression<Value> {
-    internal let _expression: (Bool) async throws -> Value?
+public struct AsyncExpression<Value: Sendable>: Sendable {
+    internal let _expression: MemoizedClosure<Value>
     internal let _withoutCaching: Bool
     public let location: SourceLocation
     public let isClosure: Bool
@@ -38,8 +50,8 @@ public struct AsyncExpression<Value> {
     ///                  requires an explicit closure. This gives Nimble
     ///                  flexibility if @autoclosure behavior changes between
     ///                  Swift versions. Nimble internals always sets this true.
-    public init(expression: @escaping () async throws -> Value?, location: SourceLocation, isClosure: Bool = true) {
-        self._expression = memoizedClosure(expression)
+    public init(expression: @escaping @Sendable () async throws -> Value?, location: SourceLocation, isClosure: Bool = true) {
+        self._expression = MemoizedClosure<Value>(expression)
         self.location = location
         self._withoutCaching = false
         self.isClosure = isClosure
@@ -59,7 +71,7 @@ public struct AsyncExpression<Value> {
     ///                  requires an explicit closure. This gives Nimble
     ///                  flexibility if @autoclosure behavior changes between
     ///                  Swift versions. Nimble internals always sets this true.
-    public init(memoizedExpression: @escaping (Bool) async throws -> Value?, location: SourceLocation, withoutCaching: Bool, isClosure: Bool = true) {
+    public init(memoizedExpression: MemoizedClosure<Value>, location: SourceLocation, withoutCaching: Bool, isClosure: Bool = true) {
         self._expression = memoizedExpression
         self.location = location
         self._withoutCaching = withoutCaching
@@ -70,7 +82,7 @@ public struct AsyncExpression<Value> {
     public func toSynchronousExpression() async -> Expression<Value> {
         let value: Result<Value?, Error>
         do {
-            value = .success(try await _expression(self._withoutCaching))
+            value = .success(try await _expression.evaluate(self._withoutCaching))
         } catch {
             value = .failure(error)
         }
@@ -99,7 +111,7 @@ public struct AsyncExpression<Value> {
     }
 
     public func evaluate() async throws -> Value? {
-        return try await self._expression(_withoutCaching)
+        return try await self._expression.evaluate(_withoutCaching)
     }
 
     public func withoutCaching() -> AsyncExpression<Value> {

Sources/Nimble/DSL+AsyncAwait.swift

@@ -3,7 +3,7 @@ import Dispatch
 #endif
 
 /// Make an ``AsyncExpectation`` on a given actual value. The value given is lazily evaluated.
-public func expect<T>(file: FileString = #file, line: UInt = #line, _ expression: @escaping () async throws -> T?) -> AsyncExpectation<T> {
+public func expect<T: Sendable>(file: FileString = #file, line: UInt = #line, _ expression: @escaping @Sendable () async throws -> T?) -> AsyncExpectation<T> {
     return AsyncExpectation(
         expression: AsyncExpression(
             expression: expression,
@@ -12,7 +12,7 @@ public func expect<T>(file: FileString = #file, line: UInt = #line, _ expression
 }
 
 /// Make an ``AsyncExpectation`` on a given actual value. The closure is lazily invoked.
-public func expect<T>(file: FileString = #file, line: UInt = #line, _ expression: () -> (() async throws -> T)) -> AsyncExpectation<T> {
+public func expect<T: Sendable>(file: FileString = #file, line: UInt = #line, _ expression: () -> (@Sendable () async throws -> T)) -> AsyncExpectation<T> {
     return AsyncExpectation(
         expression: AsyncExpression(
             expression: expression(),
@@ -21,7 +21,7 @@ public func expect<T>(file: FileString = #file, line: UInt = #line, _ expression
 }
 
 /// Make an ``AsyncExpectation`` on a given actual value. The closure is lazily invoked.
-public func expect<T>(file: FileString = #file, line: UInt = #line, _ expression: () -> (() async throws -> T?)) -> AsyncExpectation<T> {
+public func expect<T: Sendable>(file: FileString = #file, line: UInt = #line, _ expression: () -> (@Sendable () async throws -> T?)) -> AsyncExpectation<T> {
     return AsyncExpectation(
         expression: AsyncExpression(
             expression: expression(),
@@ -30,7 +30,7 @@ public func expect<T>(file: FileString = #file, line: UInt = #line, _ expression
 }
 
 /// Make an ``AsyncExpectation`` on a given actual value. The closure is lazily invoked.
-public func expect(file: FileString = #file, line: UInt = #line, _ expression: () -> (() async throws -> Void)) -> AsyncExpectation<Void> {
+public func expect(file: FileString = #file, line: UInt = #line, _ expression: () -> (@Sendable () async throws -> Void)) -> AsyncExpectation<Void> {
     return AsyncExpectation(
         expression: AsyncExpression(
             expression: expression(),
@@ -40,7 +40,7 @@ public func expect(file: FileString = #file, line: UInt = #line, _ expression: (
 
 /// Make an ``AsyncExpectation`` on a given actual value. The value given is lazily evaluated.
 /// This is provided to avoid  confusion between `expect -> SyncExpectation` and `expect -> AsyncExpectation`.
-public func expecta<T>(file: FileString = #file, line: UInt = #line, _ expression: @autoclosure @escaping () async throws -> T?) async -> AsyncExpectation<T> {
+public func expecta<T>(file: FileString = #file, line: UInt = #line, _ expression: @autoclosure @escaping @Sendable () async throws -> T?) async -> AsyncExpectation<T> {
     return AsyncExpectation(
         expression: AsyncExpression(
             expression: expression,
@@ -50,7 +50,7 @@ public func expecta<T>(file: FileString = #file, line: UInt = #line, _ expressio
 
 /// Make an ``AsyncExpectation`` on a given actual value. The closure is lazily invoked.
 /// This is provided to avoid  confusion between `expect -> SyncExpectation`  and `expect -> AsyncExpectation`
-public func expecta<T>(file: FileString = #file, line: UInt = #line, _ expression: @autoclosure () -> (() async throws -> T)) async -> AsyncExpectation<T> {
+public func expecta<T>(file: FileString = #file, line: UInt = #line, _ expression: @autoclosure () -> (@Sendable () async throws -> T)) async -> AsyncExpectation<T> {
     return AsyncExpectation(
         expression: AsyncExpression(
             expression: expression(),
@@ -60,7 +60,7 @@ public func expecta<T>(file: FileString = #file, line: UInt = #line, _ expressio
 
 /// Make an ``AsyncExpectation`` on a given actual value. The closure is lazily invoked.
 /// This is provided to avoid  confusion between `expect -> SyncExpectation`  and `expect -> AsyncExpectation`
-public func expecta<T>(file: FileString = #file, line: UInt = #line, _ expression: @autoclosure () -> (() async throws -> T?)) async -> AsyncExpectation<T> {
+public func expecta<T>(file: FileString = #file, line: UInt = #line, _ expression: @autoclosure () -> (@Sendable () async throws -> T?)) async -> AsyncExpectation<T> {
     return AsyncExpectation(
         expression: AsyncExpression(
             expression: expression(),
@@ -70,7 +70,7 @@ public func expecta<T>(file: FileString = #file, line: UInt = #line, _ expressio
 
 /// Make an ``AsyncExpectation`` on a given actual value. The closure is lazily invoked.
 /// This is provided to avoid  confusion between `expect -> SyncExpectation`  and `expect -> AsyncExpectation`
-public func expecta(file: FileString = #file, line: UInt = #line, _ expression: @autoclosure () -> (() async throws -> Void)) async -> AsyncExpectation<Void> {
+public func expecta(file: FileString = #file, line: UInt = #line, _ expression: @autoclosure () -> (@Sendable () async throws -> Void)) async -> AsyncExpectation<Void> {
     return AsyncExpectation(
         expression: AsyncExpression(
             expression: expression(),
@@ -87,7 +87,7 @@ public func expecta(file: FileString = #file, line: UInt = #line, _ expression:
 ///
 /// @warning
 /// Unlike the synchronous version of this call, this does not support catching Objective-C exceptions.
-public func waitUntil(timeout: DispatchTimeInterval = AsyncDefaults.timeout, file: FileString = #file, line: UInt = #line, action: @escaping (@escaping () -> Void) async -> Void) async {
+public func waitUntil(timeout: DispatchTimeInterval = AsyncDefaults.timeout, file: FileString = #file, line: UInt = #line, action: @escaping @Sendable (@escaping () async -> Void) async -> Void) async {
     await throwableUntil(timeout: timeout) { done in
         await action(done)
     }
@@ -100,7 +100,7 @@ public func waitUntil(timeout: DispatchTimeInterval = AsyncDefaults.timeout, fil
 ///
 /// @warning
 /// Unlike the synchronous version of this call, this does not support catching Objective-C exceptions.
-public func waitUntil(timeout: DispatchTimeInterval = AsyncDefaults.timeout, file: FileString = #file, line: UInt = #line, action: @escaping (@escaping () -> Void) -> Void) async {
+public func waitUntil(timeout: DispatchTimeInterval = AsyncDefaults.timeout, file: FileString = #file, line: UInt = #line, action: @escaping @Sendable (@escaping () async -> Void) -> Void) async {
     await throwableUntil(timeout: timeout, file: file, line: line) { done in
         action(done)
     }
@@ -115,16 +115,16 @@ private func throwableUntil(
     timeout: DispatchTimeInterval,
     file: FileString = #file,
     line: UInt = #line,
-    action: @escaping (@escaping () -> Void) async throws -> Void) async {
+    action: @escaping @Sendable (@escaping () async -> Void) async throws -> Void) async {
         let awaiter = NimbleEnvironment.activeInstance.awaiter
         let leeway = timeout.divided
-        let result = await awaiter.performBlock(file: file, line: line) { @MainActor (done: @escaping (ErrorResult) -> Void) async throws -> Void in
+        let result = await awaiter.performBlock(file: file, line: line) { @MainActor (done: @escaping (ErrorResult) async -> Void) async throws -> Void in
             do {
                 try await action {
-                    done(.none)
+                    await done(.none)
                 }
             } catch let e {
-                done(.error(e))
+                await done(.error(e))
             }
         }
             .timeout(timeout, forcefullyAbortTimeout: leeway)

Sources/Nimble/Expectation.swift

@@ -33,7 +33,7 @@ internal func execute<T>(_ expression: Expression<T>, _ style: ExpectationStyle,
     return result
 }
 
-public enum ExpectationStatus: Equatable {
+public enum ExpectationStatus: Equatable, Sendable {
 
     /// No predicates have been performed.
     case pending
@@ -197,7 +197,7 @@ public struct SyncExpectation<Value>: Expectation {
     // - NMBExpectation for Objective-C interface
 }
 
-public struct AsyncExpectation<Value>: Expectation {
+public struct AsyncExpectation<Value: Sendable>: Expectation, Sendable {
     public let expression: AsyncExpression<Value>
 
     /// The status of the test after predicates have been evaluated.

Sources/Nimble/ExpectationMessage.swift

@@ -1,4 +1,4 @@
-public indirect enum ExpectationMessage {
+public indirect enum ExpectationMessage: Sendable {
     // --- Primary Expectations ---
     /// includes actual value in output ("expected to <message>, got <actual>")
     case expectedActualValueTo(/* message: */ String)

Sources/Nimble/Matchers/PostNotification.swift

@@ -74,11 +74,13 @@ private func _postNotifications<Out>(
             actualValue = "<\(stringify(collector.observedNotifications))>"
         }
 
-        var result = try predicate.satisfies(collectorNotificationsExpression)
-        result.message = result.message.replacedExpectation { message in
-            return .expectedCustomValueTo(message.expectedMessage, actual: actualValue)
-        }
-        return result
+        let predicateResult = try predicate.satisfies(collectorNotificationsExpression)
+        return PredicateResult(
+            status: predicateResult.status,
+            message: predicateResult.message.replacedExpectation { message in
+                return .expectedCustomValueTo(message.expectedMessage, actual: actualValue)
+            }
+        )
     }
 }
 

Sources/Nimble/Matchers/Predicate.swift

@@ -16,8 +16,8 @@
 /// The Predicate provide the heavy lifting on how to assert against a given value. Internally,
 /// predicates are simple wrappers around closures to provide static type information and
 /// allow composition and wrapping of existing behaviors.
-public struct Predicate<T> {
-    fileprivate var matcher: (Expression<T>) throws -> PredicateResult
+public struct Predicate<T>: Sendable {
+    fileprivate let matcher: (Expression<T>) throws -> PredicateResult
 
     /// Constructs a predicate that knows how take a given value
     public init(_ matcher: @escaping (Expression<T>) throws -> PredicateResult) {
@@ -82,17 +82,17 @@ extension Predicate {
 }
 
 // The Expectation style intended for comparison to a PredicateStatus.
-public enum ExpectationStyle {
+public enum ExpectationStyle: Sendable {
     case toMatch, toNotMatch
 }
 
 /// The value that a Predicates return to describe if the given (actual) value matches the
 /// predicate.
-public struct PredicateResult {
+public struct PredicateResult: Sendable {
     /// Status indicates if the predicate matches, does not match, or fails.
-    public var status: PredicateStatus
+    public let status: PredicateStatus
     /// The error message that can be displayed if it does not match
-    public var message: ExpectationMessage
+    public let message: ExpectationMessage
 
     /// Constructs a new PredicateResult with a given status and error message
     public init(status: PredicateStatus, message: ExpectationMessage) {
@@ -113,7 +113,7 @@ public struct PredicateResult {
 }
 
 /// PredicateStatus is a trinary that indicates if a Predicate matches a given value or not
-public enum PredicateStatus {
+public enum PredicateStatus: Sendable {
     /// Matches indicates if the predicate / matcher passes with the given value
     ///
     /// For example, `equals(1)` returns `.matches` for `expect(1).to(equal(1))`.