Perception warnings in State.init

[KirillZholnerovich]

Description

For example, we have ParentFeature and ChildFeature and if we have array of ChileFeature.State in ParentFeature.State it throws runtime perception warning

Code:

@Reducer
public struct ParentFeature {
   @ObservableState
   public struct State {
   	public var items: IdentifiedArrayOf<ChildFeature.State> = [ .init() ]
   	
   	//...
   }

   //.......
}

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

No perception warnings

Actual behavior

Have perception warnings

Reproducing project

No response

The Composable Architecture version information

1.15.0

Destination operating system

iOS 18.0

Xcode version information

Xcode 16.0

Swift Compiler version information

swift-driver version: 1.115 Apple Swift version 6.0 (swiftlang-6.0.0.9.10 clang-1600.0.26.2)
Target: arm64-apple-macosx15.0

[stephencelis]

@KirillZholnerovich I don't think this is a bug in the library and you have not provided a full reproduction for us to evaluate the problem.

It does sound like maybe there could be an observation issue in your application requiring a WithPerceptionTracking view, but we'll need more info to help. Please follow up in the discussion with some compiling sample code!

[KirillZholnerovich]

@stephencelis Hi! Thank you for the answer. Here is a full example:

import ComposableArchitecture
import SwiftUI

@Reducer
public struct ChildFeature {
    @ObservableState
    public struct State: Equatable, Identifiable {
        public var id: UUID
        public var counter: Int = 0
		
        public init() {
            @Dependency(\.uuid) var uuid
            self.id = uuid()
        }
    }
	
    public enum Action {
        case decrementButtonTapped
        case incrementButtonTapped
    }
	
    public init() {}
	
    public var body: some ReducerOf<Self> {
        Reduce { state, action in
            switch action {
            case .decrementButtonTapped:
                state.counter -= 1
                return .none
				
            case .incrementButtonTapped:
                state.counter += 1
                return .none
            }
        }
    }
}

public struct ChildView: View {
    private let store: StoreOf<ChildFeature>
	
    public init(store: StoreOf<ChildFeature>) {
        self.store = store
    }
	
    public var body: some View {
        WithPerceptionTracking {
            HStack(spacing: 20) {
                Button("-") {
                    self.store.send(.decrementButtonTapped)
                }
				
                Text("Counter: \(self.store.counter)")
				
                Button("+") {
                    self.store.send(.incrementButtonTapped)
                }
            }
        }
    }
}

@Reducer
public struct ParentFeature {
    @ObservableState
    public struct State {
        public var items: IdentifiedArrayOf<ChildFeature.State> = []
		
        public init() {
            self.items.append(.init())
        }
    }
	
    public enum Action {
        case items(IdentifiedActionOf<ChildFeature>)
    }
	
    public init() {}
	
    public var body: some ReducerOf<Self> {
        Reduce { state, action in
            switch action {
            case .items:
                return .none
            }
        }
        .forEach(\.items, action: \.items) {
            ChildFeature()
        }
    }
}

public struct ParentView: View {
    public let store: StoreOf<ParentFeature>
	
    public init(store: StoreOf<ParentFeature>) {
        self.store = store
    }
	
    public var body: some View {
        WithPerceptionTracking {
            VStack {
                ForEach(
                    self.store.scope(
                        state: \.items,
                        action: \.items
                    )
                ) { itemStore in
                    WithPerceptionTracking {
                        ChildView(store: itemStore)
                    }
                }
            }
        }
    }
}

#Preview {
    ParentView(
        store: Store(initialState: .init()) {
            ParentFeature()
        }
    )
}

And if I rewrite my ParentFeature like this I have no warnings anymore :

@Reducer
public struct ParentFeature {
    @ObservableState
    public struct State {
        public var items: IdentifiedArrayOf<ChildFeature.State> = []
		
        public init() {}
    }
	
    public enum Action {
        case items(IdentifiedActionOf<ChildFeature>)
        case onAppear
    }
	
    public init() {}
	
    public var body: some ReducerOf<Self> {
        Reduce { state, action in
            switch action {
            case .items:
                return .none
				
            case .onAppear:
                state.items.append(.init())
                return .none
            }
        }
        .forEach(\.items, action: \.items) {
            ChildFeature()
        }
    }
}

public struct ParentView: View {
    public let store: StoreOf<ParentFeature>
	
    public init(store: StoreOf<ParentFeature>) {
        self.store = store
    }
	
    public var body: some View {
        WithPerceptionTracking {
            VStack {
                ForEach(
                    self.store.scope(
                        state: \.items,
                        action: \.items
                    )
                ) { itemStore in
                    WithPerceptionTracking {
                        ChildView(store: itemStore)
                    }
                }
            }
            .onAppear { self.store.send(.onAppear) }
        }
    }
}

[stephencelis]

@KirillZholnerovich Thanks for the example! This behavior is expected and reproducible in vanilla SwiftUI observation, not just TCA. If you directly access/mutate state in the body of the view, it will be observed, and this includes logic in initializers if you aren't careful.

One option is to assign through the underscored properties to explicitly opt out of observation:

 public init() {
-  self.items.append(.init())
+  self._items.append(.init())
 }

In this case it's not enough of a fix, though, because your child feature has its id observed when it is created and appended to the identified array because id is mutable and thus observable. So you could work around this by updating it to be a let, which will opt out of observation:

 @Reducer
 public struct ChildFeature {
   @ObservableState
   public struct State: Equatable, Identifiable {
-    public var id: UUID
+    public let id: UUID

And now things build and run without the warnings, since nothing is being observed in the view.

So this is one path you can take: explicitly avoid observable paths when observable state is initialized in view bodies.

Alternately, you can avoid creating observable state directly inside view bodies. Instead, you can create them in actions (like the onAppear action you used above), or for a root store/model, you can create it in the init of your application instead of its scene body.