swift concurrency

CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+### 7.0.0
+
+- Xcode 15
+- Swift 5.10
+- Swift Concurrency support
+
 ### 6.3.0
 
 - Xcode 13

Package.swift

@@ -2,15 +2,19 @@
 
 import PackageDescription
 
+let swiftSettings: [SwiftSetting] = [
+  .enableExperimentalFeature("StrictConcurrency")
+]
+
 let package = Package(
   name: "AdvancedOperation",
   platforms: [.macOS(.v13), .iOS(.v16), .tvOS(.v16), .watchOS(.v5), .visionOS(.v1)],
   products: [
     .library(name: "AdvancedOperation", targets: ["AdvancedOperation"])
   ],
   targets: [
-    .target(name: "AdvancedOperation", path: "Sources"),
-    .testTarget(name: "AdvancedOperationTests", dependencies: ["AdvancedOperation"])
+    .target(name: "AdvancedOperation", path: "Sources", swiftSettings: swiftSettings),
+    .testTarget(name: "AdvancedOperationTests", dependencies: ["AdvancedOperation"], swiftSettings: swiftSettings)
   ],
   swiftLanguageVersions: [.v5]
 )

Sources/Operations/AsynchronousBlockOperation.swift

@@ -7,7 +7,7 @@ public typealias AsyncBlockOperation = AsynchronousBlockOperation
 /// A  sublcass of `AsynchronousOperation` to execute a closure.
 public final class AsynchronousBlockOperation: AsynchronousOperation {
   /// A closure type that takes a closure as its parameter.
-  public typealias Block = (@escaping () -> Void) -> Void
+  public typealias Block = (@Sendable @escaping () -> Void) -> Void
 
   // MARK: - Private Properties
 

Sources/Operations/ResultOperation.swift

@@ -6,7 +6,7 @@ import os.lock
 /// An `AsynchronousOperation` that produces a `result` once finished.
 ///
 /// If a `ResultOperation` gets cancelled before being executed, no result will be produced by default.
-open class ResultOperation<Success, Failure>: AsynchronousOperation where Failure: Error {
+open class ResultOperation<Success, Failure>: AsynchronousOperation where Success: Sendable, Failure: Error {
   /// Block executed after the operation is finished providing the final result (if any).
   /// - Note: `onFinish` and `completionBlock` call order is not guaranteed in any way.
   public var onFinish: ((Result<Success, Failure>?) -> Void)?

Tests/AdvancedOperationTests/Core/AsynchronousOperationTests.swift

@@ -1,7 +1,7 @@
 // AdvancedOperation
 
 import XCTest
-
+import os.lock
 @testable import AdvancedOperation
 
 final class AsynchronousOperationTests: XCTestCase {
@@ -296,6 +296,7 @@ final class AsynchronousOperationTests: XCTestCase {
     XCTAssertTrue(operation1.isFinished)
   }
 
+  @MainActor
   func testAllOperationCancelled() {
     let queue = OperationQueue()
     let expectation1 = expectation(description: "\(#function)\(#line)")
@@ -398,30 +399,38 @@ final class AsynchronousOperationTests: XCTestCase {
     let expectation = XCTKVOExpectation(
       keyPath: #keyPath(Operation.isFinished), object: operation2, expectedValue: true)
 
-    var eventsForOperation = [Event]()
-    var eventsForOperation2 = [Event]()
+    let eventsForOperation = OSAllocatedUnfairLock(initialState: [Event]())
+    let eventsForOperation2 = OSAllocatedUnfairLock(initialState: [Event]())
 
     let tokenExecuting = operation.observe(\.isExecuting, options: [.prior, .old, .new]) { (op, change) in
-      eventsForOperation.append(Event(isPrior: change.isPrior, oldValue: change.oldValue, newValue: change.newValue))
+      eventsForOperation.withLock {
+        $0.append(Event(isPrior: change.isPrior, oldValue: change.oldValue, newValue: change.newValue))
+      }
     }
 
     let tokenFinishing = operation.observe(\.isFinished, options: [.prior, .old, .new]) { (op, change) in
-      eventsForOperation.append(Event(isPrior: change.isPrior, oldValue: change.oldValue, newValue: change.newValue))
+      eventsForOperation.withLock {
+        $0.append(Event(isPrior: change.isPrior, oldValue: change.oldValue, newValue: change.newValue))
+      }
     }
 
     let tokenExecuting2 = operation.observe(\.isExecuting, options: [.prior, .old, .new]) { (op, change) in
-      eventsForOperation2.append(Event(isPrior: change.isPrior, oldValue: change.oldValue, newValue: change.newValue))
+      eventsForOperation2.withLock {
+        $0.append(Event(isPrior: change.isPrior, oldValue: change.oldValue, newValue: change.newValue))
+      }
     }
 
     let tokenFinishing2 = operation.observe(\.isFinished, options: [.prior, .old, .new]) { (op, change) in
-      eventsForOperation2.append(Event(isPrior: change.isPrior, oldValue: change.oldValue, newValue: change.newValue))
+      eventsForOperation2.withLock {
+        $0.append(Event(isPrior: change.isPrior, oldValue: change.oldValue, newValue: change.newValue))
+      }
     }
 
     operation.start()
     operation2.start()
 
     wait(for: [expectation], timeout: 2)
-    XCTAssertEqual(eventsForOperation, eventsForOperation2)
+    XCTAssertEqual(eventsForOperation.withLock({ $0 }), eventsForOperation2.withLock({ $0 }))
     tokenExecuting.invalidate()
     tokenExecuting2.invalidate()
     tokenFinishing.invalidate()

Tests/AdvancedOperationTests/Core/ProgressReportingTests.swift

@@ -47,7 +47,7 @@ final class ProgressReportingTests: XCTestCase {
 
     currentProgress.addChild(groupOperation.progress, withPendingUnitCount: 1)
 
-    var logs = [String]()
+    nonisolated(unsafe) var logs = [String]()
     let token = currentProgress.observe(\.fractionCompleted, options: [.initial, .old, .new]) { progress, _ in
       // gather some progress data to be used if the test fails
       let log =
@@ -358,7 +358,7 @@ final class ProgressReportingTests: XCTestCase {
 
     currentProgress.addChild(queue.progress, withPendingUnitCount: 1)
 
-    var fractions = [Double]()
+    nonisolated(unsafe) var fractions = [Double]()
     let expectedFractions = [0.0, 0.125, 0.25, 0.375, 0.5, 0.625, 0.75, 0.875, 1.0]
     let token = currentProgress.observe(\.fractionCompleted, options: [.initial, .old, .new]) { (progress, change) in
       print("fraction: \(progress.fractionCompleted)", "-", progress.localizedAdditionalDescription ?? "")

Tests/AdvancedOperationTests/Helpers/Mocks.swift

@@ -269,7 +269,7 @@ internal final class DummyFailableOperation: FailableAsyncOperation<DummyFailabl
 // MARK: - GroupOperation
 
 internal final class ProducerGroupOperation: GroupOperation {
-  init(operation: @escaping () -> Operation) {
+  init(operation: @Sendable @escaping () -> Operation) {
     super.init(operations: [])
     let producer = BlockOperation { [unowned self] in
       // operation can be "produced" and added to the GroupOperation only if the producer is still running

Tests/AdvancedOperationTests/Operations/AsynchronousBlockOperationTests.swift

@@ -51,6 +51,7 @@ final class AsynchronousBlockOperationTests: XCTestCase {
     wait(for: [expectation1, expectation2], timeout: 10, enforceOrder: true)
   }
 
+  @MainActor
   func testComposition() {
     let expectation3 = expectation(description: "\(#function)\(#line)")
     let operation1 = SleepyAsyncOperation()
@@ -76,8 +77,10 @@ final class AsynchronousBlockOperationTests: XCTestCase {
     XCTAssertTrue(adapterOperation.isFinished)
   }
 
+  @MainActor
   func testMemoryLeak() {
-    var object = NSObject()
+    class Dummy: @unchecked Sendable { }
+    var object = Dummy()
     weak var weakObject = object
 
     autoreleasepool {
@@ -96,7 +99,7 @@ final class AsynchronousBlockOperationTests: XCTestCase {
 
       // Memory leaks test: once the operation is released, the captured object (by reference) should be nil (weakObject)
       operation = AsynchronousBlockOperation { _ in }
-      object = NSObject()
+      object = Dummy()
     }
 
     XCTAssertNil(weakObject, "Memory leak: the object should have been deallocated at this point.")