Workaround for BindingAction existential layout crash (#1881)

* Add test case for binding action crash

* Workaround layout issue

* flakey test

* wip

(cherry picked from commit c3304961646bd6b6fd71e311d48950b1d63bd930)

# Conflicts:
#	Tests/ComposableArchitectureTests/BindingTests.swift

Author: stephencelis

Sources/ComposableArchitecture/SwiftUI/Binding.swift

@@ -171,9 +171,32 @@ public struct BindingAction<Root>: Equatable {
 
   @usableFromInline
   let set: (inout Root) -> Void
-  let value: Any
+  // NB: swift(<5.8) has an enum existential layout bug that can cause crashes when extracting
+  //     payloads. We can box the existential to work around the bug.
+  #if swift(<5.8)
+    private let _value: [Any]
+    var value: Any { self._value[0] }
+  #else
+    let value: Any
+  #endif
   let valueIsEqualTo: (Any) -> Bool
 
+  init(
+    keyPath: PartialKeyPath<Root>,
+    set: @escaping (inout Root) -> Void,
+    value: Any,
+    valueIsEqualTo: @escaping (Any) -> Bool
+  ) {
+    self.keyPath = keyPath
+    self.set = set
+    #if swift(<5.8)
+      self._value = [value]
+    #else
+      self.value = value
+    #endif
+    self.valueIsEqualTo = valueIsEqualTo
+  }
+
   public static func == (lhs: Self, rhs: Self) -> Bool {
     lhs.keyPath == rhs.keyPath && lhs.valueIsEqualTo(rhs.value)
   }

Tests/ComposableArchitectureTests/BindingTests.swift

@@ -1,46 +1,59 @@
 #if canImport(SwiftUI)
-  import ComposableArchitecture
-  import XCTest
-
-  @MainActor
-  final class BindingTests: XCTestCase {
-    #if swift(>=5.7)
-      func testNestedBindingState() {
-        struct BindingTest: ReducerProtocol {
-          struct State: Equatable {
-            @BindingState var nested = Nested()
-
-            struct Nested: Equatable {
-              var field = ""
-            }
+import ComposableArchitecture
+import XCTest
+
+@MainActor
+final class BindingTests: XCTestCase {
+  #if swift(>=5.7)
+    func testNestedBindingState() {
+      struct BindingTest: ReducerProtocol {
+        struct State: Equatable {
+          @BindingState var nested = Nested()
+
+          struct Nested: Equatable {
+            var field = ""
           }
+        }
 
-          enum Action: BindableAction, Equatable {
-            case binding(BindingAction<State>)
-          }
+        enum Action: BindableAction, Equatable {
+          case binding(BindingAction<State>)
+        }
 
-          var body: some ReducerProtocol<State, Action> {
-            BindingReducer()
-            Reduce { state, action in
-              switch action {
-              case .binding(\.$nested.field):
-                state.nested.field += "!"
-                return .none
-              default:
-                return .none
-              }
+        var body: some ReducerProtocol<State, Action> {
+          BindingReducer()
+          Reduce { state, action in
+            switch action {
+            case .binding(\.$nested.field):
+              state.nested.field += "!"
+              return .none
+            default:
+              return .none
             }
           }
         }
+      }
 
-        let store = Store(initialState: BindingTest.State(), reducer: BindingTest())
+      let store = Store(initialState: BindingTest.State(), reducer: BindingTest())
 
-        let viewStore = ViewStore(store, observe: { $0 })
+      let viewStore = ViewStore(store, observe: { $0 })
 
-        viewStore.binding(\.$nested.field).wrappedValue = "Hello"
+      viewStore.binding(\.$nested.field).wrappedValue = "Hello"
 
-        XCTAssertEqual(viewStore.state, .init(nested: .init(field: "Hello!")))
-      }
-    #endif
+      XCTAssertEqual(viewStore.state, .init(nested: .init(field: "Hello!")))
+    }
+  #endif
+
+  // NB: This crashes in Swift(<5.8) RELEASE when `BindingAction` holds directly onto an unboxed
+  //     `value: Any` existential
+  func testLayoutBug() {
+    enum Foo {
+      case bar(Baz)
+}
+    enum Baz {
+      case fizz(BindingAction<Void>)
+      case buzz(Bool)
+    }
+    _ = (/Foo.bar).extract(from: .bar(.buzz(true)))
   }
+}
 #endif

Tests/ComposableArchitectureTests/TestStoreNonExhaustiveTests.swift

@@ -460,38 +460,40 @@
     // Confirms that when you send an action the test store skips any unreceived actions
     // automatically.
     func testSendWithUnreceivedActions_SkipsActions() async {
-      struct Feature: ReducerProtocol {
-        enum Action: Equatable {
-          case tap
-          case response(Int)
-        }
-        func reduce(into state: inout Int, action: Action) -> EffectTask<Action> {
-          switch action {
-          case .tap:
-            state += 1
-            return .task { [state] in .response(state + 42) }
-          case let .response(number):
-            state = number
-            return .none
+      await _withMainSerialExecutor {
+        struct Feature: ReducerProtocol {
+          enum Action: Equatable {
+            case tap
+            case response(Int)
+          }
+          func reduce(into state: inout Int, action: Action) -> EffectTask<Action> {
+            switch action {
+            case .tap:
+              state += 1
+              return .task { [state] in .response(state + 42) }
+            case let .response(number):
+              state = number
+              return .none
+            }
           }
         }
-      }
 
-      let store = TestStore(
-        initialState: 0,
-        reducer: Feature()
-      )
-      store.exhaustivity = .off
+        let store = TestStore(
+          initialState: 0,
+          reducer: Feature()
+        )
+        store.exhaustivity = .off
 
-      await store.send(.tap)
-      XCTAssertEqual(store.state, 1)
+        await store.send(.tap)
+        XCTAssertEqual(store.state, 1)
 
-      // Ignored received action: .response(43)
-      await store.send(.tap)
-      XCTAssertEqual(store.state, 44)
+        // Ignored received action: .response(43)
+        await store.send(.tap)
+        XCTAssertEqual(store.state, 44)
 
-      await store.skipReceivedActions()
-      XCTAssertEqual(store.state, 86)
+        await store.skipReceivedActions()
+        XCTAssertEqual(store.state, 86)
+      }
     }
 
     func testPartialExhaustivityPrefix() async {