[Observation] Ensure deinitialized Observable types don't leave active observations in memory (swiftlang#82752)

Explanation:
This ensures a potential leak with SwiftUI and other systems using
Observation do not leak observation closures when the potential
Observable instances used are only weakly referenced inside the tracking
closure.
 
Scope:
This is limited to the runtime behavior of Observable types and has no
ABI or language level interactions.

Issues:
rdar://112167556

Original PRs:
swiftlang#79823
swiftlang#82307

Risk:
Low - This is very targeted to just Observation, however it is a
behavioral change which does not make this a zero risk change.

Testing:
New unit tests were added to catch at least some of the potential cases
this issue can occur with.

Author: phausler

stdlib/public/Observation/Sources/Observation/ObservationRegistrar.swift

@@ -110,9 +110,27 @@ public struct ObservationRegistrar: Sendable {
       }
     }
 
-    internal mutating func cancelAll() {
+    internal mutating func deinitialize() -> (@Sendable () -> Void)? {
+      func extractSelf<T>(_ ty: T.Type) -> AnyKeyPath {
+        return \T.self
+      }
+
+      var tracker: (@Sendable () -> Void)?
+      lookupIteration: for (keyPath, ids) in lookups {
+        for id in ids {
+          if let found = observations[id]?.willSetTracker {
+            // convert the keyPath into its \Self.self version 
+            let selfKp = _openExistential(type(of: keyPath).rootType, do: extractSelf)
+            tracker = {
+               found(selfKp)
+            }
+            break lookupIteration
+          }
+        }
+      }
       observations.removeAll()
       lookups.removeAll()
+      return tracker
     }
 
     internal mutating func willSet(keyPath: AnyKeyPath) -> [@Sendable (AnyKeyPath) -> Void] {
@@ -157,8 +175,8 @@ public struct ObservationRegistrar: Sendable {
       state.withCriticalRegion { $0.cancel(id) }
     }
 
-    internal func cancelAll() {
-      state.withCriticalRegion { $0.cancelAll() }
+    internal func deinitialize() {
+      state.withCriticalRegion { $0.deinitialize() }?()
     }
 
     internal func willSet<Subject: Observable, Member>(
@@ -189,7 +207,7 @@ public struct ObservationRegistrar: Sendable {
     }
 
     deinit {
-      context.cancelAll()
+      context.deinitialize()
     }
   }
 

test/stdlib/Observation/Observable.swift

@@ -287,6 +287,22 @@ final class CowTest {
   var container = CowContainer()
 }
 
+@Observable
+final class DeinitTriggeredObserver {
+  var property: Int = 3
+  var property2: Int = 4
+  let deinitTrigger: () -> Void
+
+  init(_ deinitTrigger: @escaping () -> Void) {
+    self.deinitTrigger = deinitTrigger
+  }
+
+  deinit {
+    deinitTrigger()
+  }
+}
+
+
 @main
 struct Validator {
   @MainActor
@@ -511,6 +527,23 @@ struct Validator {
       expectEqual(subject.container.id, startId)
     }
 
+    suite.test("weak container observation") {
+      let changed = CapturedState(state: false)
+      let deinitialized = CapturedState(state: 0)
+      var test = DeinitTriggeredObserver {
+        deinitialized.state += 1
+      }
+      withObservationTracking { [weak test] in
+        _blackHole(test?.property)
+        _blackHole(test?.property2)
+      } onChange: {
+        changed.state = true
+      }
+      test = DeinitTriggeredObserver { }
+      expectEqual(deinitialized.state, 1) // ensure only one invocation is done per deinitialization
+      expectEqual(changed.state, true)
+    }
+
     runAllTests()
   }
 }