Add Observation support to OpenSwiftUI

Package.swift

@@ -224,6 +224,7 @@ let openSwiftUICoreTarget = Target.target(
         .product(name: "OpenQuartzCoreShims", package: "OpenCoreGraphics"),
         .product(name: "OpenAttributeGraphShims", package: "OpenAttributeGraph"),
         .product(name: "OpenRenderBoxShims", package: "OpenRenderBox"),
+        .product(name: "OpenObservation", package: "OpenObservation"),
     ] + (swiftUIRenderCondition && symbolLocatorCondition ? ["OpenSwiftUISymbolDualTestsSupport"] : []),
     cSettings: sharedCSettings,
     cxxSettings: sharedCxxSettings,
@@ -542,6 +543,7 @@ if useLocalDeps {
         .package(path: "../OpenCoreGraphics"),
         .package(path: "../OpenAttributeGraph"),
         .package(path: "../OpenRenderBox"),
+        .package(path: "../OpenObservation"),
     ]
     if attributeGraphCondition || renderBoxCondition || linkCoreUI {
         dependencies.append(.package(path: "../DarwinPrivateFrameworks"))
@@ -553,6 +555,7 @@ if useLocalDeps {
         // FIXME: on Linux platform: OG contains unsafe build flags which prevents us using version dependency
         .package(url: "https://github.com/OpenSwiftUIProject/OpenAttributeGraph", branch: "main"),
         .package(url: "https://github.com/OpenSwiftUIProject/OpenRenderBox", branch: "main"),
+        .package(url: "https://github.com/OpenSwiftUIProject/OpenObservation", branch: "main"),
     ]
     if attributeGraphCondition || renderBoxCondition || linkCoreUI {
         dependencies.append(.package(url: "https://github.com/OpenSwiftUIProject/DarwinPrivateFrameworks.git", branch: "main"))

Scripts/CI/darwin_setup_build.sh

@@ -11,4 +11,5 @@ cd $REPO_ROOT
 Scripts/CI/opencoregraphics_setup.sh
 Scripts/CI/openattributegraph_setup.sh
 Scripts/CI/openrenderbox_setup.sh
+Scripts/CI/openobservation_setup.sh
 Scripts/CI/framework_setup.sh

Scripts/CI/openobservation_setup.sh

@@ -0,0 +1,27 @@
+#!/bin/bash
+
+# A `realpath` alternative using the default C implementation.
+filepath() {
+    [[ $1 = /* ]] && echo "$1" || echo "$PWD/${1#./}"
+}
+
+REPO_ROOT="$(dirname $(dirname $(dirname $(filepath $0))))"
+
+clone_checkout_openobservation() {
+  cd $REPO_ROOT
+  revision=$(Scripts/CI/get_revision.sh openobservation)
+  cd ..
+  if [ ! -d OpenObservation ]; then
+    gh repo clone OpenSwiftUIProject/OpenObservation
+    cd OpenObservation
+  else
+    echo "OpenObservation already exists, skipping clone."
+    cd OpenObservation
+    git fetch --all --quiet
+    git stash --quiet || true
+    git reset --hard --quiet origin/main
+  fi
+  git checkout --quiet $revision
+}
+
+clone_checkout_openobservation

Sources/OpenSwiftUI/OpenGraph/Attribute/AnyAttributeFix.swift → Sources/OpenSwiftUI/Util/AnyAttributeFix.swift

@@ -33,6 +33,14 @@ extension AnyAttribute {
     package func createIndirect() -> AnyAttribute {
         preconditionFailure("#39")
     }
+
+    package var subgraph: Subgraph {
+        preconditionFailure("#39")
+    }
+
+    package var subgraph2: Subgraph? {
+        preconditionFailure("#39")
+    }
 }
 
 extension AnyAttribute {

Sources/OpenSwiftUICore/Data/Observation/ObservationUtil.swift

@@ -0,0 +1,229 @@
+//
+//  ObservationUtil.swift
+//  OpenSwiftUICore
+//
+//  Audited for 6.5.4
+//  Status: Blocked by TraceEvent
+//  ID: 7DF024579E4FC31D4E92A33BBA0366D6 (SwiftUI?)
+
+import Foundation
+package import OpenAttributeGraphShims
+@_spi(OpenSwiftUI)
+package import OpenObservation
+
+// MARK: - ObservationEntry
+
+private struct ObservationEntry {
+    let context: AnyObject
+    var properties: Set<AnyKeyPath>
+
+    func union(_ entry: ObservationEntry) -> ObservationEntry {
+        ObservationEntry(context: context, properties: properties.union(entry.properties))
+    }
+}
+
+extension ObservationTracking._AccessList {
+    mutating func merge(_ other: ObservationTracking._AccessList) {
+        withUnsafeMutablePointer(to: &self) { ptr1 in
+            withUnsafePointer(to: other) { ptr2 in
+                let selfPtr = UnsafeMutableRawPointer(mutating: ptr1)
+                    .assumingMemoryBound(to: [ObjectIdentifier: ObservationEntry].self)
+                let otherPtr = UnsafeRawPointer(ptr2)
+                    .assumingMemoryBound(to: [ObjectIdentifier: ObservationEntry].self)
+                selfPtr.pointee.merge(otherPtr.pointee) { $0.union($1) }
+            }
+        }
+    }
+}
+
+// MARK: - ObservationGraphMutation
+
+private struct ObservationGraphMutation: GraphMutation {
+    var invalidatingMutation: InvalidatingGraphMutation
+    var observationTracking: [ObservationTracking]
+    var subgraphObservers: [(Subgraph, Int)]
+
+    func apply() {
+        for (subgraph, observerID) in subgraphObservers {
+            subgraph.removeObserver(observerID)
+        }
+        ObservationRegistrar.latestTriggers.removeAll(keepingCapacity: true)
+
+        for tracking in observationTracking {
+            if let changedKeyPath = tracking.changed {
+                ObservationRegistrar.latestTriggers.append(changedKeyPath)
+            }
+            tracking.cancel()
+        }
+        invalidatingMutation.apply()
+        ObservationRegistrar.invalidations.value.removeValue(forKey: invalidatingMutation.attribute)
+    }
+
+    mutating func combine<T>(with other: T) -> Bool where T: GraphMutation {
+        guard invalidatingMutation.combine(with: other) else {
+            return false
+        }
+        if let otherObservation = other as? ObservationGraphMutation {
+            observationTracking.append(contentsOf: otherObservation.observationTracking)
+            subgraphObservers.append(contentsOf: otherObservation.subgraphObservers)
+        }
+        return true
+    }
+
+    func cancel() {
+        for tracking in observationTracking {
+            tracking.cancel()
+        }
+        for (subgraph, observerID) in subgraphObservers {
+            subgraph.removeObserver(observerID)
+        }
+    }
+}
+
+// MARK: - ObservationRegistrar + Extension
+
+extension ObservationRegistrar {
+    package static var latestTriggers: [AnyKeyPath] = []
+
+    package static var latestAccessLists: [ObservationTracking._AccessList] = []
+
+    fileprivate static var invalidations: ThreadSpecific<[AnyWeakAttribute: (mutation: ObservationGraphMutation, accessList: ObservationTracking._AccessList)]> = .init([:])
+}
+
+// MARK: - Observation Utilities
+
+@inline(__always)
+package func _withObservation<T>(
+    do work: () throws -> T
+) rethrows -> (value: T, accessList: ObservationTracking._AccessList?) {
+    var accessList: ObservationTracking._AccessList?
+    let result = try withUnsafeMutablePointer(to: &accessList) { ptr in
+        let previous = _ThreadLocal.value
+        _ThreadLocal.value = UnsafeMutableRawPointer(ptr)
+        defer { _ThreadLocal.value = previous }
+        return try work()
+    }
+    if let accessList {
+        ObservationRegistrar.latestAccessLists.append(accessList)
+    }
+    return (result, accessList)
+}
+
+@inline(__always)
+package func _withObservation<V, T>(
+    attribute: Attribute<V>,
+    do work: () throws -> T
+) rethrows -> T {
+    let previousAccessLists = ObservationRegistrar.latestAccessLists
+    ObservationRegistrar.latestAccessLists = []
+    defer { ObservationRegistrar.latestAccessLists = previousAccessLists }
+
+    let (result, _) = try _withObservation(do: work)
+    for accessList in ObservationRegistrar.latestAccessLists {
+        installObservationSlow(accessList: accessList, attribute: attribute)
+    }
+    return result
+}
+
+@inline(__always)
+package func _installObservation<T>(
+    accessLists: [ObservationTracking._AccessList],
+    attribute: Attribute<T>
+) {
+    guard !accessLists.isEmpty else { return }
+    for accessList in accessLists {
+        installObservationSlow(accessList: accessList, attribute: attribute)
+    }
+}
+
+private func installObservationSlow<T>(
+    accessList: ObservationTracking._AccessList,
+    attribute: Attribute<T>
+) {
+    guard let subgraph = attribute.identifier.subgraph2 else {
+        return
+    }
+    let weakViewGraph = WeakUncheckedSendable(ViewGraph.current)
+    let weakAttribute = AnyWeakAttribute(attribute.identifier)
+
+    var newAccessList = accessList
+    let removedValue = ObservationRegistrar.invalidations.value.removeValue(forKey: weakAttribute)
+    if let removedValue {
+        newAccessList.merge(removedValue.accessList)
+        removedValue.mutation.cancel()
+    }
+
+    let tracking = ObservationTracking(newAccessList)
+    let observerID = subgraph.addObserver {
+        let removedValue = ObservationRegistrar.invalidations.value.removeValue(forKey: weakAttribute)
+        if let removedValue {
+            removedValue.mutation.cancel()
+        }
+    }
+    let mutation = ObservationGraphMutation(
+        invalidatingMutation: InvalidatingGraphMutation(attribute: weakAttribute),
+        observationTracking: [tracking],
+        subgraphObservers: [(subgraph, observerID)]
+    )
+    ObservationRegistrar.invalidations.value[weakAttribute] = (mutation: mutation, accessList: newAccessList)
+    ObservationTracking._installTracking(
+        tracking,
+        willSet: { tracking in
+            guard subgraph.isValid else { return }
+            Update.ensure {
+                guard let attribute = weakAttribute.attribute,
+                      let viewGraph = weakViewGraph.value else {
+                    mutation.cancel()
+                    return
+                }
+                // TODO: transaction result
+                let _ = viewGraph.asyncTransaction(
+                    Transaction.current,
+                    mutation: mutation,
+                    style: Thread.isMainThread ? .immediate : .deferred,
+                )
+                // TODO: AGGraphAddTraceEvent
+            }
+        }
+    )
+}
+
+// MARK: - Rule + Observation
+
+extension Rule {
+    @inline(__always)
+    package func withObservation<T>(do work: () throws -> T) rethrows -> T {
+        try _withObservation(attribute: attribute, do: work)
+    }
+
+    package var observationInstaller: (ObservationTracking._AccessList) -> Void {
+        { [attribute] accessList in
+            guard attribute.subgraph.isValid else {
+                return
+            }
+            attribute.subgraph.apply {
+                installObservationSlow(accessList: accessList, attribute: attribute)
+            }
+        }
+    }
+}
+
+// MARK: - StatefulRule + Observation
+
+extension StatefulRule {
+    @inline(__always)
+    package func withObservation<T>(do work: () throws -> T) rethrows -> T {
+        try _withObservation(attribute: attribute, do: work)
+    }
+
+    package var observationInstaller: (ObservationTracking._AccessList) -> Void {
+        { [attribute] accessList in
+            guard attribute.subgraph.isValid else {
+                return
+            }
+            attribute.subgraph.apply {
+                installObservationSlow(accessList: accessList, attribute: attribute)
+            }
+        }
+    }
+}

Sources/OpenSwiftUICore/Data/State/State.swift

@@ -266,7 +266,7 @@ private struct StatePropertyBox<Value>: DynamicPropertyBox {
                 signal: signal
             )
         }
-        let signalChanged = signal.changedValue()?.changed ?? false
+        let signalChanged = signal.changedValue(options: [])?.changed ?? false
         property._value = location!.updateValue
         property._location = location!
         return (signalChanged ? location!.wasRead : false) || locationChanged

Sources/OpenSwiftUICore/OpenGraph/AnyAttributeFix.swift → Sources/OpenSwiftUICore/Util/AnyAttributeFix.swift

@@ -76,6 +76,14 @@ extension AnyAttribute {
     package func invalidateValue() {
         preconditionFailure("#39")
     }
+
+    package var subgraph: Subgraph {
+        preconditionFailure("#39")
+    }
+
+    package var subgraph2: Subgraph? {
+        preconditionFailure("#39")
+    }
 }
 
 extension AnyAttribute {

Sources/OpenSwiftUICore/OpenGraph/OpenGraphAdditions.swift → Sources/OpenSwiftUICore/Util/AttributeGraphAdditions.swift

@@ -1,5 +1,5 @@
 //
-//  OpenAttributeGraphAdditions.swift
+//  AttributeGraphAdditions.swift
 //  OpenSwiftUICore
 //
 //  Status: WIP