Rework observation for transaction actors and start to include macros

Author: phausler

include/swift/Threading/Impl/Darwin.h

@@ -238,6 +238,8 @@ inline tls_key_t tls_get_key(tls_key k) {
     return __PTK_FRAMEWORK_SWIFT_KEY4;
   case tls_key::concurrency_fallback:
     return __PTK_FRAMEWORK_SWIFT_KEY5;
+  case tls_key::observation_transaction:
+    return __PTK_FRAMEWORK_SWIFT_KEY6;
   }
 }
 

include/swift/Threading/TLSKeys.h

@@ -21,7 +21,8 @@ enum class tls_key {
   compatibility50,
   concurrency_task,
   concurrency_executor_tracking_info,
-  concurrency_fallback
+  concurrency_fallback,
+  observation_transaction
 };
 
 } // namespace swift

stdlib/public/Observation/CMakeLists.txt

@@ -1,4 +1,4 @@
-#===--- CMakeLists.txt - Reflection support library ---------------------===#
+#===--- CMakeLists.txt - Observation support library ---------------------===#
 #
 # This source file is part of the Swift.org open source project
 #
@@ -11,3 +11,4 @@
 #===----------------------------------------------------------------------===#
 
 add_subdirectory(Sources/Observation)
+add_subdirectory(Sources/ObservationMacros)

stdlib/public/Observation/Sources/Observation/CMakeLists.txt

@@ -12,24 +12,27 @@
 
 set(SWIFT_OBSERVATION_SWIFT_FLAGS)
 
+list(APPEND SWIFT_OBSERVATION_SWIFT_FLAGS
+  "-enable-experimental-feature Macros")
+
 add_swift_target_library(swiftObservation ${SWIFT_STDLIB_LIBRARY_BUILD_TYPES} IS_STDLIB
-  ImmediateTransactionModel.swift
+  KeyPaths.swift
   Locking.cpp
   Locking.swift
-  MemberKeyPaths.swift
+  Macros.swift
   Observable.swift
-  ObservationRegistrar.swift
-  ObservationToken.swift
+  ObservationRegistar.swift
   ObservationTracking.swift
-  ObservationTransaction.swift
-  ObservationTransactionModel.swift
   ObservedChanges.swift
-  Observer.swift
+  ObservedTransactions.swift
   ThreadLocal.cpp
   ThreadLocal.swift
 
   SWIFT_COMPILE_FLAGS
     ${SWIFT_STANDARD_LIBRARY_SWIFT_FLAGS}
     ${SWIFT_OBSERVATION_SWIFT_FLAGS}
   SWIFT_MODULE_DEPENDS _Concurrency
-  INSTALL_IN_COMPONENT stdlib)
+  INSTALL_IN_COMPONENT stdlib
+
+  MACCATALYST_BUILD_FLAVOR "zippered"
+)

stdlib/public/Observation/Sources/Observation/ImmediateTransactionModel.swift

@@ -0,0 +1,100 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2023 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+//
+//===----------------------------------------------------------------------===//
+
+@available(SwiftStdlib 5.9, *)
+public struct KeyPaths<Root>: SetAlgebra, Hashable, @unchecked Sendable {
+  public typealias Element = PartialKeyPath<Root>
+  public typealias ArrayLiteralElement = PartialKeyPath<Root>
+  
+  internal var raw: Set<PartialKeyPath<Root>>
+  
+  internal init(raw keyPaths: Set<AnyKeyPath>) {
+    self.raw = Set(keyPaths.compactMap { $0 as? PartialKeyPath<Root> })
+  }
+  
+  public init(_ sequence: __owned some Sequence<PartialKeyPath<Root>>) {
+    self.raw = Set(sequence)
+  }
+  
+  public init() {
+    self.raw = Set()
+  }
+  
+  public init(arrayLiteral elements: PartialKeyPath<Root>...) {
+    self.init(elements)
+  }
+  
+  public func union(_ other: __owned KeyPaths<Root>) -> KeyPaths<Root> {
+    KeyPaths(raw: raw.union(other.raw))
+  }
+  
+  public func intersection(_ other: KeyPaths<Root>) -> KeyPaths<Root> {
+    KeyPaths(raw: raw.intersection(other.raw))
+  }
+  
+  public func symmetricDifference(_ other: __owned KeyPaths<Root>) -> KeyPaths<Root> {
+    KeyPaths(raw: raw.symmetricDifference(other.raw))
+  }
+  
+  public mutating func formUnion(_ other: __owned KeyPaths<Root>) {
+    raw.formUnion(other.raw)
+  }
+  
+  public mutating func formIntersection(_ other: KeyPaths<Root>) {
+    raw.formIntersection(other.raw)
+  }
+  
+  public mutating func formSymmetricDifference(_ other: __owned KeyPaths<Root>) {
+    raw.formSymmetricDifference(other.raw)
+  }
+  
+  public func contains(_ member: PartialKeyPath<Root>) -> Bool {
+    raw.contains(member)
+  }
+  
+  public var isEmpty: Bool {
+    raw.isEmpty
+  }
+  
+  @discardableResult
+  public mutating func insert(_ newMember: __owned PartialKeyPath<Root>) -> (inserted: Bool, memberAfterInsert: PartialKeyPath<Root>) {
+    let (inserted, memberAfterInsert) = raw.insert(newMember)
+    return (inserted, memberAfterInsert)
+  }
+
+  @discardableResult
+  public mutating func remove(_ member: PartialKeyPath<Root>) -> PartialKeyPath<Root>? {
+    raw.remove(member)
+  }
+  
+  @discardableResult
+  public mutating func update(with newMember: __owned PartialKeyPath<Root>) -> PartialKeyPath<Root>? {
+    raw.update(with:newMember)
+  }
+  
+  public func hash(into hasher: inout Hasher) {
+    hasher.combine(raw)
+  }
+  
+  public static func == (_ lhs: KeyPaths<Root>, _ rhs: KeyPaths<Root>) -> Bool {
+    return lhs.raw == rhs.raw
+  }
+}
+
+@available(SwiftStdlib 5.9, *)
+extension KeyPaths where Root: Observable {
+  public init(dependent: KeyPaths<Root>) {
+    self.init()
+    for raw in dependent.raw {
+      self.formUnion(Root.dependencies(of: raw))
+    }
+  }
+}

stdlib/public/Observation/Sources/Observation/KeyPaths.swift

@@ -52,7 +52,7 @@ struct ManagedCriticalState<State> {
 
 @available(SwiftStdlib 5.9, *)
 protocol Deinitializable {
-  func deinitialize()
+  mutating func deinitialize()
 }
 
 @available(SwiftStdlib 5.9, *)
@@ -78,15 +78,8 @@ extension ManagedCriticalState where State: Deinitializable {
 extension ManagedCriticalState: @unchecked Sendable where State: Sendable { }
 
 @available(SwiftStdlib 5.9, *)
-extension ManagedCriticalState: Hashable {
-  static func == (
-    lhs: ManagedCriticalState<State>, 
-    rhs: ManagedCriticalState<State>
-  ) -> Bool {
-    lhs.buffer === rhs.buffer
-  }
-
-  func hash(into hasher: inout Hasher) {
-    hasher.combine(ObjectIdentifier(buffer))
+extension ManagedCriticalState: Identifiable {
+  var id: ObjectIdentifier {
+    ObjectIdentifier(buffer)
   }
 }

stdlib/public/Observation/Sources/Observation/Locking.swift

@@ -2,17 +2,18 @@
 //
 // This source file is part of the Swift.org open source project
 //
-// Copyright (c) 2022 Apple Inc. and the Swift project authors
+// Copyright (c) 2023 Apple Inc. and the Swift project authors
 // Licensed under Apache License v2.0 with Runtime Library Exception
 //
 // See https://swift.org/LICENSE.txt for license information
 //
 //===----------------------------------------------------------------------===//
 
+@available(SwiftStdlib 5.9, *)
+@attached(member)
+@attached(memberAttribute)
+public macro Observable() = #externalMacro(module: "ObservationMacros", type: "ObservableMacro")
 
 @available(SwiftStdlib 5.9, *)
-public protocol Observer<Subject> {
-  associatedtype Subject: Observable
-  
-  func changes(_ subject: Subject, to members: MemberKeyPaths<Subject>)
-}
+@attached(accessor)
+public macro ObservableProperty() = #externalMacro(module: "ObservationMacros", type: "ObservablePropertyMacro")