Cleanup Sendable conformances and @preconcurrency imports to build as strict concurrency clean (#230)

Author: phausler

Sources/AsyncAlgorithms/AsyncBufferSequence.swift

@@ -198,7 +198,7 @@ public actor AsyncLimitBuffer<Element: Sendable>: AsyncBuffer {
   }
 }
 
-extension AsyncSequence where Element: Sendable {
+extension AsyncSequence where Element: Sendable, Self: Sendable {
   /// Creates an asynchronous sequence that buffers elements using a buffer created from a supplied closure.
   ///
   /// Use the `buffer(_:)` method to account for `AsyncSequence` types that may produce elements faster
@@ -224,7 +224,7 @@ extension AsyncSequence where Element: Sendable {
 }
 
 /// An `AsyncSequence` that buffers elements utilizing an `AsyncBuffer`.
-public struct AsyncBufferSequence<Base: AsyncSequence, Buffer: AsyncBuffer> where Base.Element == Buffer.Input, Base.AsyncIterator: Sendable {
+public struct AsyncBufferSequence<Base: AsyncSequence & Sendable, Buffer: AsyncBuffer> where Base.Element == Buffer.Input {
   let base: Base
   let createBuffer: @Sendable () -> Buffer
 
@@ -246,11 +246,11 @@ extension AsyncBufferSequence: AsyncSequence {
       let buffer: Buffer
       let state: AsyncBufferState<Buffer.Input, Buffer.Output>
 
-      init(_ iterator: Base.AsyncIterator, buffer: Buffer, state: AsyncBufferState<Buffer.Input, Buffer.Output>) {
+      init(_ base: Base, buffer: Buffer, state: AsyncBufferState<Buffer.Input, Buffer.Output>) {
         self.buffer = buffer
         self.state = state
         task = Task {
-          var iter = iterator
+          var iter = base.makeAsyncIterator()
           do {
             while let item = try await iter.next() {
               await state.enqueue(item, buffer: buffer)
@@ -279,21 +279,21 @@ extension AsyncBufferSequence: AsyncSequence {
     }
 
     enum State {
-      case idle(Base.AsyncIterator, @Sendable () -> Buffer)
+      case idle(Base, @Sendable () -> Buffer)
       case active(Active)
     }
 
     var state: State
 
-    init(_ iterator: Base.AsyncIterator, createBuffer: @Sendable @escaping () -> Buffer) {
-      state = .idle(iterator, createBuffer)
+    init(_ base: Base, createBuffer: @Sendable @escaping () -> Buffer) {
+      state = .idle(base, createBuffer)
     }
 
     public mutating func next() async rethrows -> Element? {
       switch state {
-      case .idle(let iterator, let createBuffer):
+      case .idle(let base, let createBuffer):
         let bufferState = AsyncBufferState<Base.Element, Buffer.Output>()
-        let buffer = Active(iterator, buffer: createBuffer(), state: bufferState)
+        let buffer = Active(base, buffer: createBuffer(), state: bufferState)
         state = .active(buffer)
         return try await buffer.next()
       case .active(let buffer):
@@ -303,6 +303,6 @@ extension AsyncBufferSequence: AsyncSequence {
   }
 
   public func makeAsyncIterator() -> Iterator {
-    Iterator(base.makeAsyncIterator(), createBuffer: createBuffer)
+    Iterator(base, createBuffer: createBuffer)
   }
 }

Sources/AsyncAlgorithms/AsyncChannel.swift

@@ -9,7 +9,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-import OrderedCollections
+@preconcurrency import OrderedCollections
 
 /// A channel for sending elements from one task to another with back pressure.
 ///
@@ -58,7 +58,7 @@ public final class AsyncChannel<Element: Sendable>: AsyncSequence, Sendable {
   typealias Pending = ChannelToken<UnsafeContinuation<UnsafeContinuation<Element?, Never>?, Never>>
   typealias Awaiting = ChannelToken<UnsafeContinuation<Element?, Never>>
 
-  struct ChannelToken<Continuation>: Hashable {
+  struct ChannelToken<Continuation: Sendable>: Hashable, Sendable {
     var generation: Int
     var continuation: Continuation?
 
@@ -86,14 +86,14 @@ public final class AsyncChannel<Element: Sendable>: AsyncSequence, Sendable {
     case cancelled
   }
 
-  enum Emission {
+  enum Emission : Sendable {
     case idle
     case pending(OrderedSet<Pending>)
     case awaiting(OrderedSet<Awaiting>)
     case finished
   }
 
-  struct State {
+  struct State : Sendable {
     var emission: Emission = .idle
     var generation = 0
   }

Sources/AsyncAlgorithms/AsyncCompactedSequence.swift

@@ -68,4 +68,4 @@ extension AsyncSequence {
   }
 }
 
-extension AsyncCompactedSequence: Sendable where Base: Sendable, Base.Element: Sendable, Base.AsyncIterator: Sendable { }
+extension AsyncCompactedSequence: Sendable where Base: Sendable, Base.Element: Sendable { }

Sources/AsyncAlgorithms/AsyncInterspersedSequence.swift

@@ -99,4 +99,4 @@ extension AsyncInterspersedSequence: AsyncSequence {
   }
 }
 
-extension AsyncInterspersedSequence: Sendable where Base: Sendable, Base.Element: Sendable, Base.AsyncIterator: Sendable { }
+extension AsyncInterspersedSequence: Sendable where Base: Sendable, Base.Element: Sendable { }

Sources/AsyncAlgorithms/AsyncJoinedSequence.swift

@@ -91,4 +91,4 @@ public struct AsyncJoinedSequence<Base: AsyncSequence>: AsyncSequence where Base
 }
 
 extension AsyncJoinedSequence: Sendable
-where Base: Sendable, Base.Element: Sendable, Base.Element.Element: Sendable, Base.AsyncIterator: Sendable, Base.Element.AsyncIterator: Sendable { }
+where Base: Sendable, Base.Element: Sendable, Base.Element.Element: Sendable { }

Sources/AsyncAlgorithms/AsyncRemoveDuplicatesSequence.swift

@@ -85,9 +85,6 @@ public struct AsyncRemoveDuplicatesSequence<Base: AsyncSequence>: AsyncSequence
   }
 }
 
-extension AsyncRemoveDuplicatesSequence: Sendable where Base: Sendable, Base.Element: Sendable, Base.AsyncIterator: Sendable { }
-
-
 /// An asynchronous sequence that omits repeated elements by testing them with an error-throwing predicate.
 public struct AsyncThrowingRemoveDuplicatesSequence<Base: AsyncSequence>: AsyncSequence {
   public typealias Element = Base.Element
@@ -143,4 +140,6 @@ public struct AsyncThrowingRemoveDuplicatesSequence<Base: AsyncSequence>: AsyncS
   }
 }
 
-extension AsyncThrowingRemoveDuplicatesSequence: Sendable where Base: Sendable, Base.Element: Sendable, Base.AsyncIterator: Sendable { }
+
+extension AsyncRemoveDuplicatesSequence: Sendable where Base: Sendable, Base.Element: Sendable { }
+extension AsyncThrowingRemoveDuplicatesSequence: Sendable where Base: Sendable, Base.Element: Sendable { }

Sources/AsyncAlgorithms/AsyncThrowingChannel.swift

@@ -9,7 +9,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-import OrderedCollections
+@preconcurrency import OrderedCollections
 
 /// An error-throwing channel for sending elements from on task to another with back pressure.
 ///
@@ -61,7 +61,7 @@ public final class AsyncThrowingChannel<Element: Sendable, Failure: Error>: Asyn
   typealias Pending = ChannelToken<UnsafeContinuation<UnsafeContinuation<Element?, Error>?, Never>>
   typealias Awaiting = ChannelToken<UnsafeContinuation<Element?, Error>>
 
-  struct ChannelToken<Continuation>: Hashable {
+  struct ChannelToken<Continuation: Sendable>: Hashable, Sendable {
     var generation: Int
     var continuation: Continuation?
 
@@ -95,14 +95,14 @@ public final class AsyncThrowingChannel<Element: Sendable, Failure: Error>: Asyn
     case failed(Error)
   }
 
-  enum Emission {
+  enum Emission: Sendable {
     case idle
     case pending(OrderedSet<Pending>)
     case awaiting(OrderedSet<Awaiting>)
     case terminated(Termination)
   }
 
-  struct State {
+  struct State : Sendable {
     var emission: Emission = .idle
     var generation = 0
   }

Sources/AsyncAlgorithms/CombineLatest/AsyncCombineLatest2Sequence.swift

@@ -35,7 +35,7 @@ public func combineLatest<
 public struct AsyncCombineLatest2Sequence<
   Base1: AsyncSequence,
   Base2: AsyncSequence
->: AsyncSequence where
+>: AsyncSequence, Sendable where
   Base1: Sendable,
   Base1.Element: Sendable,
   Base2: Sendable,

Sources/AsyncAlgorithms/CombineLatest/AsyncCombineLatest3Sequence.swift

@@ -39,7 +39,7 @@ public struct AsyncCombineLatest3Sequence<
   Base1: AsyncSequence,
   Base2: AsyncSequence,
   Base3: AsyncSequence
->: AsyncSequence where
+>: AsyncSequence, Sendable where
   Base1: Sendable,
   Base1.Element: Sendable,
   Base2: Sendable,

Sources/AsyncAlgorithms/Zip/AsyncZip2Sequence.swift

@@ -20,7 +20,7 @@ public func zip<Base1: AsyncSequence, Base2: AsyncSequence>(
 
 /// An asynchronous sequence that concurrently awaits values from two `AsyncSequence` types
 /// and emits a tuple of the values.
-public struct AsyncZip2Sequence<Base1: AsyncSequence, Base2: AsyncSequence>: AsyncSequence
+public struct AsyncZip2Sequence<Base1: AsyncSequence, Base2: AsyncSequence>: AsyncSequence, Sendable
   where Base1: Sendable, Base1.Element: Sendable, Base2: Sendable, Base2.Element: Sendable {
   public typealias Element = (Base1.Element, Base2.Element)
   public typealias AsyncIterator = Iterator

Sources/AsyncAlgorithms/Zip/AsyncZip3Sequence.swift

@@ -21,7 +21,7 @@ public func zip<Base1: AsyncSequence, Base2: AsyncSequence, Base3: AsyncSequence
 
 /// An asynchronous sequence that concurrently awaits values from three `AsyncSequence` types
 /// and emits a tuple of the values.
-public struct AsyncZip3Sequence<Base1: AsyncSequence, Base2: AsyncSequence, Base3: AsyncSequence>: AsyncSequence
+public struct AsyncZip3Sequence<Base1: AsyncSequence, Base2: AsyncSequence, Base3: AsyncSequence>: AsyncSequence, Sendable
   where Base1: Sendable, Base1.Element: Sendable, Base2: Sendable, Base2.Element: Sendable, Base3: Sendable, Base3.Element: Sendable {
   public typealias Element = (Base1.Element, Base2.Element, Base3.Element)
   public typealias AsyncIterator = Iterator

Tests/AsyncAlgorithmsTests/Performance/ThroughputMeasurement.swift

@@ -11,7 +11,7 @@
 
 import AsyncAlgorithms
 import Foundation
-@preconcurrency import XCTest
+import XCTest
 
 #if canImport(Darwin)
 public struct InfiniteAsyncSequence<Value: Sendable>: AsyncSequence, Sendable {

Tests/AsyncAlgorithmsTests/Support/ReportingSequence.swift

@@ -43,7 +43,7 @@ final class ReportingSequence<Element>: Sequence, IteratorProtocol {
   }
 }
 
-final class ReportingAsyncSequence<Element>: AsyncSequence, AsyncIteratorProtocol {
+final class ReportingAsyncSequence<Element: Sendable>: AsyncSequence, AsyncIteratorProtocol, @unchecked Sendable {
   enum Event: Equatable, CustomStringConvertible {
     case next
     case makeAsyncIterator

Tests/AsyncAlgorithmsTests/TestAdjacentPairs.swift

@@ -9,7 +9,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-@preconcurrency import XCTest
+import XCTest
 import AsyncAlgorithms
 
 final class TestAdjacentPairs: XCTestCase {