Make Send sendable (#2112)

* Make Send wrap a sendable closure.

* Move Send under the effects docs.

* Fixed a bunch of doc references.

* wip

* wip

* fix

---------

Co-authored-by: Stephen Celis <[email protected]>

Author: mbrandonw

Sources/ComposableArchitecture/Documentation.docc/Articles/Bindings.md

@@ -232,7 +232,7 @@ struct Settings: ReducerProtocol {
 ```
 
 Binding actions are constructed and sent to the store by calling
-``ViewStore/binding(_:file:fileID:line:)`` with a key path to the binding state:
+``ViewStore/binding(_:fileID:line:)`` with a key path to the binding state:
 
 ```swift
 TextField("Display name", text: viewStore.binding(\.$displayName))

Sources/ComposableArchitecture/Documentation.docc/Articles/MigratingToTheReducerProtocol.md

@@ -377,7 +377,7 @@ A `Parent` reducer conformances can be made by implementing the
 ``ReducerProtocol/body-swift.property-7foai`` property of the ``ReducerProtocol``, which allows you
 to express the parent's logic as a composition of multiple reducers. In particular, you can use
 the ``Reduce`` entry point to implement the core parent logic, and then chain on the 
-``ReducerProtocol/ifLet(_:action:then:file:fileID:line:)`` operator to identify the optional child
+``ReducerProtocol/ifLet(_:action:then:fileID:line:)`` operator to identify the optional child
 state that you want to run the `Feature` reducer on when non-`nil`:
 
 ```swift
@@ -408,7 +408,7 @@ Because the `ifLet` operator has knowledge of both the parent and child reducers
 order to add an additional layer of correctness.
 
 If you are using an enum to model your state, then there is a corresponding 
-``ReducerProtocol/ifCaseLet(_:action:then:file:fileID:line:)`` operator that can help you run a
+``ReducerProtocol/ifCaseLet(_:action:then:fileID:line:)`` operator that can help you run a
 reducer on just one case of the enum.
 
 ## For-each reducers
@@ -417,7 +417,7 @@ Similar to `optional` reducers, another common pattern in applications is the us
 ``AnyReducer/forEach(state:action:environment:file:fileID:line:)-2ypoa`` to allow running a reducer
 on each element of a collection. Converting such child and parent reducers will look nearly
 identical to what we did above for optional reducers, but it will make use of the new
-``ReducerProtocol/forEach(_:action:element:file:fileID:line:)`` operator instead.
+``ReducerProtocol/forEach(_:action:element:fileID:line:)`` operator instead.
 
 In particular, the new `forEach` method operates on the parent reducer by specifying the collection
 sub-state you want to work on, and providing the element reducer you want to be able to run on

Sources/ComposableArchitecture/Documentation.docc/Articles/SwiftConcurrency.md

@@ -8,7 +8,7 @@ for the time being, but in Swift 6 most (if not all) of these warnings will beco
 you will need to know how to prove to the compiler that your types are safe to use concurrently.
 
 There primary way to create an ``EffectTask`` in the library is via
-``EffectPublisher/run(priority:operation:catch:file:fileID:line:)``. It takes a `@Sendable`,
+``EffectPublisher/run(priority:operation:catch:fileID:line:)``. It takes a `@Sendable`,
 asynchronous closure, which restricts the types of closures you can use for your effects. In
 particular, the closure can only capture `Sendable` variables that are bound with `let`. Mutable
 variables and non-`Sendable` types are simply not allowed to be passed to `@Sendable` closures.

Sources/ComposableArchitecture/Documentation.docc/Articles/Testing.md

@@ -186,7 +186,7 @@ Location, Core Motion, Speech Recognition, etc.), and more.
 
 As a simple example, suppose we have a feature with a button such that when you tap it, it starts
 a timer that counts up until you reach 5, and then stops. This can be accomplished using the
-``EffectPublisher/run(priority:operation:catch:file:fileID:line:)`` helper on ``EffectTask``,
+``EffectPublisher/run(priority:operation:catch:fileID:line:)`` helper on ``EffectTask``,
 which provides you with an asynchronous context to operate in and can send multiple actions back 
 into the system:
 

Sources/ComposableArchitecture/Documentation.docc/Extensions/Deprecations/EffectDeprecations.md

@@ -15,7 +15,7 @@ Avoid using deprecated APIs in your app. Select a method to see the replacement
 
 ### Creating an effect
 
-- ``EffectPublisher/task(priority:operation:catch:file:fileID:line:)``
+- ``EffectPublisher/task(priority:operation:catch:fileID:line:)``
 - ``EffectPublisher/task(priority:operation:)``
 - ``EffectPublisher/fireAndForget(priority:_:)``
 

Sources/ComposableArchitecture/Documentation.docc/Extensions/Effect.md

@@ -5,7 +5,7 @@
 ### Creating an effect
 
 - ``EffectPublisher/none``
-- ``EffectPublisher/run(priority:operation:catch:file:fileID:line:)``
+- ``EffectPublisher/run(priority:operation:catch:fileID:line:)``
 - ``EffectPublisher/send(_:)``
 - ``TaskResult``
 

Sources/ComposableArchitecture/Documentation.docc/Extensions/EffectRun.md

@@ -1,4 +1,4 @@
-# ``ComposableArchitecture/EffectPublisher/run(priority:operation:catch:file:fileID:line:)``
+# ``ComposableArchitecture/EffectPublisher/run(priority:operation:catch:fileID:line:)``
 
 ## Topics
 

Sources/ComposableArchitecture/Documentation.docc/Extensions/ReducerProtocol.md

@@ -15,9 +15,9 @@
 - ``Body-swift.typealias``
 - ``ReducerBuilder``
 - ``Scope``
-- ``ifLet(_:action:then:file:fileID:line:)``
-- ``ifCaseLet(_:action:then:file:fileID:line:)``
-- ``forEach(_:action:element:file:fileID:line:)``
+- ``ifLet(_:action:then:fileID:line:)``
+- ``ifCaseLet(_:action:then:fileID:line:)``
+- ``forEach(_:action:element:fileID:line:)``
 
 ### Supporting reducers
 

Sources/ComposableArchitecture/Documentation.docc/Extensions/SwiftUI.md

@@ -23,7 +23,7 @@ The Composable Architecture can be used to power applications built in many fram
 - ``BindableAction``
 - ``BindingAction``
 - ``BindingReducer``
-- ``ViewStore/binding(_:file:fileID:line:)``
+- ``ViewStore/binding(_:fileID:line:)``
 
 <!--DocC: Can't currently document `View` extensions-->
 <!--### View Modifiers-->

Sources/ComposableArchitecture/Effect.swift

@@ -91,7 +91,7 @@ extension EffectPublisher {
 /// the other using Apple's Combine framework:
 ///
 /// * If using Swift's native structured concurrency tools then there is one main way to create an
-/// effect: ``EffectPublisher/run(priority:operation:catch:file:fileID:line:)``.
+/// effect: ``EffectPublisher/run(priority:operation:catch:fileID:line:)``.
 ///
 /// * If using Combine in your application, in particular for the dependencies of your feature
 /// then you can create effects by making use of any of Combine's operators, and then erasing the
@@ -247,10 +247,10 @@ extension EffectPublisher where Failure == Never {
 ///
 /// [callAsFunction]: https://docs.swift.org/swift-book/ReferenceManual/Declarations.html#ID622
 @MainActor
-public struct Send<Action> {
-  public let send: @MainActor (Action) -> Void
+public struct Send<Action>: Sendable {
+  let send: @MainActor @Sendable (Action) -> Void
 
-  public init(send: @escaping @MainActor (Action) -> Void) {
+  public init(send: @escaping @MainActor @Sendable (Action) -> Void) {
     self.send = send
   }
 

Sources/ComposableArchitecture/Effects/Publisher.swift

@@ -46,12 +46,12 @@ extension EffectPublisher: Publisher {
         let task = Task(priority: priority) { @MainActor in
           defer { subscriber.send(completion: .finished) }
           #if DEBUG
-            var isCompleted = false
-            defer { isCompleted = true }
+            let isCompleted = LockIsolated(false)
+            defer { isCompleted.setValue(true) }
           #endif
           let send = Send<Action> {
             #if DEBUG
-              if isCompleted {
+              if isCompleted.value {
                 runtimeWarn(
                   """
                   An action was sent from a completed effect:
@@ -86,7 +86,7 @@ extension EffectPublisher {
   ///
   /// > Important: This Combine interface has been soft-deprecated in favor of Swift concurrency.
   /// > Prefer performing asynchronous work directly in
-  /// > ``EffectPublisher/run(priority:operation:catch:file:fileID:line:)`` by adopting a
+  /// > ``EffectPublisher/run(priority:operation:catch:fileID:line:)`` by adopting a
   /// > non-Combine interface, or by iterating over the publisher's asynchronous sequence of
   /// > `values`:
   /// >

Sources/ComposableArchitecture/Effects/TaskResult.swift

@@ -31,7 +31,7 @@ import XCTestDynamicOverlay
 /// }
 /// ```
 ///
-/// And finally you can use ``EffectPublisher/run(priority:operation:catch:file:fileID:line:)`` to
+/// And finally you can use ``EffectPublisher/run(priority:operation:catch:fileID:line:)`` to
 /// construct an effect in the reducer that invokes the `numberFact` endpoint and wraps its response
 /// in a ``TaskResult`` by using its catching initializer, ``TaskResult/init(catching:)``:
 ///

Sources/ComposableArchitecture/Reducer/Reducers/Scope.swift

@@ -58,7 +58,7 @@
 /// ## Enum state
 ///
 /// The ``Scope`` reducer also works when state is modeled as an enum, not just a struct. In that
-/// case you can use ``init(state:action:child:file:fileID:line:)`` to specify a case path that
+/// case you can use ``init(state:action:child:fileID:line:)`` to specify a case path that
 /// identifies the case of state you want to scope to.
 ///
 /// For example, if your state was modeled as an enum for unloaded/loading/loaded, you could
@@ -94,7 +94,7 @@
 /// bugs, and so we show a runtime warning in that case, and cause test failures.
 ///
 /// For an alternative to using ``Scope`` with state case paths that enforces the order, check out
-/// the ``ifCaseLet(_:action:then:file:fileID:line:)`` operator.
+/// the ``ifCaseLet(_:action:then:fileID:line:)`` operator.
 public struct Scope<ParentState, ParentAction, Child: ReducerProtocol>: ReducerProtocol {
   @usableFromInline
   enum StatePath {
@@ -199,7 +199,7 @@ public struct Scope<ParentState, ParentAction, Child: ReducerProtocol>: ReducerP
   /// > ```
   /// >
   /// > If the parent domain contains additional logic for switching between cases of child state,
-  /// > prefer ``ReducerProtocol/ifCaseLet(_:action:then:file:fileID:line:)``, which better ensures
+  /// > prefer ``ReducerProtocol/ifCaseLet(_:action:then:fileID:line:)``, which better ensures
   /// > that child logic runs _before_ any parent logic can replace child state:
   /// >
   /// > ```swift

Sources/ComposableArchitecture/Store.swift

@@ -414,13 +414,13 @@ public final class Store<State, Action> {
           tasks.wrappedValue.append(
             Task(priority: priority) { @MainActor in
               #if DEBUG
-                var isCompleted = false
-                defer { isCompleted = true }
+                let isCompleted = LockIsolated(false)
+                defer { isCompleted.setValue(true) }
               #endif
               await operation(
                 Send { effectAction in
                   #if DEBUG
-                    if isCompleted {
+                    if isCompleted.value {
                       runtimeWarn(
                         """
                         An action was sent from a completed effect:

Sources/ComposableArchitecture/SwiftUI/ForEachStore.swift

@@ -56,7 +56,7 @@ import SwiftUI
 /// }
 /// ```
 ///
-/// Enhance its core reducer using ``ReducerProtocol/forEach(_:action:element:file:fileID:line:)``:
+/// Enhance its core reducer using ``ReducerProtocol/forEach(_:action:element:fileID:line:)``:
 ///
 /// ```swift
 /// var body: some ReducerProtocol<State, Action> {

Sources/ComposableArchitecture/SwiftUI/SwitchStore.swift

@@ -41,8 +41,8 @@ import SwiftUI
 /// > it changes. As such, you should not rely on this value for anything other than checking the
 /// > current case, _e.g._ by switching on it and routing to an appropriate `CaseLet`.
 ///
-/// See ``ReducerProtocol/ifCaseLet(_:action:then:file:fileID:line:)`` and
-/// ``Scope/init(state:action:child:file:fileID:line:)`` for embedding reducers that operate on each
+/// See ``ReducerProtocol/ifCaseLet(_:action:then:fileID:line:)`` and
+/// ``Scope/init(state:action:child:fileID:line:)`` for embedding reducers that operate on each
 /// case of an enum in reducers that operate on the entire enum.
 public struct SwitchStore<State, Action, Content: View>: View {
   public let store: Store<State, Action>

Sources/ComposableArchitecture/TestStore.swift

@@ -662,11 +662,7 @@ public final class TestStore<State, Action, ScopedState, ScopedAction, Environme
     ScopedState: Equatable,
     Environment == Void
   {
-    var dependencies = DependencyValues._current
-    let reducer = withDependencies {
-      prepareDependencies(&dependencies)
-      $0 = dependencies
-    } operation: {
+    let reducer = withDependencies(prepareDependencies) {
       TestReducer(Reduce(reducer()), initialState: initialState())
     }
     self._environment = .init(wrappedValue: ())
@@ -677,7 +673,6 @@ public final class TestStore<State, Action, ScopedState, ScopedAction, Environme
     self.store = Store(initialState: reducer.state, reducer: reducer)
     self.timeout = 100 * NSEC_PER_MSEC
     self.toScopedState = toScopedState
-    self.dependencies = dependencies
   }
 
   /// Creates a test store with an initial state and a reducer powering its runtime.
@@ -703,11 +698,7 @@ public final class TestStore<State, Action, ScopedState, ScopedAction, Environme
     Action == ScopedAction,
     Environment == Void
   {
-    var dependencies = DependencyValues._current
-    let reducer = withDependencies {
-      prepareDependencies(&dependencies)
-      $0 = dependencies
-    } operation: {
+    let reducer = withDependencies(prepareDependencies) {
       TestReducer(Reduce(reducer()), initialState: initialState())
     }
     self._environment = .init(wrappedValue: ())
@@ -718,7 +709,6 @@ public final class TestStore<State, Action, ScopedState, ScopedAction, Environme
     self.store = Store(initialState: reducer.state, reducer: reducer)
     self.timeout = 100 * NSEC_PER_MSEC
     self.toScopedState = { $0 }
-    self.dependencies = dependencies
   }
 
   @available(
@@ -1177,7 +1167,7 @@ extension TestStore where ScopedState: Equatable {
       var expectedWhenGivenPreviousState = expected
       if let updateStateToExpectedResult = updateStateToExpectedResult {
         try withDependencies {
-          $0 = self.dependencies
+          $0 = self.reducer.dependencies
         } operation: {
           try updateStateToExpectedResult(&expectedWhenGivenPreviousState)
         }
@@ -1194,7 +1184,7 @@ extension TestStore where ScopedState: Equatable {
       var expectedWhenGivenActualState = actual
       if let updateStateToExpectedResult = updateStateToExpectedResult {
         try withDependencies {
-          $0 = self.dependencies
+          $0 = self.reducer.dependencies
         } operation: {
           try updateStateToExpectedResult(&expectedWhenGivenActualState)
         }
@@ -1213,7 +1203,7 @@ extension TestStore where ScopedState: Equatable {
           _XCTExpectFailure(strict: false) {
             do {
               try withDependencies {
-                $0 = self.dependencies
+                $0 = self.reducer.dependencies
               } operation: {
                 try updateStateToExpectedResult(&expectedWhenGivenPreviousState)
               }
@@ -2164,8 +2154,8 @@ extension TestStore {
 /// await store.send(.stopTimerButtonTapped).finish()
 /// ```
 ///
-/// See ``TestStore/finish(timeout:file:line:)`` for the ability to await all in-flight
-/// effects in the test store.
+/// See ``TestStore/finish(timeout:file:line:)`` for the ability to await all in-flight effects in
+/// the test store.
 ///
 /// See ``ViewStoreTask`` for the analog provided to ``ViewStore``.
 public struct TestStoreTask: Hashable, Sendable {
@@ -2274,7 +2264,7 @@ public struct TestStoreTask: Hashable, Sendable {
 
 class TestReducer<State, Action>: ReducerProtocol {
   let base: Reduce<State, Action>
-  var dependencies = DependencyValues()
+  var dependencies: DependencyValues
   let effectDidSubscribe = AsyncStream.makeStream(of: Void.self)
   var inFlightEffects: Set<LongLivingEffect> = []
   var receivedActions: [(action: Action, state: State)] = []
@@ -2284,7 +2274,9 @@ class TestReducer<State, Action>: ReducerProtocol {
     _ base: Reduce<State, Action>,
     initialState: State
   ) {
+    @Dependency(\.self) var dependencies
     self.base = base
+    self.dependencies = dependencies
     self.state = initialState
   }