Update

Author: muukii

Sources/StructTransaction/CopyOnWrite.swift

@@ -0,0 +1,14 @@
+
+final class ReferenceEdgeStorage<Value>: @unchecked Sendable {
+  
+  var value: Value
+  
+  init(_ value: consuming Value) {
+    self.value = value
+  }
+  
+  func read<T>(_ thunk: (borrowing Value) -> T) -> T {
+    thunk(value)
+  }
+  
+}

Sources/StructTransaction/Source.swift

@@ -3,48 +3,16 @@
  Available only for structs
  */
 @attached(
-  extension,
-  conformances: DetectingType,
-  names: named(Accessing),
-  named(modify(source:modifier:)),
-  named(read(source:reader:)),
-  named(AccessingTarget)
+  memberAttribute
 )
-public macro Detecting() = #externalMacro(module: "StructTransactionMacros", type: "WriterMacro")
+public macro Tracking() = #externalMacro(module: "StructTransactionMacros", type: "TrackingMacro")
 
-/**
- Available only for member functions.
- Marker Macro that indicates if the function will be exported into Accessing struct.
- */
-@attached(peer)
-public macro Exporting() = #externalMacro(module: "StructTransactionMacros", type: "MarkerMacro")
-
-/**
- Use ``Detecting()`` macro to adapt struct
- */
-public protocol DetectingType {
-
-  associatedtype Accessing
-
-  @discardableResult
-  static func modify(source: inout Self, modifier: (inout Accessing) throws -> Void) rethrows -> AccessingResult
-
-  @discardableResult
-  static func read(source: Self, reader: (inout Accessing) throws -> Void) rethrows -> AccessingResult
-}
-
-extension DetectingType {
-
-  @discardableResult
-  public mutating func modify(modifier: (inout Accessing) throws -> Void) rethrows -> AccessingResult {
-    try Self.modify(source: &self, modifier: modifier)
-  }
-
-  @discardableResult
-  public borrowing func read(reader: (inout Accessing) throws -> Void) rethrows -> AccessingResult {
-    try Self.read(source: self, reader: reader)
-  }
-}
+@attached(
+  accessor, 
+  names: named(init), named(get), named(set), named(_modify)
+)
+@attached(peer, names: prefixed(`_backing_`))
+public macro TrackingProperty() = #externalMacro(module: "StructTransactionMacros", type: "TrackingPropertyMacro")
 
 public struct AccessingResult {
 
@@ -60,3 +28,57 @@ public struct AccessingResult {
   }
 }
 
+
+
+@Tracking
+struct MyState {
+  
+  init() {
+    stored_2 = 0
+  }
+  
+  var stored_1: Int = 18
+  
+  var stored_2: Int
+  
+  var computed_1: Int {
+    stored_1
+  }
+  
+  var subState: MySubState = .init()
+  
+}
+
+
+@Tracking
+struct MySubState {
+  
+  var stored_1: Int = 18
+  
+  var computed_1: Int {
+    stored_1
+  }
+  
+  init() {
+    
+  }
+  
+}
+
+#if canImport(Observation)
+import Observation
+
+@available(macOS 14.0, iOS 17.0, tvOS 15.0, watchOS 8.0, *)
+@Observable
+class Hoge {
+  
+  let stored: Int
+  
+  var stored_2: Int
+  
+  init(stored: Int) {
+    self.stored = stored
+    self.stored_2 = stored
+  }
+}
+#endif

Sources/StructTransactionMacros/Plugin.swift

@@ -6,7 +6,7 @@ import SwiftSyntaxMacros
 @main
 struct Plugin: CompilerPlugin {
   let providingMacros: [Macro.Type] = [
-    WriterMacro.self,
-    MarkerMacro.self,
+    TrackingMacro.self,
+    TrackingPropertyMacro.self,
   ]
 }

Sources/StructTransactionMacros/TracingMacro.swift

@@ -0,0 +1,48 @@
+import SwiftCompilerPlugin
+import SwiftSyntax
+import SwiftSyntaxBuilder
+import SwiftSyntaxMacros
+
+public struct TrackingMacro: Macro {
+    
+  public enum Error: Swift.Error {
+    case needsTypeAnnotation
+    case notFoundPropertyName
+  }
+  
+  public static var formatMode: FormatMode = .disabled
+  
+}
+
+extension TrackingMacro: MemberAttributeMacro {
+  
+  public static func expansion(
+    of node: AttributeSyntax,
+    attachedTo declaration: some DeclGroupSyntax,
+    providingAttributesFor member: some DeclSyntaxProtocol,
+    in context: some MacroExpansionContext
+  ) throws -> [AttributeSyntax] {
+    
+    guard let variableDecl = member.as(VariableDeclSyntax.self) else {
+      return []
+    }
+    
+    // to ignore computed properties
+    for binding in variableDecl.bindings {
+      if binding.accessorBlock != nil {
+        return []
+      }
+    }
+    
+    if variableDecl.bindingSpecifier.tokenKind == .keyword(.let) ||
+        variableDecl.bindingSpecifier.tokenKind == .keyword(.var) {
+      let macroAttribute = "@TrackingProperty"
+      let attributeSyntax = AttributeSyntax.init(stringLiteral: macroAttribute)
+      
+      return [attributeSyntax]
+    }
+    
+    return []
+  }
+
+}

Sources/StructTransactionMacros/TrackingMacro.swift

@@ -0,0 +1,150 @@
+
+import SwiftCompilerPlugin
+import SwiftSyntax
+import SwiftSyntaxBuilder
+import SwiftSyntaxMacros
+
+public struct TrackingPropertyMacro {
+  
+  public enum Error: Swift.Error {
+    
+  }
+}
+
+extension TrackingPropertyMacro: PeerMacro {
+  public static func expansion(
+    of node: AttributeSyntax,
+    providingPeersOf declaration: some DeclSyntaxProtocol,
+    in context: some MacroExpansionContext
+  ) throws -> [DeclSyntax] {
+    
+    
+    guard let variableDecl = declaration.as(VariableDeclSyntax.self) else {
+      return []
+    }
+    
+    let renameRewriter = RenameIdentifierRewriter()
+    let modifierRewriter = MakePrivateRewriter()
+    
+    var newMembers: [DeclSyntax] = []
+    
+    for binding in variableDecl.bindings {
+      if binding.accessorBlock != nil {
+        // skip computed properties
+        continue
+      }
+      
+      let backingStorageDecl = modifierRewriter.visit(
+        renameRewriter.visit(variableDecl.trimmed)
+      )
+      
+      newMembers.append(backingStorageDecl)
+    }
+    
+    return newMembers
+  }
+}
+
+extension TrackingPropertyMacro: AccessorMacro {
+  public static func expansion(
+    of node: SwiftSyntax.AttributeSyntax,
+    providingAccessorsOf declaration: some SwiftSyntax.DeclSyntaxProtocol,
+    in context: some SwiftSyntaxMacros.MacroExpansionContext
+  ) throws -> [SwiftSyntax.AccessorDeclSyntax] {
+    
+    guard let variableDecl = declaration.as(VariableDeclSyntax.self) else {
+      return []
+    }
+    
+    // `@TrackingProperty` は単一のプロパティにのみ適用可能
+    guard let binding = variableDecl.bindings.first,
+          let identifierPattern = binding.pattern.as(IdentifierPatternSyntax.self) else {
+      return []
+    }
+        
+    let propertyName = identifierPattern.identifier.text
+    let backingName = "_backing_" + propertyName
+    
+    let initAccessor = AccessorDeclSyntax(
+      """
+      @storageRestrictions(initializes: \(raw: backingName))
+      init(initialValue) {
+          \(raw: backingName) = initialValue
+      }
+      """
+    )
+    
+    let getAccessor = AccessorDeclSyntax(
+      """
+      get { \(raw: backingName) }
+      """
+    )
+    
+    let setAccessor = AccessorDeclSyntax(
+      """
+      set { \(raw: backingName) = newValue }
+      """
+    )
+    
+    let modifyAccessor = AccessorDeclSyntax(
+      """
+      _modify {
+          yield &\(raw: backingName)
+      }
+      """
+    )
+    
+    if binding.initializer == nil {      
+      return [
+        initAccessor,
+        getAccessor,
+        setAccessor,
+        modifyAccessor
+      ]
+    } else {
+      return [
+        getAccessor,
+        setAccessor,
+        modifyAccessor
+      ]
+    }
+    
+  }
+
+  
+}
+
+
+final class RenameIdentifierRewriter: SyntaxRewriter {
+  
+  init() {}
+  
+  override func visit(_ node: IdentifierPatternSyntax) -> PatternSyntax {
+    
+    let propertyName = node.identifier.text
+    let newIdentifier = IdentifierPatternSyntax.init(identifier: "_backing_\(raw: propertyName)")
+    
+    return super.visit(newIdentifier)
+    
+  }
+}
+
+final class MakePrivateRewriter: SyntaxRewriter {
+  
+  init() {}
+  
+  //  override func visit(_ node: VariableDeclSyntax) -> DeclSyntax {
+  //    return super.visit(node.trimmed(matching: { $0.isNewline }))
+  //  }
+  
+  override func visit(_ node: DeclModifierListSyntax) -> DeclModifierListSyntax {
+    if node.contains(where: { $0.name.tokenKind == .keyword(.private) }) {
+      return super.visit(node)
+    }
+    
+    var modified = node 
+    modified.append(.init(name: .keyword(.private), trailingTrivia: .spaces(1)))    
+    
+    return super.visit(modified)
+  }
+}