Only dismiss alert/dialog state when receiving a domain-specific action (pointfreeco#2468)

Author: stephencelis

Sources/ComposableArchitecture/Internal/EphemeralState.swift

@@ -4,21 +4,39 @@
 /// with they go away. Such features do not manage any behavior on the inside.
 ///
 /// Alerts and confirmation dialogs are examples of this kind of state.
-public protocol _EphemeralState {}
+public protocol _EphemeralState {
+  static var actionType: Any.Type { get }
+}
 
-extension AlertState: _EphemeralState {}
+extension AlertState: _EphemeralState {
+  public static var actionType: Any.Type { Action.self }
+}
 
 @available(iOS 13, macOS 12, tvOS 13, watchOS 6, *)
-extension ConfirmationDialogState: _EphemeralState {}
+extension ConfirmationDialogState: _EphemeralState {
+  public static var actionType: Any.Type { Action.self }
+}
+
+@usableFromInline
+func ephemeralType<State>(of state: State) -> (any _EphemeralState.Type)? {
+  (State.self as? any _EphemeralState.Type)
+    ?? EnumMetadata(type(of: state)).flatMap { metadata in
+      metadata.associatedValueType(forTag: metadata.tag(of: state))
+        as? any _EphemeralState.Type
+    }
+}
 
 @usableFromInline
 func isEphemeral<State>(_ state: State) -> Bool {
-  if State.self is _EphemeralState.Type {
-    return true
-  } else if let metadata = EnumMetadata(type(of: state)) {
-    return metadata.associatedValueType(forTag: metadata.tag(of: state))
-      is _EphemeralState.Type
-  } else {
-    return false
+  ephemeralType(of: state) != nil
+}
+
+extension _EphemeralState {
+  @usableFromInline
+  static func canSend<Action>(_ action: Action) -> Bool {
+    return Action.self == Self.actionType
+      || EnumMetadata(Action.self).flatMap { metadata in
+        metadata.associatedValueType(forTag: metadata.tag(of: action)) == Self.actionType
+      } == true
   }
 }

Sources/ComposableArchitecture/Reducer/Reducers/PresentationReducer.swift

@@ -353,9 +353,10 @@ public struct _PresentationReducer<Base: Reducer, Destination: Reducer>: Reducer
         .map { self.toPresentationAction.embed(.presented($0)) }
         ._cancellable(navigationIDPath: destinationNavigationIDPath)
       baseEffects = self.base.reduce(into: &state, action: action)
-      if isEphemeral(destinationState),
+      if let ephemeralType = ephemeralType(of: destinationState),
         destinationNavigationIDPath
-          == state[keyPath: self.toPresentationState].wrappedValue.map(self.navigationIDPath(for:))
+          == state[keyPath: self.toPresentationState].wrappedValue.map(self.navigationIDPath(for:)),
+        ephemeralType.canSend(destinationAction)
       {
         state[keyPath: self.toPresentationState].wrappedValue = nil
       }

Tests/ComposableArchitectureTests/Reducers/PresentationReducerTests.swift

@@ -2427,4 +2427,118 @@ final class PresentationReducerTests: BaseTCATestCase {
     // NB: Another action needs to come into the `ifLet` to cancel the child action
     await store.send(.tapAfter)
   }
+
+  func testPresentation_leaveAlertPresentedForNonAlertActions() async {
+    if #available(iOS 16, macOS 13, tvOS 16, watchOS 9, *) {
+      struct Child: Reducer {
+        struct State: Equatable {
+          var count = 0
+        }
+        enum Action: Equatable {
+          case decrementButtonTapped
+          case incrementButtonTapped
+        }
+        func reduce(into state: inout State, action: Action) -> Effect<Action> {
+          switch action {
+          case .decrementButtonTapped:
+            state.count -= 1
+            return .none
+          case .incrementButtonTapped:
+            state.count += 1
+            return .none
+          }
+        }
+      }
+
+      struct Parent: Reducer {
+        struct State: Equatable {
+          @PresentationState var destination: Destination.State?
+          var isDeleted = false
+        }
+        enum Action: Equatable {
+          case destination(PresentationAction<Destination.Action>)
+          case presentAlert
+          case presentChild
+        }
+
+        var body: some ReducerOf<Self> {
+          Reduce { state, action in
+            switch action {
+            case .destination(.presented(.alert(.deleteButtonTapped))):
+              state.isDeleted = true
+              return .none
+            case .destination:
+              return .none
+            case .presentAlert:
+              state.destination = .alert(
+                AlertState {
+                  TextState("Uh oh!")
+                } actions: {
+                  ButtonState(role: .destructive, action: .deleteButtonTapped) {
+                    TextState("Delete")
+                  }
+                }
+              )
+              return .none
+            case .presentChild:
+              state.destination = .child(Child.State())
+              return .none
+            }
+          }
+          .ifLet(\.$destination, action: /Action.destination) {
+            Destination()
+          }
+        }
+        struct Destination: Reducer {
+          enum State: Equatable {
+            case alert(AlertState<Action.Alert>)
+            case child(Child.State)
+          }
+          enum Action: Equatable {
+            case alert(Alert)
+            case child(Child.Action)
+
+            enum Alert: Equatable {
+              case deleteButtonTapped
+            }
+          }
+          var body: some ReducerOf<Self> {
+            Scope(state: /State.alert, action: /Action.alert) {}
+            Scope(state: /State.child, action: /Action.child) {
+              Child()
+            }
+          }
+        }
+      }
+      let line = #line - 6
+
+      let store = TestStore(initialState: Parent.State()) {
+        Parent()
+      }
+
+      await store.send(.presentAlert) {
+        $0.destination = .alert(
+          AlertState {
+            TextState("Uh oh!")
+          } actions: {
+            ButtonState(role: .destructive, action: .deleteButtonTapped) {
+              TextState("Delete")
+            }
+          }
+        )
+      }
+
+      #if DEBUG
+        XCTExpectFailure {
+          $0.compactDescription.hasPrefix(
+            """
+            A "Scope" at "\(#fileID):\(line)" received a child action when child state was set to a \
+            different case. …
+            """
+          )
+        }
+      #endif
+      await store.send(.destination(.presented(.child(.decrementButtonTapped))))
+    }
+  }
 }