chore: only use swift 6

Author: ph1ps

Package.swift

@@ -1,4 +1,4 @@
-// swift-tools-version: 5.9
+// swift-tools-version: 6.0
 
 import PackageDescription
 
@@ -13,16 +13,15 @@ let package = Package(
   ],
   targets: [
     .target(
-      name: "Deadline",
-      swiftSettings: [.enableExperimentalFeature("StrictConcurrency")]
+      name: "Deadline"
     ),
     .testTarget(
       name: "DeadlineTests",
       dependencies: [
         "Deadline",
         .product(name: "Clocks", package: "swift-clocks")
-      ],
-      swiftSettings: [.enableExperimentalFeature("StrictConcurrency")]
+      ]
     )
-  ]
+  ],
+  swiftLanguageModes: [.v6]
 )

Sources/Deadline/Deadline.swift

@@ -6,7 +6,6 @@ enum DeadlineState<T>: Sendable where T: Sendable {
 /// An error indicating that the deadline has passed and the operation did not complete.
 public struct DeadlineExceededError: Error { }
 
-#if swift(>=6.0)
 /// Race the given operation against a deadline.
 ///
 /// This function provides a mechanism for enforcing timeouts on asynchronous operations that lack native deadline support. It creates a `TaskGroup` with two concurrent tasks: the provided operation and a sleep task.
@@ -203,196 +202,3 @@ public func deadline<R>(
 ) async throws -> R where R: Sendable {
   try await deadline(until: instant, tolerance: tolerance, clock: ContinuousClock(), isolation: isolation, operation: operation)
 }
-#else
-/// Race the given operation against a deadline.
-///
-/// This function provides a mechanism for enforcing timeouts on asynchronous operations that lack native deadline support. It creates a `TaskGroup` with two concurrent tasks: the provided operation and a sleep task.
-///
-/// - Parameters:
-///   - instant: The absolute deadline for the operation to complete.
-///   - tolerance: The allowed tolerance for the deadline.
-///   - clock: The clock used for timing the operation.
-///   - operation: The asynchronous operation to be executed.
-///
-/// - Returns: The result of the operation if it completes before the deadline.
-/// - Throws: `DeadlineExceededError`, if the operation fails to complete before the deadline and errors thrown by the operation or clock.
-///
-/// ## Examples
-/// To fully understand this, let's illustrate the 3 outcomes of this function:
-///
-/// ### Outcome 1
-/// The operation finishes in time:
-/// ```swift
-/// let result = try await deadline(until: .now + .seconds(5)) {
-///   // Simulate long running task
-///   try await Task.sleep(for: .seconds(1))
-///   return "success"
-/// }
-/// ```
-/// As you'd expect, result will be "success". The same applies when your operation fails in time:
-/// ```swift
-/// let result = try await deadline(until: .now + .seconds(5)) {
-///   // Simulate long running task
-///   try await Task.sleep(for: .seconds(1))
-///   throw CustomError()
-/// }
-/// ```
-/// This will throw `CustomError`.
-///
-/// ## Outcome 2
-/// The operation does not finish in time:
-/// ```swift
-/// let result = try await deadline(until: .now + .seconds(1)) {
-///   // Simulate even longer running task
-///   try await Task.sleep(for: .seconds(5))
-///   return "success"
-/// }
-/// ```
-/// This will throw `DeadlineExceededError` because the operation will not finish in time.
-///
-/// ## Outcome 3
-/// The parent task was cancelled:
-/// ```swift
-/// let task = Task {
-///   do {
-///     try await deadline(until: .now + .seconds(5)) {
-///       try await URLSession.shared.data(from: url)
-///     }
-///   } catch {
-///     print(error)
-///   }
-/// }
-///
-/// task.cancel()
-/// ```
-/// The print is guaranteed to print `URLError(.cancelled)`.
-/// - Important: The operation closure must support cooperative cancellation. Otherwise, the deadline will not be respected.
-public func deadline<C, R>(
-  until instant: C.Instant,
-  tolerance: C.Instant.Duration? = nil,
-  clock: C,
-  operation: @Sendable () async throws -> R
-) async throws -> R where C: Clock, R: Sendable {
-  
-  // NB: This is safe to use, because the closure will not escape the context of this function.
-  let result = await withoutActuallyEscaping(operation) { operation in
-    await withTaskGroup(
-      of: DeadlineState<R>.self,
-      returning: Result<R, any Error>.self
-    ) { taskGroup in
-      
-      taskGroup.addTask {
-        do {
-          let result = try await operation()
-          return .operationResult(.success(result))
-        } catch {
-          return .operationResult(.failure(error))
-        }
-      }
-      
-      taskGroup.addTask {
-        do {
-          try await Task.sleep(until: instant, tolerance: tolerance, clock: clock)
-          return .sleepResult(.success(false))
-        } catch where Task.isCancelled {
-          return .sleepResult(.success(true))
-        } catch {
-          return .sleepResult(.failure(error))
-        }
-      }
-      
-      defer {
-        taskGroup.cancelAll()
-      }
-      
-      for await next in taskGroup {
-        switch next {
-        case .operationResult(let result):
-          return result
-        case .sleepResult(.success(false)):
-          return .failure(DeadlineExceededError())
-        case .sleepResult(.success(true)):
-          continue
-        case .sleepResult(.failure(let error)):
-          return .failure(error)
-        }
-      }
-      
-      preconditionFailure("Invalid state")
-    }
-  }
-  
-  return try result.get()
-}
-
-/// Race the given operation against a deadline.
-///
-/// This function provides a mechanism for enforcing timeouts on asynchronous operations that lack native deadline support. It creates a `TaskGroup` with two concurrent tasks: the provided operation and a sleep task.
-/// `ContinuousClock` will be used as the default clock.
-///
-/// - Parameters:
-///   - instant: The absolute deadline for the operation to complete.
-///   - tolerance: The allowed tolerance for the deadline.
-///   - operation: The asynchronous operation to be executed.
-///
-/// - Returns: The result of the operation if it completes before the deadline.
-/// - Throws: `DeadlineExceededError`, if the operation fails to complete before the deadline and errors thrown by the operation or clock.
-///
-/// ## Examples
-/// To fully understand this, let's illustrate the 3 outcomes of this function:
-///
-/// ### Outcome 1
-/// The operation finishes in time:
-/// ```swift
-/// let result = try await deadline(until: .now + .seconds(5)) {
-///   // Simulate long running task
-///   try await Task.sleep(for: .seconds(1))
-///   return "success"
-/// }
-/// ```
-/// As you'd expect, result will be "success". The same applies when your operation fails in time:
-/// ```swift
-/// let result = try await deadline(until: .now + .seconds(5)) {
-///   // Simulate long running task
-///   try await Task.sleep(for: .seconds(1))
-///   throw CustomError()
-/// }
-/// ```
-/// This will throw `CustomError`.
-///
-/// ## Outcome 2
-/// The operation does not finish in time:
-/// ```swift
-/// let result = try await deadline(until: .now + .seconds(1)) {
-///   // Simulate even longer running task
-///   try await Task.sleep(for: .seconds(5))
-///   return "success"
-/// }
-/// ```
-/// This will throw `DeadlineExceededError` because the operation will not finish in time.
-///
-/// ## Outcome 3
-/// The parent task was cancelled:
-/// ```swift
-/// let task = Task {
-///   do {
-///     try await deadline(until: .now + .seconds(5)) {
-///       try await URLSession.shared.data(from: url)
-///     }
-///   } catch {
-///     print(error)
-///   }
-/// }
-///
-/// task.cancel()
-/// ```
-/// The print is guaranteed to print `URLError(.cancelled)`.
-/// - Important: The operation closure must support cooperative cancellation. Otherwise, the deadline will not be respected.
-public func deadline<R>(
-  until instant: ContinuousClock.Instant,
-  tolerance: ContinuousClock.Instant.Duration? = nil,
-  operation: @Sendable () async throws -> R
-) async throws -> R where R: Sendable {
-  try await deadline(until: instant, tolerance: tolerance, clock: ContinuousClock(), operation: operation)
-}
-#endif