Workaround for BindingAction existential layout crash

Sources/ComposableArchitecture/SwiftUI/Binding.swift

@@ -166,9 +166,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

@@ -41,4 +41,17 @@ final class BindingTests: XCTestCase {
       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)))
+  }
 }

Tests/ComposableArchitectureTests/TestStoreNonExhaustiveTests.swift

@@ -458,38 +458,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 {