Warning when using @Perceptible with nested observable objects

[kentanakae]

Description

When using the @Perceptible property wrapper from the Perception library in a nested observable object scenario, a warning is displayed that states the perceptible state was accessed but is not being tracked, despite the view being wrapped in a WithPerceptionTracking view. This behavior occurs when modifying the list of Book objects contained within a Library object. Notably, despite the appearance of this warning, the application continues to function as expected, with the UI correctly updating to reflect changes. This suggests that while the warning is concerning, it does not appear to critically affect the app's functionality. Previously, using @Observable did not result in this warning, suggesting the issue is specific to the @Perceptible implementation.

Checklist

• I have determined that this bug is not reproducible using Swift's observation tools. If the bug is reproducible using the @Observable macro or another tool from the Observation framework, please file it directly with Apple.
• 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 expected that using @Perceptible in the same manner as @Observable would not produce any warnings when the state changes are tracked within a WithPerceptionTracking view. Specifically, modifications to the Library object's books array should be tracked without issue, allowing for a seamless update of the UI.

Actual behavior

Upon modifying the Library object (e.g., adding a new Book to the books array), the console displays the following warning:

Perceptible state was accessed but is not being tracked. Track changes to state by wrapping your view in a 'WithPerceptionTracking' view.

This occurs despite the views being properly wrapped with WithPerceptionTracking, indicating an issue with how nested @Perceptible objects are tracked or a misunderstanding of the correct implementation.
It is important to note that despite this warning, the application continues to function as expected, with the UI updating correctly to reflect changes to the Library object. This suggests that the warning may not indicate a critical failure in state tracking, but it is still concerning and potentially indicative of an underlying issue that could affect future stability or performance.

Steps to reproduce

1. Define two classes, Book and Library, both annotated with @Perceptible. Library contains an array of Book instances.
2. Create a SwiftUI view that displays information from the Library object, ensuring the view is wrapped in WithPerceptionTracking.
3. Modify the Library object by adding a new Book or changing properties of existing Book instances.
4. Observe the warning in the console after performing the modification step.
   Below is a simplified code snippet demonstrating the issue:

import SwiftUI
import Perception

@Perceptible
class Book: Identifiable {
    // Book properties
}

@Perceptible
class Library {
    var books: [Book] = []
    // Methods to modify books
}

struct ContentView: View {
    var library: Library

    var body: some View {
        WithPerceptionTracking {
            // ContentView implementation
        }
    }
}

This structure results in the aforementioned warning when the Library object is modified, despite expectations based on the library's documentation and comparable use of @Observable.

Perception version information

1.1.1

Destination operating system

iOS/iPadOS 15, 16

Xcode version information

Xcode 15.2

Swift Compiler version information

swift-driver version: 1.87.3 Apple Swift version 5.9.2 (swiftlang-5.9.2.2.56 clang-1500.1.0.2.5)
Target: arm64-apple-macosx14.0

[mbrandonw]

Hi @kentanakae, I'm not able to reproduce this on my side. Can you please provide a minimal project that demonstrates the behavior you are seeing?

[kentanakae]

Hi @mbrandonw,

Thank you for your response. Here is the sample code that demonstrates the issue:

import SwiftUI
import Perception

//@Observable
@Perceptible
class Book: Identifiable {
    var title: String
    let id = UUID()

    init(title: String) {
        self.title = title
    }
}

//@Observable
@Perceptible
class Library {
    var books: [Book] = [
        Book(title: "Sample Book 1"),
        Book(title: "Sample Book 2")
    ]

    func addBook() {
        books.append(Book(title: "Sample Book \(books.count + 1)"))
    }

    func updateFirstBook() {
        guard !books.isEmpty else { return }
        books[0].title = "Updated Title"
    }
}

struct BookView: View {
    var book: Book

    var body: some View {
        WithPerceptionTracking {
            VStack {
                Text(book.title).font(.headline)
            }
        }
    }
}

struct ContentView: View {
    var library: Library

    var body: some View {
        WithPerceptionTracking {
            NavigationView {
                List(library.books) { book in
                    NavigationLink(destination: BookView(book: book)) {
                        Text(book.title)
                    }
                }
                .navigationTitle("Library")
                .toolbar {
                    ToolbarItemGroup(placement: .navigationBarTrailing) {
                        Button("Add Book") {
                            library.addBook()
                        }
                        Button("Update First Book") {
                            library.updateFirstBook()
                        }
                    }
                }
            }
        }
    }
}

Please let me know if there's any additional information I can provide to help resolve this issue.

[Brett-Best]

The issue you're facing here is documented https://pointfreeco.github.io/swift-composable-architecture/main/documentation/composablearchitecture/observationbackport#Lazy-view-closures.

[mbrandonw]

Hi @kentanakae, as @Brett-Best pointed out, this is expected. You need to wrap the inside of the ForEach in WithPerceptionTracking too. Really any escaping trailing closure in a SwiftUI will need WithPerceptionTracking if you are going to access state inside that closure.

Since this isn't an issue with the library I am going to convert it to a discussion.

[SongJiyeon]

How about view builders? Should I wrap every view inside of closure like viewbuilders or some stacks like VStack?

[kentanakae]

Hi @mbrandonw, I apologize for the delayed response. I hadn't checked in for a while and only just noticed your message.

Understood, and thank you for converting this to a discussion.

[mbrandonw]

How about view builders? Should I wrap every view inside of closure like viewbuilders or some stacks like VStack?

@SongJiyeon Only if the builder is an escaping closure. Most builder closures are not though, such as VStack { … }, Group { … }, etc.