Getting Runtime warning on setting optional state nil only if the view is wrapped inside navigation

[kakhaberikiknadze]

Hi guys! So, recently I've noticed this kind of runtime warning

Warning log

2023-02-11 14:26:52.386376+0400 AVRecorder[68312:16891785] [ComposableArchitecture] An "ifLet" at "AVRecorder/AppCoordinatorReducer.swift:78" received a child action when child state was "nil". …

Action:
FeatureA.Action.featureB(.updateText)

This is generally considered an application logic error, and can happen for a few reasons:

• A parent reducer set child state to "nil" before this reducer ran. This reducer must run before any other reducer sets child state to "nil". This ensures that child reducers can handle their actions while their state is still available.

• An in-flight effect emitted this action when child state was "nil". While it may be perfectly reasonable to ignore this action, consider canceling the associated effect before child state becomes "nil", especially if it is a long-living effect.

• This action was sent to the store while state was "nil". Make sure that actions for this reducer can only be sent from a view store when state is non-"nil". In SwiftUI applications, use "IfLetStore".
2023-02-11 14:26:52.392599+0400 AVRecorder[68312:16891785] [ComposableArchitecture] An "ifLet" at "AVRecorder/AppCoordinatorReducer.swift:78" received a child action when child state was "nil". …

Action:
FeatureA.Action.featureB(.updateText)

This is generally considered an application logic error, and can happen for a few reasons:

• A parent reducer set child state to "nil" before this reducer ran. This reducer must run before any other reducer sets child state to "nil". This ensures that child reducers can handle their actions while their state is still available.

• An in-flight effect emitted this action when child state was "nil". While it may be perfectly reasonable to ignore this action, consider canceling the associated effect before child state becomes "nil", especially if it is a long-living effect.

• This action was sent to the store while state was "nil". Make sure that actions for this reducer can only be sent from a view store when state is non-"nil". In SwiftUI applications, use "IfLetStore".

When does it happen?

It happens only if the FeatureB is wrapped inside NavigationStack (Same issue on NavigationView).

What I want to achieve

I want to show either login screen or the root view. After user logs in, login screen should be removed completely and the root view should be shown.

How I try to do it

• I'm using an app reducer with two optional states. One for sign in and the other for root.
• When the sign in is completed, app reducer sets the sign in state to nil and creates the root state.

How to reproduce

Let's say FeatureA is our app reducer, FeatureB is sign in and FeatureC is the root.

struct FeatureA: ReducerProtocol {
    struct State: Equatable {
        var featureB: FeatureB.State?
        var featureC: FeatureC.State?
    }
    
    enum Action {
        case featureB(FeatureB.Action)
        case featureC(FeatureC.Action)
        case requestInitialScreen
    }
    
    var body: some ReducerProtocol<State, Action> {
        Reduce { state, action in
            switch action {
            case .requestInitialScreen:
                state.featureB = .init(text: "", isButtonDisabled: true)
                return .none
            case let .featureB(.taskCompleted(result)):
                print("Feature B completed with result:", result)
                state.featureB = nil
                state.featureC = .init()
                return .none
            default:
                return .none
            }
        }
        .ifLet(\.featureB, action: /Action.featureB) {
            FeatureB()
        }
        .ifLet(\.featureC, action: /Action.featureC) {
            FeatureC()
        }
    }
}

struct FeatureB: ReducerProtocol {
    struct State: Equatable {
        var text: String
        var isButtonDisabled: Bool
        var isLoading: Bool = false
    }
    
    enum Action {
        case performTask
        case taskCompleted(String)
        case updateText(String)
    }
    
    var body: some ReducerProtocol<State, Action> {
        Reduce { state, action in
            switch action {
            case .performTask:
                state.isLoading = true
                return .task { [result = state.text] in
                    try await Task.sleep(for: .seconds(3))
                    return .taskCompleted(result)
                }
            case let .updateText(text):
                state.text = text
                state.isButtonDisabled = text.isEmpty
                return .none
            case .taskCompleted:
                state.isLoading = false
                return .none
            }
        }
    }
}

struct FeatureC: ReducerProtocol {
    struct State: Equatable {
        // ...
    }
    
    enum Action {
        // ...
    }
    
    var body: some ReducerProtocol<State, Action> {
        Reduce { state, action in
            return .none
        }
    }
}

struct FeatureAView: View {
    private typealias Action = FeatureA.Action
    let store: StoreOf<FeatureA>
    
    var body: some View {
        WithViewStore(store, observe: { $0 }) { viewStore in
            IfLetStore(
                store.scope(state: \.featureB, action: Action.featureB),
                then: FeatureBView.init,
                else: {
                    IfLetStore(
                        store.scope(state: \.featureC, action: Action.featureC),
                        then: FeatureCView.init
                    )
                }
            )
            .task {
                viewStore.send(.requestInitialScreen)
            }
        }
    }
}

struct FeatureBView: View {
    private typealias Action = FeatureB.Action
    let store: StoreOf<FeatureB>
    
    var body: some View {
        WithViewStore(store, observe: { $0 }) { viewStore in
            NavigationStack { // If you comment out NavigationStack issue doesn't exist
                VStack {
                    TextField(
                        "",
                        text: viewStore.binding(
                            get: \.text,
                            send: Action.updateText
                        )
                    )
                    .textFieldStyle(RoundedBorderTextFieldStyle())
                    
                    Button("title from view state") {
                        viewStore.send(.performTask)
                    }
                    .disabled(viewStore.isButtonDisabled)
                }
            }
        }
    }
}

struct FeatureCView: View {
    let store: StoreOf<FeatureC>
    
    var body: some View {
        Text("Feature C")
    }
}

As I see textfield binding gets called after the optional state in FeatureA becomes nil.

Notes

• Same issue consists if I use viewStore.binding(\.$text) instead.
• Issue doesn't exist if you don't type anything in the textfield (need to comment out button disabling for that)
  • Even if you set some value beforehand for the textfield. So it happens only if you update the textfield.

I believe I'm missing something simple or maybe even doing something stupid so I'd better ask for your help 😃

[tgrapperon]

Hey @kakhaberikiknadze! TextField is indeed a very vocal view that frequently over-emits on its binding. For example, it sets the the value when it loses focus, and this is very likely what you're observing when FeatureB is dismissed: FeatureB.State is nil'd, the view goes away, and if the TextField had focus, it emits on the binding when losing it, which triggers the warning because FeatureB.State is nil. There are experiments to disable this warning when the action is a BindingAction, but it would only work when using the BindingReducer. It is also possible that this warning can also be bypassed if the upcoming navigation utilities are used.

I didn't run your code, so I can't explain yet why it doesn't trigger the warning when you remove the NavigationStack. I'll try to give it a spin later. Otherwise, nothing stands-out in your code, besides the fact that you don't need a WithViewStore in FeatureAView (you can create the one you need in .task directly:

.task {
  ViewStore(store.stateless).send(.requestInitialScreen)
}

You can probably safely ignore this warning for now.

[kakhaberikiknadze]

For the record, I've done it on 0.49 version. I haven't tried on 0.50 yet.

[kakhaberikiknadze]

Ok, I've tried the same code in the new project and didn't get the errors. Then I copied the same code into my other project that uses 0.49.2 version and the error appeared there. I think it's fixed in 0.50. Will update my other project to the new version as well and let you know if it's fixed there as well.

[kakhaberikiknadze]

Yeah, it's definitely fixed in version 0.50.2 👍🏻

[tgrapperon]

Indeed, this was fixed in #1879 (v0.50.1). I forgot that it was effectively merged and released. Sorry about that.

[kakhaberikiknadze]

No worries 🙌🏻 Great to see it's fixed and honestly, great to see how maintained all those packages are 🚀

[miaoruiyuan]

Hello, I've encountered the same situation and I'm not sure how to resolve it.

[miaoruiyuan]

    if let homeStore = appStore.scope(state: \.home, action: \.home) {
        window?.rootViewController = UIHostingController(rootView: HomeView(store: homeStore))
    }
}`

[miaoruiyuan]

public static var body: some ReducerOf {

Reduce { state, action in
    switch action {
    case let .welcome(welcome):
        switch welcome {
        case let .destination(.presented(destination)):
            switch destination {
            case .login(.oneTimeCode(.presented(.loginResponse(.success)))):
                state = .home(Home.State())
                return .none
            case .accountAuth(.loginResponse(.success)):
                state = .home(Home.State())
                return .none
            default:
                return .none
            }
        default:
            return .none
        }

    case .home(.alert(.presented(.reLogin))):
        state = .welcome(Welcome.State())
        return .none
        
    case .home(.setting(.presented(.logoutResponse(.success)))):
        state = .welcome(Welcome.State())
        return .none
        
    case .home:
        return .none
    }
}
.ifLet(\.home, action: \.home) {
    Home()
}
.ifLet(\.welcome, action: \.welcome) {
    Welcome()
}

}

[miaoruiyuan]

An "ifLet" at "EvaluationPro_Dev/AppCore.swift:50" received a child action when child state was "nil". …

Action:
EvaluationPro.Action.home(
.alert(.dismiss)
)