Crash when using SwitchStore

[yBuild1When2Are2xThePrice]

Description

When I use SwitchStore I'm getting a crash. I'm probably using it wrong but I reproduced it in a small case.

Checklist

• I have determined whether this bug is also reproducible in a vanilla SwiftUI project.
• If possible, I've reproduced the issue using the main branch of this package.
• This issue hasn't been addressed in an existing GitHub issue or discussion.

Expected behavior

I would expect no crash and the different feature views swapped out.

Actual behavior

Getting a crash with

Fatal error: No ObservableObject of type StoreObservableObject<State, Action> found. A View.environmentObject(_:) for StoreObservableObject<State, Action> may be missing as an ancestor of this view.

Steps to reproduce

import ComposableArchitecture
import SwiftUI

struct MyApp: App {
    var body: some Scene {
        WindowGroup {
            FeatureView(
                store: Store(
                    initialState: Feature.State()
                ) {
                    Feature()
                }
            )
        }
    }
}

struct Feature: Reducer {
    struct State: Equatable {
        var color: Color.State?
    }
    
    enum Action: Equatable {
        case buttonTapped
        case color(Color.Action)
    }
    
    struct Color: Reducer {
        enum State: Equatable {
            case red(Red.State)
            case blue(Blue.State)
        }
        
        enum Action: Equatable {
            case red(Red.Action)
            case blue(Blue.Action)
        }
        
        var body: some ReducerOf<Self> {
            Scope(state: /State.red, action: /Action.red) {
                Red()
            }
            Scope(state: /State.blue, action: /Action.blue) {
                Blue()
            }
        }
    }
    
    var body: some ReducerOf<Self> {
        Reduce { state, action in
            switch action {
            case .buttonTapped:
                switch state.color {
                case .none:
                    state.color = .red(.init())
                    return .none
                case .red:
                    state.color = .blue(.init())
                    return .none
                case .blue:
                    state.color = nil
                    return .none
                }
            case .color:
                return .none
            }
        }
        .ifLet(\.color, action: /Action.color) {
            Color()
        }
    }
}

struct FeatureView: View {
    
    let store: StoreOf<Feature>
    
    var body: some View {
        WithViewStore(self.store, observe: { $0} ) { viewStore in
            Button("Tap Me") {
                viewStore.send(.buttonTapped)
            }
            SwitchStore(store.scope(state: \.color, action: { .color($0) })) { state in
                switch state {
                case .red:
                    CaseLet(
                        /Feature.Color.State.red,
                        action: Feature.Color.Action.red
                    ) { store in
                        RedView(store: store)
                    }
                case .blue:
                    CaseLet(
                        /Feature.Color.State.blue,
                        action: Feature.Color.Action.blue
                    ) { store in
                        BlueView(store: store)
                    }
                case .none:
                    Text("No Color")
                }
            }
        }
    }
}

struct Red: Reducer {
    struct State: Equatable { }
    enum Action: Equatable { }
    var body: some ReducerOf<Self> { EmptyReducer() }
}

struct RedView: View {
    
    let store: StoreOf<Red>
    
    var body: some View {
        WithViewStore(self.store, observe: { $0} ) { viewStore in
            Text("RedView")
                .foregroundColor(.red)
        }
    }
}

struct Blue: Reducer {
    struct State: Equatable { }
    enum Action: Equatable { }
    var body: some ReducerOf<Self> { EmptyReducer() }
}

struct BlueView: View {
    
    let store: StoreOf<Blue>
    
    var body: some View {
        WithViewStore(self.store, observe: { $0} ) { viewStore in
            Text("BlueView")
                .foregroundColor(.blue)
        }
    }
}

The Composable Architecture version information

1.2.0

Destination operating system

No response

Xcode version information

No response

Swift Compiler version information

No response

[stephencelis]

The behavior you're seeing is related to Swift's optional promotion and the fact that CaseLet is not in a context that can be influenced by type inference. In this case a Store<State?, Action> is passed to SwitchStore, which makes the exhaustive switch's types line up, but the CaseLet is working with a non-optional case path expression, which makes its body look for an environment object of a store of non-optional state to be hydrated with.

So the fix is to make the types line up. One option is to update the CaseLet with extraction functions that fully account for the optionality:

switch state {
case .some(.red):
  CaseLet(
    (/Feature.Color.State?.some).appending(path: /Feature.Color.State.red).extract,
    action: Feature.Color.Action.red
  ) { store in
    RedView(store: store)
  }
case .some(.blue):
  CaseLet(
    (/Feature.Color.State?.some).appending(path: /Feature.Color.State.blue).extract,
    action: Feature.Color.Action.blue
  ) { store in
    BlueView(store: store)
  }
case .none:
  Text("No Color")
}

Or you can take 2 steps, first using an IfLetStore to unwrap the optional color state, before switching on the non-optional color state that can be switched over directly:

IfLetStore(store.scope(state: \.color, action: { .color($0) })) { colorStore in
  SwitchStore(colorStore) { state in
    switch state {
    case .red:
      CaseLet(
        /Feature.Color.State.red,
        action: Feature.Color.Action.red
      ) { store in
        RedView(store: store)
      }
    case .blue:
      CaseLet(
        /Feature.Color.State.blue,
        action: Feature.Color.Action.blue
      ) { store in
        BlueView(store: store)
      }
    }
  }
}

With the current way Swift works and CaseLet works, we don't think we can work around this quirk, so I'm going to convert this to a discussion. We do plan on retiring SwitchStore in the future, though, which will help avoid this gotcha.

[stephencelis]

@Muhammed9991 Looking at your ParentFeature.body it doesn't seem to integrate with ChildFeature at all. Are you missing a reducer operation to incorporate ChildFeature's logic into the parent?

[Muhammed9991]

Can you show me what I'm missing? I might be having a brain fart

[Muhammed9991]

Ohh I was missing this inside the reducer.:

.ifLet(\.content, action: /Action.content) {
            ChildFeature()
        }

Brain fart it was.

One thread two answers. Nice one @stephencelis 😅

[stephencelis]

@Muhammed9991 Brandon and I are going to look into designing a Reducer.trace() operator of sorts to help figure out what reducers in your tree process an action. It should make it easier to track down problems like this.

[Muhammed9991]

That would be great. I've come across this issue before where all I've done is forgotten to add the ifLet. So anything that can help us better avoid such bugs would be great.