Perception checking in iOS 17 and a bug fix (pointfreeco#10)

* Check perception even in iOS 17.

* Fix implicit closures.

* wip

* wip

* Update WithPerceptionTracking.swift

* fix

* wip

* More tests and some performance improvements.

* more performance

* wip

Author: mbrandonw

Sources/Perception/PerceptionRegistrar.swift

@@ -80,6 +80,8 @@ extension PerceptionRegistrar {
     _ subject: Subject,
     keyPath: KeyPath<Subject, Member>
   ) {
+    perceptionCheck()
+    
     #if canImport(Observation)
       if #available(iOS 17, macOS 14, tvOS 17, watchOS 10, *) {
         func `open`<T: Observable>(_ subject: T) {
@@ -92,7 +94,6 @@ extension PerceptionRegistrar {
           open(subject)
         }
       } else {
-        perceptionCheck()
         self.perceptionRegistrar.access(subject, keyPath: keyPath)
       }
     #endif
@@ -194,7 +195,7 @@ extension PerceptionRegistrar: Hashable {
 
 #if DEBUG
   private func perceptionCheck() {
-    if #unavailable(iOS 17, macOS 14, tvOS 17, watchOS 10),
+    if
       !_PerceptionLocals.isInPerceptionTracking,
       !_PerceptionLocals.skipPerceptionChecking,
       isInSwiftUIBody()
@@ -214,8 +215,8 @@ extension PerceptionRegistrar: Hashable {
         .drop(while: { $0 != .init(ascii: "$") })
         .prefix(while: { $0 != .init(ascii: " ") })
       guard
+        mangledSymbol.isMangledViewBodyGetter,
         let demangled = String(Substring(mangledSymbol)).demangled,
-        demangled.contains("body.getter : "),
         !demangled.isActionClosure
       else {
         continue
@@ -228,11 +229,12 @@ extension PerceptionRegistrar: Hashable {
   extension String {
     fileprivate var isActionClosure: Bool {
       var view = self[...].utf8
-      guard view.starts(with: "closure #".utf8) else { return false }
+      guard
+        view.starts(with: "closure #".utf8) || view.starts(with: "implicit closure #".utf8)
+      else { return false }
       view = view.drop(while: { $0 != .init(ascii: "-") })
       return view.starts(with: "-> () in ".utf8)
     }
-
     fileprivate var demangled: String? {
       return self.utf8CString.withUnsafeBufferPointer { mangledNameUTF8CStr in
         let demangledNamePtr = swift_demangle(
@@ -291,3 +293,26 @@ extension PerceptionRegistrar: Hashable {
     apply()
   }
 #endif
+
+extension Substring.UTF8View {
+  fileprivate var isMangledViewBodyGetter: Bool {
+    self._contains("V4bodyQrvg".utf8)
+  }
+  fileprivate func _contains(_ other: String.UTF8View) -> Bool {
+    guard let first = other.first
+    else { return false }
+    let otherCount = other.count
+    var input = self
+    while let index = input.firstIndex(where: { first == $0 }) {
+      input = input[index...]
+      if
+        input.count >= otherCount,
+        zip(input, other).allSatisfy(==)
+      {
+        return true
+      }
+      input.removeFirst()
+    }
+    return false
+  }
+}

Sources/Perception/WithPerceptionTracking.swift

@@ -1,14 +1,5 @@
 import SwiftUI
 
-@available(iOS, deprecated: 17)
-@available(macOS, deprecated: 14)
-@available(tvOS, deprecated: 17)
-@available(watchOS, deprecated: 10)
-public enum _PerceptionLocals {
-  @TaskLocal public static var isInPerceptionTracking = false
-  @TaskLocal public static var skipPerceptionChecking = false
-}
-
 /// Observes changes to perceptible models.
 ///
 /// Use this view to automatically subscribe to the changes of any fields in ``Perceptible()``
@@ -58,21 +49,31 @@ public struct WithPerceptionTracking<Content> {
 
   public var body: Content {
     if #available(iOS 17, macOS 14, tvOS 17, watchOS 10, *) {
-      return self.content()
+      return self.instrumentedBody()
     } else {
       // NB: View will not re-render when 'id' changes unless we access it in the view.
       let _ = self.id
       return withPerceptionTracking {
-        _PerceptionLocals.$isInPerceptionTracking.withValue(true) {
-          self.content()
-        }
+        self.instrumentedBody()
       } onChange: {
         Task { @MainActor in
           self.id += 1
         }
       }
     }
   }
+
+  @_transparent
+  @inline(__always)
+  private func instrumentedBody() -> Content {
+    #if DEBUG
+      return _PerceptionLocals.$isInPerceptionTracking.withValue(true) {
+        self.content()
+      }
+    #else
+      return self.content()
+    #endif
+  }
 }
 
 @available(iOS 15, macOS 12, tvOS 15, watchOS 8, *)
@@ -157,3 +158,12 @@ extension WithPerceptionTracking: View where Content: View {
     self.content = content
   }
 }
+
+@available(iOS, deprecated: 17)
+@available(macOS, deprecated: 14)
+@available(tvOS, deprecated: 17)
+@available(watchOS, deprecated: 10)
+public enum _PerceptionLocals {
+  @TaskLocal public static var isInPerceptionTracking = false
+  @TaskLocal public static var skipPerceptionChecking = false
+}

Tests/PerceptionTests/RuntimeWarningTests.swift

@@ -1,3 +1,4 @@
+import Combine
 import Perception
 import SwiftUI
 import XCTest
@@ -268,15 +269,73 @@ final class RuntimeWarningTests: XCTestCase {
     self.render(FeatureView())
   }
 
-  private func expectFailure() {
-    if #unavailable(iOS 17, macOS 14, tvOS 17, watchOS 10) {
-      XCTExpectFailure {
-        $0.compactDescription == """
-          Perceptible state was accessed but is not being tracked. Track changes to state by \
-          wrapping your view in a 'WithPerceptionTracking' view.
-          """
+  func testActionClosure_CallMethodWithArguments() {
+    struct FeatureView: View {
+      @State var model = Model()
+      var body: some View {
+        Text("Hi")
+          .onAppear { _ = foo(42) }
+      }
+      func foo(_: Int) -> Bool {
+        _ = self.model.count
+        return true
       }
     }
+
+    self.render(FeatureView())
+  }
+
+  func testActionClosure_WithArguments() {
+    struct FeatureView: View {
+      @State var model = Model()
+      var body: some View {
+        Text("Hi")
+          .onReceive(Just(1)) { _ in
+            _ = self.model.count
+          }
+      }
+    }
+
+    self.render(FeatureView())
+  }
+
+  func testActionClosure_WithArguments_ImplicitClosure() {
+    struct FeatureView: View {
+      @State var model = Model()
+      var body: some View {
+        Text("Hi")
+          .onReceive(Just(1), perform: self.foo)
+      }
+      func foo(_: Int) {
+        _ = self.model.count
+      }
+    }
+
+    self.render(FeatureView())
+  }
+
+  func testImplicitActionClosure() {
+    struct FeatureView: View {
+      @State var model = Model()
+      var body: some View {
+        Text("Hi")
+          .onAppear(perform: foo)
+      }
+      func foo() {
+        _ = self.model.count
+      }
+    }
+
+    self.render(FeatureView())
+  }
+
+  private func expectFailure() {
+    XCTExpectFailure {
+      $0.compactDescription == """
+        Perceptible state was accessed but is not being tracked. Track changes to state by \
+        wrapping your view in a 'WithPerceptionTracking' view.
+        """
+    }
   }
 
   private func render(_ view: some View) {