[RESOLVED] ReducerProtocol: Missing ViewStore updates in Release in Xcode 14

[PorterHoskins]

Loving the beta. It really is great. I put up a TestFlight build to try it out and my entire app was broken. After looking into it more, it seems like there are ViewStore updates that are not getting fired on this branch when the app is built in release mode in Xcode 14.

It doesn't seem to be an issue directly with ReducerProtocol and happens with both reducer paradigms. I tried turning off Whole Module Optimization and Speed Optimization build settings. I tried converting everything to the new concurrency model. I got rid of all the deprecated build warnings. Everything is straight TCA with no custom extensions.

0.40.1 works fine from Xcode 14 in release mode. The beta works fine in debug and in release on Xcode 13. I tried to reproduce the issue in a small sample project but I can't get it to reproduce. Are you seeing any issues like this with Isowords by chance?

[jaanussiim]

This reminds me. While trying to create a sample project for another issue got to this issue where actions disappear in release build.

You should be able to copy it into view controller of default new app project. And adding protocol-beta + xctest-dynamic-overlay to Packages.

import ComposableArchitecture
import Foundation
import SwiftUI
import UIKit
import XCTestDynamicOverlay


internal class ViewController: UIViewController {
    private lazy var client = TimeEntriesClient(
        onLoadEntries: {
            _ in
                
            try await DispatchQueue.main.sleep(for: .milliseconds(500))
            
            return [
                Entry(id: Int64.random(in: 0...Int64.max)),
                Entry(id: Int64.random(in: 0...Int64.max)),
                Entry(id: Int64.random(in: 0...Int64.max)),
                Entry(id: Int64.random(in: 0...Int64.max)),
                Entry(id: Int64.random(in: 0...Int64.max)),
                Entry(id: Int64.random(in: 0...Int64.max))
            ]
        }
    )
    
    private lazy var store = Store(
        initialState: Application.State(),
        reducer: Application()
            .dependency(\.timeEntriesClient, client)
    )
    private lazy var appView = ApplicationView(store: store)
    private lazy var hosting = UIHostingController(rootView: appView)
    
    override func viewDidLoad() {
        super.viewDidLoad()

        addChild(hosting)
        view.addSubview(hosting.view)
        hosting.view.translatesAutoresizingMaskIntoConstraints = false
        hosting.view.leadingAnchor.constraint(equalTo: view.leadingAnchor).isActive = true
        hosting.view.topAnchor.constraint(equalTo: view.topAnchor).isActive = true
        hosting.view.trailingAnchor.constraint(equalTo: view.trailingAnchor).isActive = true
        hosting.view.bottomAnchor.constraint(equalTo: view.bottomAnchor).isActive = true
    }
}

public struct TimeEntriesClient {
    internal let onLoadEntries: ((Date) async throws -> [Entry])
}

extension TimeEntriesClient {
    public static let unimplemented = TimeEntriesClient(
        onLoadEntries: XCTUnimplemented("\(Self.self).onLoadEntries")
    )
}

private enum TimeEntriesClientKey: DependencyKey {
    static var liveValue = TimeEntriesClient.unimplemented
    static let previewValue = TimeEntriesClient.unimplemented
    static let testValue = TimeEntriesClient.unimplemented
}

extension DependencyValues {
    public var timeEntriesClient: TimeEntriesClient {
        get { self[TimeEntriesClientKey.self] }
        set { self[TimeEntriesClientKey.self] = newValue }
    }
}


public struct Application: ReducerProtocol {
    public struct State: Equatable {
        internal var timeEntriesState = TimeEntries.State()
    }
    
    public enum Action {
        case timeEntries(TimeEntries.Action)
    }
    
    public var body: some ReducerProtocol<State, Action> {
        Reduce {
            state, action in
        
            switch action {
            case .timeEntries:
                return .none
            }
        }
        Scope(state: \.timeEntriesState, action: /Action.timeEntries) {
            TimeEntries()
        }
    }
}

public struct Entry: Equatable {
    let id: Int64
}

public struct TimeEntry: ReducerProtocol {
    public struct State: Equatable, Identifiable {
        public var id: Int64 {
            entry.id
        }
        
        let entry: Entry
    }
    
    public enum Action {
        case tapped
    }
    
    public var body: some ReducerProtocol<State, Action> {
        Reduce {
            state, action in
            
            switch action {
            case .tapped:
                return .none
            }
        }
    }
}

public struct TimeEntries: ReducerProtocol {
    public struct State: Equatable {
        internal var entries = IdentifiedArrayOf<TimeEntry.State>()
        @BindableState var activeDate = Date.now
        @BindableState var overlayDate = Date.now
        internal var calendarShown = false
    }
    
    public enum Action: BindableAction {
        case loadEntries
        case loaded(TaskResult<[Entry]>)
        case toggleCalendar
        
        
        case binding(BindingAction<TimeEntries.State>)
        case timeEntry(id: TimeEntry.State.ID, action: TimeEntry.Action)
    }
    
    @Dependency(\.timeEntriesClient) var timeEntriesClient
    
    public var body: some ReducerProtocol<State, Action> {
        BindingReducer()
        Reduce {
            state, action in
            
            switch action {
            case .binding(\.$activeDate):
                return Effect(value: .loadEntries)
                
            case .loadEntries:
                return Effect.task {
                    [date = state.activeDate] in
                    
                    await .loaded(
                        TaskResult {
                            try await timeEntriesClient.onLoadEntries(date)
                        }
                    )
                }
                
            case .loaded(.failure):
                return .none
                
            case .loaded(.success(let entries)):
                dump(entries)
                state.entries = IdentifiedArrayOf(uniqueElements: entries.map(TimeEntry.State.init(entry:)))
                return .none
                
            case .toggleCalendar:
                state.calendarShown.toggle()
                return .none
                
            case .binding:
                return .none
                
            case .timeEntry:
                return .none
            }
        }
        .forEach(\.entries, action: /Action.timeEntry(id:action:)) {
            TimeEntry()
        }
        .debug()
    }
}

public struct TimeEntriesView: View {
    internal let store: StoreOf<TimeEntries>
    
    public var body: some View {
        WithViewStore(store) {
            viewStore in
            
            NavigationView {
                ZStack {
                    VStack {
                        DatePicker(
                            "Entries on:",
                            selection: viewStore.binding(\.$activeDate), displayedComponents: .date
                        )
                        .padding(.horizontal)
                        List {
                            ForEachStore(store.scope(state: \.entries, action: TimeEntries.Action.timeEntry(id:action:))) {
                                entryStore in
                                
                                WithViewStore(entryStore) {
                                    entryViewStore in
                                    
                                    Text(String(describing: entryViewStore.id))
                                }
                            }
                        }
                        .listStyle(PlainListStyle())
                    }
                    
                    if viewStore.calendarShown {
                        Color.white.opacity(1)
                        VStack {
                            DatePicker(
                                "Entries on:",
                                selection: viewStore.binding(\.$overlayDate), displayedComponents: .date
                            )
                            .datePickerStyle(.graphical)
                            .padding(.horizontal)
                            Spacer()
                        }
                    }
                    
                }
                .toolbar {
                    ToolbarItem {
                        Button(action: { viewStore.send(.toggleCalendar) }) {
                            Image(systemName: "calendar")
                        }
                    }
                }
            }
            .navigationViewStyle(StackNavigationViewStyle())
            .onAppear {
                viewStore.send(.loadEntries)
            }

        }
    }
}

public struct ApplicationView: View {
    internal let store: StoreOf<Application>
    
    public var body: some View {
        WithViewStore(store) {
            viewStore in
            
            TabView {
                TimeEntriesView(store: store.scope(state: \.timeEntriesState, action: Application.Action.timeEntries))
                    .tabItem {
                        Label("Time entries", systemImage: "rectangle.stack")
                    }
            }
        }
    }
}

[mbrandonw]

Thanks @PorterHoskins for bringing this up and thanks @jaanussiim for giving us a small repro! We can see this behavior when running locally, but we haven't figured out what exactly is going on yet. We're both busy for the next few days with some travel, but we will look into it soon!

In the meantime, if you have time @jaanussiim, would you mind providing us with a port of your code sample that runs on main? That will give us something to hop back and forth between to see what is breaking down. If you don't have time it's OK, we can do it ourselves later.

[jaanussiim]

@mbrandonw - by "runs on main" you mean @main struct SwiftUICheckApp: App? :)

import ComposableArchitecture
import SwiftUI
import XCTestDynamicOverlay

@main struct SwiftUICheckApp: App {
    private let appStore = Store(initialState: Application.State(), reducer: Application())
    private let entriesStore = Store(initialState: TimeEntries.State(), reducer: TimeEntries())
    
    var body: some Scene {
        WindowGroup {
            TabView {
                TimeEntriesView(
                    store: appStore.scope(state: \.timeEntriesState, action: Application.Action.timeEntries)
                )
                .tabItem {
                    Label("Scoped", systemImage: "star.fill")
                }
                TimeEntriesView(
                    store: entriesStore
                )
                .tabItem {
                    Label("Direct", systemImage: "wand.and.stars")
                }
            }
        }
    }
}

public struct Application: ReducerProtocol {
    public struct State: Equatable {
        internal var timeEntriesState = TimeEntries.State()
    }
    
    public enum Action {
        case timeEntries(TimeEntries.Action)
    }
    
    public var body: some ReducerProtocol<State, Action> {
        Reduce {
            state, action in
        
            switch action {
            case .timeEntries:
                return .none
            }
        }
        Scope(state: \.timeEntriesState, action: /Action.timeEntries) {
            TimeEntries()
        }
    }
}

public struct Entry: Equatable {
    let id: Int64
}

public struct TimeEntries: ReducerProtocol {
    public struct State: Equatable {
        @BindableState var activeDate = Date.now
    }
    
    public enum Action: BindableAction {
        case loadEntries
        
        // ######### comment out
        case loaded(TaskResult<[Entry]>)
        // #########
        
        case binding(BindingAction<TimeEntries.State>)
    }
    
    public var body: some ReducerProtocol<State, Action> {
        BindingReducer()
        Reduce {
            state, action in
            
            switch action {
            case .binding(\.$activeDate):
                return Effect(value: .loadEntries)
                
            case .loadEntries:
                return .none

            // ######### comment out
            case .loaded(let result):
                return .none
            // #########
                                
            case .binding:
                return .none
            }
        }
        .debug()
    }
}

public struct TimeEntriesView: View {
    internal let store: StoreOf<TimeEntries>
    
    public var body: some View {
        WithViewStore(store) {
            viewStore in
            
            NavigationView {
                ZStack {
                    VStack {
                        DatePicker(
                            "Entries on:",
                            selection: viewStore.binding(\.$activeDate), displayedComponents: .date
                        )
                        .padding(.horizontal)
                        Spacer()
                        Text(viewStore.activeDate, style: .date)
                    }
                }
            }

        }
    }
}

I believe I got the sample down to bare minimum. Only one binding action. First tab uses scoped store and actions do not work in release mode. In second tab, using direct store, actions work.

If you comment out TimeEntries.Action.loaded(TaskResult<[Entry]>) then the binding action also fires on the first tab

[PorterHoskins]

I think they mean could you provide the same sample code but using the old reducer paradigm. Like no ReducerProtocol.

[jaanussiim]

Anyway - here is a version without ReducerProtocol. Has the same behaviour in main branch. No actions in release mode

import ComposableArchitecture
import SwiftUI

@main
struct MainBranchCheckApp: App {
    private let appStore = Store(
        initialState: Application.State(),
        reducer: Application.reducer,
        environment: ()
    )
    private let entriesStore = Store(
        initialState: TimeEntries.State(),
        reducer: TimeEntries.reducer,
        environment: ()
    )
    
    var body: some Scene {
        WindowGroup {
            TabView {
                TimeEntriesView(
                    store: appStore.scope(state: \.timeEntriesState, action: Application.Action.timeEntries)
                )
                .tabItem {
                    Label("Scoped", systemImage: "star.fill")
                }
                TimeEntriesView(
                    store: entriesStore
                )
                .tabItem {
                    Label("Direct", systemImage: "wand.and.stars")
                }
            }
        }
    }
}

public struct Application {
    public struct State: Equatable {
        internal var timeEntriesState = TimeEntries.State()
    }
    
    public enum Action {
        case timeEntries(TimeEntries.Action)
    }
    
    public static let reducer = Reducer<Application.State, Application.Action, Void>.combine(
        TimeEntries.reducer
            .pullback(
                state: \.timeEntriesState,
                action: /Action.timeEntries,
                environment: { $0 }
            ),
        core
    )
    
    
    private static let core = Reducer<Application.State, Application.Action, Void> {
        state, action, env in
        
        switch action {
        case .timeEntries:
            return .none
        }
    }
}

public struct Entry: Equatable {
    let id: Int64
}

public struct TimeEntries {
    public struct State: Equatable {
        @BindableState var activeDate = Date.now
    }
    
    public enum Action: BindableAction {
        case loadEntries
        
        // ######### comment out
        case loaded(TaskResult<[Entry]>)
        // #########
        
        case binding(BindingAction<TimeEntries.State>)
    }
    
    public static let reducer = Reducer<TimeEntries.State, TimeEntries.Action, Void> {
        state, action, env in
        
        switch action {
        case .binding(\.$activeDate):
            return Effect(value: .loadEntries)
            
        case .loadEntries:
            return .none

        // ######### comment out
        case .loaded(let result):
            return .none
        // #########
                            
        case .binding:
            return .none
        }
    }
    .binding()
}

public struct TimeEntriesView: View {
    internal let store: Store<TimeEntries.State, TimeEntries.Action>
    
    public var body: some View {
        WithViewStore(store) {
            viewStore in
            
            NavigationView {
                ZStack {
                    VStack {
                        DatePicker(
                            "Entries on:",
                            selection: viewStore.binding(\.$activeDate), displayedComponents: .date
                        )
                        .padding(.horizontal)
                        Spacer()
                        Text(viewStore.activeDate, style: .date)
                    }
                }
            }

        }
    }
}

[tgrapperon]

This is weird because ViewStore is mostly unchanged between the two branches, and WithViewStore the same. The main difference I can think about is the ScopedReducer that is maybe not forwarding to the publisher correctly in Release.
Would you mind trying this branch where I force the store to use the same approach as main? You can simply replace pointfreeco by tgrapperon and protocol-beta by protocol-beta-check. This would likely allow to narrow the problem by a lot if it works.

[PorterHoskins]

That does indeed fix the issue

[erikolsson]

Just chiming in that after debugging some strange behavior that appeared in iOS16, I finally found that I had wrapped NavigationView in WithViewStore, (similar to your code above).

My issue was fixed by changing:

WithViewStore(store) { viewStore in
      NavigationView {
          /* MyView */
      }
}

Into:

NavigationView {
      WithViewStore(store) { viewStore in
          /* MyView */
      }
}

[mbrandonw]

@erikolsson Be sure to read our performance article where we explain why it is generally not a good idea to observe all of the state in your store, especially at the root level of the application.

[erikolsson]

@erikolsson Be sure to read our performance article where we explain why it is generally not a good idea to observe all of the state in your store, especially at the root level of the application.

That code was just illustrative, I was observing only the necessary properties. Let me see if I can put together a test case. I had a problem where a .sheet -> navigation view -> alert would crash without a clear stack trace when dismissing.

More than anything, this felt like a bug in SwiftUI.

[tgrapperon]

Does making the root app action indirect fix your issue?

[jaanussiim]

From my side - I have since added/changed actions and, if I understand you correctly, I may have fixed it in the app by accident?

[tgrapperon]

If this is pointfreeco/swift-case-paths#71 kicking in, it seems indeed that having more actions fixes the issue. Most likely because the enum's layout then falls back again into something accounted by the extraction's algorithm, and it succeeds again. I didn't check the indirect trick at the time, but it seems to have the same effect. On a two enums cases, it seems enough to make the root enum indirect, so I'm wondering if it propagates upward and if making the root action from the app indirect is fixing the whole app, even if the issue occurs at a deeper level.
Of course, this is only a workaround, and I can't guarantee it will always work. The solution would likely be to handle the situation explicitly, but it requires runtime/low-level knowledge that I don't have.

[PorterHoskins]

These workarounds don't work for me. I am also never using an enum with a single value.

[PorterHoskins]

I don't think .debug() works in Release. If .debug is supposed to work in Release then it is not getting the action because nothing prints in the console.

[tgrapperon]

I thought .debug() now worked in Release because I tried on CaseStudies, but I updated the Test scheme instead of the Run one. Sorry about that.

[stephencelis]

@PorterHoskins Since it seems like your bug is slightly different than @jaanussiim's, is there a chance you can provide a repro for us to mess around with?

[PorterHoskins]

I emailed you guys.

[PorterHoskins]

Exciting news. After boiling my massive project down to it's essence I figured out how to reproduce it 🎉

The essence of it is chain scoping a store is not working right. Maybe this is an anti-pattern so let me know if I am doing something wrong.

I am running in Release from Xcode 14.0 on an iPad running 15.6.1 and on an iPhone 12 running 16.0.

// Doesn't Work
ContentView(
     store: store
           .scope(state: \.reducer2, action: ReducerFeature.Action.reducer2)
           .scope(state: \.reducer3, action: Reducer2Feature.Action.reducer3)
)
            
 // Works
ContentView(
      store: reducer2Store
            .scope(state: \.reducer3, action: Reducer2Feature.Action.reducer3)
)

Full demo:

ViewStoreUpdates.swift.zip

[mbrandonw]

Ah yes yes, I see. Yeah I'm having trouble remembering what was wrong with any Reducer in debug. I know the ReducerProtocolOf typealias broke the editor... but what did any Reducer do? @stephencelis do you remember?

[tgrapperon]

As an aside, I've just checked the ReducerProtocolOf editor issue (swiftlang/swift#60550). This issue is present in Xcode 14.0, but it seems fixed in Xcode 14.1 beta!

[mbrandonw]

Fantastic news!

[mbrandonw]

@tgrapperon We just dropped the release-restriction on using any ReducerProtocol so please let us know if you see anything funky that might be able to be tracked back to that change.

[PorterHoskins]

Looks good on my end

[PorterHoskins]

@mbrandonw is there a chance rescope has this same issue? I'm seeing the same behavior for ForEachStore after the parentStores fix.

[mbrandonw]

Huh, the parentStores fix was specifically for rescope. Do you happen to have a repro I can play with?

[PorterHoskins]

Nvm I found it. It is not TCA causing the issue.

[mbrandonw]

😮‍💨 glad you figured it out!