Add the implementation body for observation macros

Author: phausler

stdlib/public/Observation/Sources/ObservationMacros/ObservableMacro.swift

@@ -0,0 +1,132 @@
+import SwiftSyntax
+import SwiftSyntaxMacros
+
+private extension DeclSyntaxProtocol {
+  var isObservableStoredProperty: Bool {
+    guard let property = self.as(VariableDeclSyntax.self),
+          let binding = property.bindings.first
+    else {
+      return false
+    }
+
+    return binding.accessor == nil
+  }
+}
+
+public struct ObservableMacro: MemberMacro, MemberAttributeMacro {
+
+  // MARK: - MemberMacro
+  public static func expansion(
+    of node: AttributeSyntax,
+    providingMembersOf declaration: some DeclGroupSyntax,
+    in context: some MacroExpansionContext
+  ) throws -> [DeclSyntax] {
+    guard let identified = declaration.asProtocol(IdentifiedDeclSyntax.self) else {
+      return []
+    }
+
+    let parentName = identified.identifier
+
+    let registrar: DeclSyntax =
+      """
+      let _registrar = ObservationRegistrar<\(parentName)>()
+      """
+
+    let transactions: DeclSyntax =
+      """
+      public nonisolated func transactions<Delivery>(for keyPaths: KeyPaths<\(parentName)>, isolation: Delivery) -> ObservedTransactions<\(parentName), Delivery> where Delivery: Actor {
+        _registrar.transactions(for: keyPaths, isolation: isolation)
+      }
+      """
+
+    let changes: DeclSyntax =
+      """
+      public nonisolated func changes<Member>(for keyPath: KeyPath<\(parentName), Member>) -> ObservedChanges<\(parentName), Member> where Member: Sendable {
+        _registrar.changes(for: keyPath)
+      }
+      """
+
+    let memberList = MemberDeclListSyntax(
+      declaration.members.members.filter {
+        $0.decl.isObservableStoredProperty
+      }
+    )
+
+    let storageStruct: DeclSyntax =
+      """
+      private struct _Storage {
+      \(memberList)
+      }
+      """
+
+    let storage: DeclSyntax =
+      """
+      private var _storage = _Storage()
+      """
+
+    return [
+      registrar,
+      transactions,
+      changes,
+      storageStruct,
+      storage,
+    ]
+  }
+
+  // MARK: - MemberAttributeMacro
+  public static func expansion(
+    of node: AttributeSyntax,
+    attachedTo declaration: some DeclGroupSyntax,
+    providingAttributesFor member: DeclSyntax,
+    in context: some MacroExpansionContext
+  ) throws -> [SwiftSyntax.AttributeSyntax] {
+    guard member.isObservableStoredProperty else {
+      return []
+    }
+
+    return [
+      AttributeSyntax(
+        attributeName: SimpleTypeIdentifierSyntax(
+          name: .identifier("ObservableProperty")
+        )
+      )
+    ]
+  }
+}
+
+public struct ObservablePropertyMacro: AccessorMacro {
+  public static func expansion(
+    of node: AttributeSyntax,
+    providingAccessorsOf declaration: some DeclSyntaxProtocol,
+    in context: some MacroExpansionContext
+  ) throws -> [AccessorDeclSyntax] {
+    guard let property = declaration.as(VariableDeclSyntax.self),
+      let binding = property.bindings.first,
+      let identifier = binding.pattern.as(IdentifierPatternSyntax.self)?.identifier,
+      binding.accessor == nil
+    else {
+      return []
+    }
+
+    if identifier.text == "_registrar" || identifier.text == "_storage" { return [] }
+
+    let getAccessor: AccessorDeclSyntax =
+      """
+      get {
+        _registrar.access(self, keyPath: \\.\(identifier))
+        return _storage.\(identifier)
+      }
+      """
+
+    let setAccessor: AccessorDeclSyntax =
+      """
+      set {
+        _registrar.withMutation(self, keyPath: \\.\(identifier)) {
+          _storage.\(identifier) = newValue
+        }
+      }
+      """
+
+    return [getAccessor, setAccessor]
+  }
+}