chore(patch): [sc-24600] use Task.immediate for runSync if possible (#71)

* chore(patch): [sc-24600] use Task.immediate for runSync if possible

* resolve some lints by the way

* create closure before condition

* revert sendability to avoid API break

* skip test different way

Author: blindspotbounty

Sources/ConcurrencyHelpers/Lock.swift

@@ -17,7 +17,7 @@
     #error("Unsupported Platform")
 #endif
 
-public final class Lock {
+public final class Lock: @unchecked Sendable {
     #if os(macOS)
         fileprivate let mutex = UnsafeMutablePointer<os_unfair_lock>.allocate(capacity: 1)
     #else
@@ -76,7 +76,3 @@ public final class Lock {
 }
 
 extension Lock: Lockable {}
-
-#if compiler(>=5.5) && canImport(_Concurrency)
-    extension Lock: Sendable {}
-#endif

Sources/ConcurrencyHelpers/NIOSendable.swift

@@ -1,4 +1,4 @@
-//===----------------------------------------------------------------------===//
+// ===----------------------------------------------------------------------=== //
 //
 // This source file is part of the SwiftNIO open source project
 //
@@ -10,29 +10,15 @@
 //
 // SPDX-License-Identifier: Apache-2.0
 //
-//===----------------------------------------------------------------------===//
+// ===----------------------------------------------------------------------=== //
 
 // Adopted from SwiftNIO for boxing values between concurrency domains when needed
 
-/*
- #if swift(>=5.5) && canImport(_Concurrency)
- public typealias NIOSendable = Swift.Sendable
- #else
- public typealias NIOSendable = Any
- #endif
-
- #if swift(>=5.6)
- @preconcurrency public protocol NIOPreconcurrencySendable: Sendable {}
- #else
- public protocol NIOPreconcurrencySendable {}
- #endif
- */
-
 /// ``UnsafeTransfer`` can be used to make non-`Sendable` values `Sendable`.
 /// As the name implies, the usage of this is unsafe because it disables the sendable checking of the compiler.
 /// It can be used similar to `@unsafe Sendable` but for values instead of types.
 
-public struct UnsafeTransfer<Wrapped> {
+public struct UnsafeTransfer<Wrapped>: @unchecked Sendable {
     public var wrappedValue: Wrapped
 
     @inlinable
@@ -41,25 +27,17 @@ public struct UnsafeTransfer<Wrapped> {
     }
 }
 
-#if swift(>=5.5) && canImport(_Concurrency)
-    extension UnsafeTransfer: @unchecked Sendable {}
-#endif
-
 extension UnsafeTransfer: Equatable where Wrapped: Equatable {}
 extension UnsafeTransfer: Hashable where Wrapped: Hashable {}
 
 /// ``UnsafeMutableTransferBox`` can be used to make non-`Sendable` values `Sendable` and mutable.
 /// It can be used to capture local mutable values in a `@Sendable` closure and mutate them from within the closure.
 /// As the name implies, the usage of this is unsafe because it disables the sendable checking of the compiler and does not add any synchronisation.
-public final class UnsafeMutableTransferBox<Wrapped> {
+public final class UnsafeMutableTransferBox<Wrapped>: @unchecked Sendable {
     public var wrappedValue: Wrapped
 
     @inlinable
     public init(_ wrappedValue: Wrapped) {
         self.wrappedValue = wrappedValue
     }
 }
-
-#if swift(>=5.5) && canImport(_Concurrency)
-    extension UnsafeMutableTransferBox: @unchecked Sendable {}
-#endif

Sources/ConcurrencyHelpers/RunSync.swift

@@ -23,7 +23,7 @@ public func runSync<T>(priority: TaskPriority? = nil, _ operation: () async -> T
 
         let wrapper = UnsafeMutableTransferBox(Optional(escapableOperation))
 
-        Task(priority: priority) { [wrapper] in
+        let body = { [wrapper] in
             result.wrappedValue = await wrapper.wrappedValue!()
 
             // Make sure reference to escapableOperation is released here otherwise
@@ -32,7 +32,18 @@ public func runSync<T>(priority: TaskPriority? = nil, _ operation: () async -> T
 
             semaphore.signal()
         }
-
+        #if compiler(>=6.2)
+            // preferably to have
+            // if #compiler (>=6.2) && #available(macOS 26, iOS 26, *)
+            // but that is not supported by swift...
+            if #available(macOS 26, iOS 26, *) {
+                Task.immediate(priority: priority, operation: body)
+            } else {
+                Task(priority: priority, operation: body)
+            }
+        #else
+            Task(priority: priority, operation: body)
+        #endif
         semaphore.wait()
     }
 

Sources/ConcurrencyHelpers/Spinlock.swift

@@ -6,11 +6,11 @@
 //
 // http://www.apache.org/licenses/LICENSE-2.0
 
-import Atomics
 import _PauseShims
+import Atomics
 
 /// Lock to protect very short critical sections.
-public final class Spinlock {
+public final class Spinlock: @unchecked Sendable {
     private typealias State = Bool
 
     private static let locked: State = true
@@ -52,7 +52,3 @@ public final class Spinlock {
 }
 
 extension Spinlock: Lockable {}
-
-#if compiler(>=5.5) && canImport(_Concurrency)
-    extension Spinlock: @unchecked Sendable {}
-#endif

Sources/ConcurrencyHelpers/YieldWithBackPressure.swift

@@ -16,8 +16,10 @@
 /// - Parameter continuation: The continuation to yield message to.
 /// - Returns: `true` if the `message` has been succesfully yielded to the stream and `false` in otherwise.
 @discardableResult
-public func yieldWithBackPressure<Message>(message: Message,
-                                           to continuation: AsyncStream<Message>.Continuation) async -> Bool {
+public func yieldWithBackPressure<Message>(
+    message: Message,
+    to continuation: AsyncStream<Message>.Continuation
+) async -> Bool {
     while true {
         let result = continuation.yield(message)
         switch result {

Tests/ConcurrencyHelpersTests/ConcurrencyHelpersTests.swift

@@ -34,11 +34,11 @@ final class ConcurrencyHelpersTests: XCTestCase {
         await doTestLockable(Lock.self)
     }
 
-    struct Data {
+    private struct Data {
         @Protected var valueA: Int = 1
-        @Protected var valueB: Int? = nil
+        @Protected var valueB: Int?
 
-        public mutating func setA(_ a: Int) {
+        mutating func setA(_ a: Int) {
             _valueA.write {
                 $0 = a
             }
@@ -77,7 +77,7 @@ final class ConcurrencyHelpersTests: XCTestCase {
         await doTestLockable(Spinlock.self)
     }
 
-    private func doTestLockable<Mutex: Lockable>(_: Mutex.Type) async {
+    private func doTestLockable<Mutex: Lockable & Sendable>(_: Mutex.Type) async {
         let taskCount = 10
         let iterationCount = 10_000
 
@@ -108,6 +108,28 @@ final class ConcurrencyHelpersTests: XCTestCase {
         XCTAssertEqual(result, 34 * 2)
     }
 
+    func testRunSyncInRunSync() throws {
+        #if !compiler(>=6.2)
+            throw XCTSkip("Skipping test: compiler version does not support immediate tasks")
+        #endif
+        guard #available(macOS 26, iOS 26, *) else {
+            throw XCTSkip("Skipping test: OS version does not support immediate tasks")
+        }
+
+        func runSyncRec(recursion: Int) -> Int {
+            if recursion <= 0 {
+                return runSync {
+                    await self.someAsyncMethod(argument: 34)
+                }
+            }
+            return runSync {
+                runSyncRec(recursion: recursion - 1)
+            }
+        }
+        let result = runSyncRec(recursion: 100)
+        XCTAssertEqual(result, 34 * 2)
+    }
+
     func testRunSyncWithPriority() {
         let result = runSync(priority: .userInitiated) { await self.someAsyncMethod(argument: 34) }
         XCTAssertEqual(result, 34 * 2)
@@ -155,7 +177,7 @@ final class ConcurrencyHelpersTests: XCTestCase {
                     print("Never")
                 }
             }
-            
+
             wrapper.exception = exception
         }
         let exception = wrapper.exception
@@ -191,7 +213,7 @@ final class ConcurrencyHelpersTests: XCTestCase {
     }
 }
 
-extension AsyncStream.Continuation.YieldResult: Equatable where Element: Equatable {
+extension AsyncStream.Continuation.YieldResult: @retroactive Equatable where Element: Equatable {
     public static func == (lhs: Self, rhs: Self) -> Bool {
         switch lhs {
         case .enqueued(let lhsRemaining):

Tests/HelpersTests/TimeIntervalCounterTests.swift

@@ -10,14 +10,6 @@
 import XCTest
 
 final class TimeIntervalCounterTests: XCTestCase {
-    override func setUp() {
-        super.setUp()
-    }
-
-    override func tearDown() {
-        super.tearDown()
-    }
-
     private func counterTest(forIterations iterations: UInt64, interval: Duration) {
         var counter = TimeIntervalCounter(clock: ContinuousClock(), timeInterval: interval)
         var checkPointExecuted = false