After changing @State, the value of the old state is still obtained under WithPerceptionTracking

[zhuscat]

Description

Here is my code:

import Perception
import SwiftUI

@Perceptible
class MyFooStore {
  var shouldShow = false
}

struct FooView: View {
  @State var localShouldShow = false
  @State var store = MyFooStore()

  var body: some View {
    WithPerceptionTracking {
      VStack {
        if store.shouldShow && localShouldShow {
          Text("SHOW")
        }
        Button {
          store.shouldShow.toggle()
        } label: {
          Text("TOGGLE")
        }
      }
      .onAppear {
        localShouldShow = true
      }
    }
  }
}

#Preview {
  FooView()
}

I modified the value of localShouldShow in onAppear, and then clicked the button to change the value of shouldShow in the store. However, after clicking, "SHOW" does not appear. I found that the value of localShouldShow is still false when the view is rendered.

But if I change the order of the conditional statement to if localShouldShow && store.shouldShow, it works normally. Is this a bug in Swift Perception?

20241225-224511.mp4

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

View can update

Actual behavior

View not update

Steps to reproduce

use the code above

Perception version information

1.4.1

Destination operating system

Preview

Xcode version information

Version 16.1 (16B40)

Swift Compiler version information

swift-driver version: 1.115 Apple Swift version 6.0.2 (swiftlang-6.0.2.1.2 clang-1600.0.26.4)
Target: arm64-apple-macosx15.0

[zhuscat]

Is this a BUG? 😭

[mbrandonw]

Hi @zhuscat, this is a SwiftUI bug and it has to do with views with escaping closures. WithPerceptionTracking is one such view, but any view with an escaping closure will cause this problem. For example, here is an iOS 18 view that uses @Observable and GeometryReader to reproduce the exact same problem:

@Observable
class MyFooStore {
  var shouldShow = false
}

struct FooView: View {
  @State var localShouldShow = false
  @State var store = MyFooStore()

  var body: some View {
    GeometryReader { _ in
      VStack {
        if store.shouldShow && localShouldShow {
          Text("SHOW")
        }
        Button {
          store.shouldShow.toggle()
        } label: {
          Text("TOGGLE")
        }
      }
      .onAppear {
        localShouldShow = true
      }
    }
  }
}

The fix is to eagerly access @State in the view. Even doing something as simple as let _ = localShouldShow in the view would fix it. And the reason changing the order of && fixed things is because && uses an auto-closure for the right-hand side argument that prevents evaluating that expression if the left-hand side is false.

Since this isn't an issue with the library I am going to convert it to a discussion. Please feel free to continue the conversation over there!

[zhuscat]

@mbrandonw Thank you very much for your reply. If such a bug exists in SwiftUI, how can I avoid unintentionally introducing similar bugs when refactoring code? Are there any best practices for this? Should I access every @State for simplicity?