Cleanup, add support for Swift 5.6, drop support for Swift pre 5.5

Author: ffried

Package.swift

@@ -1,4 +1,4 @@
-// swift-tools-version:5.4
+// swift-tools-version:5.6
 // The swift-tools-version declares the minimum version of Swift required to build this package.
 
 import PackageDescription
@@ -24,8 +24,7 @@ let package = Package(
         // Targets are the basic building blocks of a package. A target can define a module or a test suite.
         // Targets can depend on other targets in this package, and on products in packages which this package depends on.
         .target(
-            name: "GCDCoreOperations",
-            dependencies: []),
+            name: "GCDCoreOperations"),
         .target(
             name: "GCDOperations",
             dependencies: ["GCDCoreOperations"]),

Package@swift-5.3.swift Package@swift-5.5.swiftPackage@swift-5.3.swift renamed to Package@swift-5.5.swift

@@ -1,4 +1,4 @@
-// swift-tools-version:5.3
+// swift-tools-version:5.5
 // The swift-tools-version declares the minimum version of Swift required to build this package.
 
 import PackageDescription
@@ -24,8 +24,7 @@ let package = Package(
         // Targets are the basic building blocks of a package. A target can define a module or a test suite.
         // Targets can depend on other targets in this package, and on products in packages which this package depends on.
         .target(
-            name: "GCDCoreOperations",
-            dependencies: []),
+            name: "GCDCoreOperations"),
         .target(
             name: "GCDOperations",
             dependencies: ["GCDCoreOperations"]),

Sources/GCDCoreOperations/Base Classes/GroupOperation.swift

@@ -4,27 +4,37 @@ import Dispatch
 public final class GroupOperation: Operation {
     private let group = DispatchGroup()
 
+    @Synchronized
+    private var _operations: ContiguousArray<Operation>
     /// The operations grouped inside this operation.
-    public private(set) var operations: ContiguousArray<Operation>
+    public var operations: ContiguousArray<Operation> { _operations }
 
     /// Creates a new GroupOperation with the given list of operations.
     /// - Parameter operations: The operations to execute grouped in this operation.
     public init(operations: ContiguousArray<Operation>) {
-        self.operations = operations
+        __operations = .init(wrappedValue: operations)
+    }
+
+    /// Creates a new GroupOperation with the given list of operations.
+    /// - Parameter operations: The operations to execute grouped in this
+    @inlinable
+    public convenience init<C: Collection>(operations: C) where C.Element == Operation {
+        self.init(operations: .init(operations))
     }
 
     /// Creates a new GroupOperation with the given variadic list of operations.
     /// - Parameter operations: The variadic list of operations to execute grouped in this operation.
+    @inlinable
     public convenience init(operations: Operation...) {
-        self.init(operations: ContiguousArray(operations))
+        self.init(operations: operations)
     }
 
     /// Adds a new operation to this GroupOperation.
     /// - Parameter op: The operation to add.
     /// - Precondition: This GroupOperation must not have finished yet!
     public func addOperation(_ op: Operation) {
         assert(!isFinished, "Cannot add operations after GroupOperation has finished!")
-        operations.append(op)
+        __operations.withValue { $0.append(op) }
         if case .running = state, let queue = queue {
             includeOperation(op, on: queue)
         }
@@ -37,7 +47,7 @@ public final class GroupOperation: Operation {
     where Operations: Collection, Operations.Element == Operation
     {
         assert(!isFinished, "Cannot add operations after GroupOperation has finished!")
-        operations.append(contentsOf: ops)
+        __operations.withValue { $0.append(contentsOf: ops) }
         if case .running = state, let queue = queue {
             ops.forEach { includeOperation($0, on: queue) }
         }

Sources/GCDCoreOperations/Base Classes/Operation.swift

@@ -22,15 +22,16 @@ open class Operation: CustomStringConvertible, CustomDebugStringConvertible {
     @Synchronized
     internal final var state: State = .created
 
+    // queue, observers and conditions are write-protected using `state`.
     internal private(set) final var queue: DispatchQueue?
 
     /// The list of observers of this operation.
-    public private(set) final var observers: [OperationObserver] = []
+    public private(set) final var observers = Array<OperationObserver>()
     /// The list of conditions of this operation.
-    public private(set) final var conditions: [OperationCondition] = []
+    public private(set) final var conditions = Array<OperationCondition>()
 
     @Synchronized
-    private final var _dependencies: ContiguousArray<Operation> = []
+    private final var _dependencies = ContiguousArray<Operation>()
     /// The list of dependencies of this operation.
     public final var dependencies: ContiguousArray<Operation> { _dependencies }
 
@@ -39,7 +40,9 @@ open class Operation: CustomStringConvertible, CustomDebugStringConvertible {
     private let dependenciesGroup = DispatchGroup()
 
     /// The list of errors this operation encountered.
-    public private(set) final var errors: [Error] = []
+    @Synchronized
+    private final var _errors = Array<Error>()
+    public final var errors: Array<Error> { _errors }
 
     // MARK: - State Accessors
     /// Whether or not this operation was cancelled.
@@ -117,7 +120,7 @@ open class Operation: CustomStringConvertible, CustomDebugStringConvertible {
     /// Aggregates a collection of errors into the list of errors of this operation.
     /// - Parameter newErrors: The collections of errors to aggregate.
     public final func aggregate<Errors>(errors newErrors: Errors) where Errors: Collection, Errors.Element: Error {
-        errors.append(contentsOf: newErrors.lazy.map { $0 })
+        __errors.withValue { $0.append(contentsOf: newErrors.lazy.map { $0 }) }
     }
 
     /// Aggregates a variadic list of errors into the list of errors of this operation.
@@ -153,11 +156,7 @@ open class Operation: CustomStringConvertible, CustomDebugStringConvertible {
             return false
         }
         guard !isCancelled else { return }
-        if let group = group {
-            queue.async(group: group, execute: run)
-        } else {
-            queue.async(execute: run)
-        }
+        queue.async(group: group, execute: run)
     }
 
     private final func run() {

Sources/GCDCoreOperations/Base Classes/OperationQueue.swift

@@ -1,14 +1,14 @@
 import Dispatch
 #if os(Linux)
-    import func CoreFoundation._CFIsMainThread
+import func CoreFoundation._CFIsMainThread
 #endif
 
 private func isMainThread() -> Bool {
-    #if os(Linux)
-        return _CFIsMainThread()
-    #else
-        return pthread_main_np() != 0
-    #endif
+#if os(Linux)
+    return _CFIsMainThread()
+#else
+    return pthread_main_np() != 0
+#endif
 }
 
 private let _operationQueueKey = DispatchSpecificKey<Unmanaged<OperationQueue>>()
@@ -46,7 +46,7 @@ public final class OperationQueue {
 
     private let queue: DispatchQueue
     private let operationsGroup = DispatchGroup()
-    private var operations: Dictionary<Int, Operation> = [:]
+    private var operations = Dictionary<Int, Operation>()
 
     /// Whether or not the queue is currently suspended.
     public private(set) var isSuspended: Bool
@@ -100,7 +100,7 @@ public final class OperationQueue {
         operationsGroup.enter()
         op.addObserver(QueueObserver(queue: self))
         let operationIdentifier = op._queueID
-        assert(operations[operationIdentifier] == nil, "Operation \(op) has already been added to this queue!")
+        assert(!operations.keys.contains(operationIdentifier), "Operation \(op) has already been added to this queue!")
         operations[operationIdentifier] = op
 
         op.conditions.lazy
@@ -129,7 +129,7 @@ public final class OperationQueue {
         dispatchPrecondition(condition: .notOnQueue(lockQueue))
         lockQueue.sync {
             let opID = op._queueID
-            assert(operations[opID] != nil, "Operation \(op) is not enqueued in this queue!")
+            assert(operations.keys.contains(opID), "Operation \(op) is not enqueued in this queue!")
             operations.removeValue(forKey: opID)
             operationsGroup.leave()
         }

Sources/GCDCoreOperations/Condition/ExclusivityController.swift

@@ -1,7 +1,7 @@
 @frozen
 enum ExclusivityController {
     @Synchronized
-    private static var operations: [String: ContiguousArray<Operation>] = [:]
+    private static var operations = Dictionary<String, ContiguousArray<Operation>>()
 
     static func addOperation<Categories: Collection>(_ operation: Operation, categories: Categories)
     where Categories.Element == String

Sources/GCDCoreOperations/Helpers/Synchronized.swift

@@ -11,7 +11,7 @@ final class Synchronized<Value> {
         dispatchPrecondition(condition: .notOnQueue(accessQueue))
         return accessQueue.sync { _wrappedValue }
     }
-    
+
     init(wrappedValue: Value) { _wrappedValue = wrappedValue }
 
     func withValue<T>(do work: (inout Value) throws -> T) rethrows -> T {
@@ -38,3 +38,7 @@ final class Synchronized<Value> {
         }
     }
 }
+
+#if compiler(>=5.5) && canImport(_Concurrency)
+extension Synchronized: @unchecked Sendable {}
+#endif