Fix compile errors for Swift 6 language mode

Author: b1ackturtle

Sources/AsyncAlgorithms_XCTest/ValidationTest.swift

@@ -24,7 +24,7 @@ extension XCTestCase {
 #endif
   }
 
-  func validate<Test: AsyncSequenceValidationTest, Theme: AsyncSequenceValidationTheme>(theme: Theme, expectedFailures: Set<String>, @AsyncSequenceValidationDiagram _ build: (AsyncSequenceValidationDiagram) -> Test, file: StaticString = #file, line: UInt = #line) {
+  func validate<Test: AsyncSequenceValidationTest, Theme: AsyncSequenceValidationTheme>(theme: Theme, expectedFailures: Set<String>, @AsyncSequenceValidationDiagram _ build: (AsyncSequenceValidationDiagram) -> Test, file: StaticString = #filePath, line: UInt = #line) {
     var expectations = expectedFailures
     var result: AsyncSequenceValidationDiagram.ExpectationResult?
     var failures = [AsyncSequenceValidationDiagram.ExpectationFailure]()
@@ -62,15 +62,15 @@ extension XCTestCase {
     }
   }
 
-  func validate<Test: AsyncSequenceValidationTest>(expectedFailures: Set<String>, @AsyncSequenceValidationDiagram _ build: (AsyncSequenceValidationDiagram) -> Test, file: StaticString = #file, line: UInt = #line) {
+  func validate<Test: AsyncSequenceValidationTest>(expectedFailures: Set<String>, @AsyncSequenceValidationDiagram _ build: (AsyncSequenceValidationDiagram) -> Test, file: StaticString = #filePath, line: UInt = #line) {
     validate(theme: .ascii, expectedFailures: expectedFailures, build, file: file, line: line)
   }
 
-  public func validate<Test: AsyncSequenceValidationTest, Theme: AsyncSequenceValidationTheme>(theme: Theme, @AsyncSequenceValidationDiagram _ build: (AsyncSequenceValidationDiagram) -> Test, file: StaticString = #file, line: UInt = #line) {
+  public func validate<Test: AsyncSequenceValidationTest, Theme: AsyncSequenceValidationTheme>(theme: Theme, @AsyncSequenceValidationDiagram _ build: (AsyncSequenceValidationDiagram) -> Test, file: StaticString = #filePath, line: UInt = #line) {
     validate(theme: theme, expectedFailures: [], build, file: file, line: line)
   }
 
-  public func validate<Test: AsyncSequenceValidationTest>(@AsyncSequenceValidationDiagram _ build: (AsyncSequenceValidationDiagram) -> Test, file: StaticString = #file, line: UInt = #line) {
+  public func validate<Test: AsyncSequenceValidationTest>(@AsyncSequenceValidationDiagram _ build: (AsyncSequenceValidationDiagram) -> Test, file: StaticString = #filePath, line: UInt = #line) {
     validate(theme: .ascii, expectedFailures: [], build, file: file, line: line)
   }
 }

Sources/AsyncSequenceValidation/Clock.swift

@@ -115,7 +115,7 @@ extension AsyncSequenceValidationDiagram.Clock {
     let token = queue.prepare()
     try await withTaskCancellationHandler {
       try await withUnsafeThrowingContinuation { continuation in
-        queue.enqueue(AsyncSequenceValidationDiagram.Context.currentJob, deadline: deadline, continuation: continuation, token: token)
+        queue.enqueue(AsyncSequenceValidationDiagram.Context.currentJob.value, deadline: deadline, continuation: continuation, token: token)
       }
     } onCancel: {
       queue.cancel(token)

Sources/AsyncSequenceValidation/Input.swift

@@ -52,7 +52,7 @@ extension AsyncSequenceValidationDiagram {
         }
         return try await withTaskCancellationHandler {
           try await withUnsafeThrowingContinuation { continuation in
-            queue.enqueue(Context.currentJob, deadline: when, continuation: continuation, results[eventIndex], index: index, token: token)
+            queue.enqueue(Context.currentJob.value, deadline: when, continuation: continuation, results[eventIndex], index: index, token: token)
           }
         } onCancel: { [queue] in
           queue.cancel(token)

Sources/AsyncSequenceValidation/TaskDriver.swift

@@ -20,12 +20,12 @@ import Glibc
 #endif
 
 #if canImport(Darwin)
-func start_thread(_ raw: UnsafeMutableRawPointer) -> UnsafeMutableRawPointer? {
+@Sendable func start_thread(_ raw: UnsafeMutableRawPointer) -> UnsafeMutableRawPointer? {
   Unmanaged<TaskDriver>.fromOpaque(raw).takeRetainedValue().run()
   return nil
 }
 #elseif canImport(Glibc)
-func start_thread(_ raw: UnsafeMutableRawPointer?) -> UnsafeMutableRawPointer? {
+@Sendable func start_thread(_ raw: UnsafeMutableRawPointer?) -> UnsafeMutableRawPointer? {
   Unmanaged<TaskDriver>.fromOpaque(raw!).takeRetainedValue().run()
   return nil
 }
@@ -77,11 +77,11 @@ final class TaskDriver {
 
   func enqueue(_ job: JobRef) {
     let job = Job(job)
-    queue.enqueue(AsyncSequenceValidationDiagram.Context.currentJob) {
-      let previous = AsyncSequenceValidationDiagram.Context.currentJob
-      AsyncSequenceValidationDiagram.Context.currentJob = job
+    queue.enqueue(AsyncSequenceValidationDiagram.Context.currentJob.value) {
+      let previous = AsyncSequenceValidationDiagram.Context.currentJob.value
+      AsyncSequenceValidationDiagram.Context.currentJob.setValue(job)
       job.execute()
-      AsyncSequenceValidationDiagram.Context.currentJob = previous
+      AsyncSequenceValidationDiagram.Context.currentJob.setValue(previous)
     }
   }
 }

Sources/AsyncSequenceValidation/Test.swift

@@ -9,7 +9,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-import _CAsyncSequenceValidationSupport
+@preconcurrency import _CAsyncSequenceValidationSupport
 import AsyncAlgorithms
 
 @_silgen_name("swift_job_run")
@@ -48,17 +48,17 @@ extension AsyncSequenceValidationDiagram {
         do {
           if let pastEnd = try await iterator.next(){
             let failure = ExpectationFailure(
-              when: Context.clock!.now,
+              when: Context.clock.value!.now,
               kind: .specificationViolationGotValueAfterIteration(pastEnd),
               specification: output)
-            Context.specificationFailures.append(failure)
+            Context.specificationFailures.withValue { $0.append(failure) }
           }
         } catch {
           let failure = ExpectationFailure(
-            when: Context.clock!.now,
+            when: Context.clock.value!.now,
             kind: .specificationViolationGotFailureAfterIteration(error),
             specification: output)
-          Context.specificationFailures.append(failure)
+          Context.specificationFailures.withValue { $0.append(failure) }
         }
       } catch {
         throw error
@@ -107,7 +107,7 @@ extension AsyncSequenceValidationDiagram {
       }
     }
 
-    private static let _executor: AnyObject = {
+    private static let _executor: any SerialExecutor = {
       if #available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *) {
         return ClockExecutor_5_9()
       } else {
@@ -116,19 +116,19 @@ extension AsyncSequenceValidationDiagram {
     }()
 
     static var unownedExecutor: UnownedSerialExecutor {
-      (_executor as! any SerialExecutor).asUnownedSerialExecutor()
+      _executor.asUnownedSerialExecutor()
     }
 #endif
 
-    static var clock: Clock?
-    
-    
-    
-    static var driver: TaskDriver?
+    static let clock = LockIsolated<Clock?>(nil)
+
 
-    static var currentJob: Job?
 
-    static var specificationFailures = [ExpectationFailure]()
+    static let driver = LockIsolated<TaskDriver?>(nil)
+
+    static let currentJob = LockIsolated<Job?>(nil)
+
+    static let specificationFailures = LockIsolated<[ExpectationFailure]>([])
   }
 
   enum ActualResult {
@@ -158,9 +158,9 @@ extension AsyncSequenceValidationDiagram {
     actual: [(Clock.Instant, Result<String?, Error>)]
   ) -> (ExpectationResult, [ExpectationFailure]) {
     let result = ExpectationResult(expected: expected, actual: actual)
-    var failures = Context.specificationFailures
-    Context.specificationFailures.removeAll()
-    
+    var failures = Context.specificationFailures.value
+    Context.specificationFailures.withValue { $0.removeAll() }
+
     let actualTimes = actual.map { when, _ in when }
     let expectedTimes = expected.map { $0.when }
 
@@ -349,14 +349,14 @@ extension AsyncSequenceValidationDiagram {
     }
 
     let actual = ManagedCriticalState([(Clock.Instant, Result<String?, Error>)]())
-    Context.clock = clock
-    Context.specificationFailures.removeAll()
+    Context.clock.setValue(clock)
+    Context.specificationFailures.withValue { $0.removeAll() }
     // This all needs to be isolated from potential Tasks (the caller function might be async!)
-    Context.driver = TaskDriver(queue: diagram.queue) { driver in
+    Context.driver.setValue(TaskDriver(queue: diagram.queue) { driver in
       swift_task_enqueueGlobal_hook = { job, original in
-        Context.driver?.enqueue(job)
+        Context.driver.value?.enqueue(job)
       }
-      
+
       let runner = Task {
         do {
           try await test.test(with: clock, activeTicks: activeTicks, output: test.output) { event in
@@ -389,15 +389,15 @@ extension AsyncSequenceValidationDiagram {
       }
 
       runner.cancel()
-      Context.clock = nil
+      Context.clock.setValue(nil)
       swift_task_enqueueGlobal_hook = nil
-    }
-    Context.driver?.start()
+    })
+    Context.driver.value?.start()
     // This is only valid since we are doing tests here
     // else wise this would cause QoS inversions
-    Context.driver?.join()
-    Context.driver = nil
-    
+    Context.driver.value?.join()
+    Context.driver.setValue(nil)
+
     return validate(
       inputs: test.inputs,
       output: test.output,
@@ -412,3 +412,32 @@ extension AsyncSequenceValidationDiagram {
     try self.test(theme: .ascii, build)
   }
 }
+
+final class LockIsolated<Value>: @unchecked Sendable {
+  private var _value: Value
+  private let lock = Lock.allocate()
+
+  init(_ value: @autoclosure @Sendable () throws -> Value) rethrows {
+    self._value = try value()
+  }
+
+  func setValue(_ newValue: @autoclosure @Sendable () throws -> Value) rethrows {
+    try self.lock.withLock {
+      self._value = try newValue()
+    }
+  }
+
+  var value: Value {
+    self.lock.withLock {
+      self._value
+    }
+  }
+
+  func withValue<T: Sendable>(_ operation: @Sendable (inout Value) throws -> T) rethrows -> T {
+    try self.lock.withLock {
+      var value = self._value
+      defer { self._value = value }
+      return try operation(&value)
+    }
+  }
+}

Tests/AsyncAlgorithmsTests/Support/Asserts.swift

@@ -154,7 +154,7 @@ public func XCTAssertEqual<A: Equatable, B: Equatable, C: Equatable>(_ expressio
 @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *)
 internal func XCTAssertThrowsError<T>(
     _ expression: @autoclosure () async throws -> T,
-    file: StaticString = #file,
+    file: StaticString = #filePath,
     line: UInt = #line,
     verify: (Error) -> Void = { _ in }
 ) async {