Support optional binding implicit nil initializing (#18)

Author: muukii

Sources/StateStruct/Source.swift

@@ -29,6 +29,18 @@ public macro COWTrackingProperty() =
 
 #if DEBUG
 
+  @Tracking
+  struct OptinalPropertyState {
+
+    var name: String
+    var stored_1: Int?
+
+    init() {
+      self.name = ""
+    }
+
+  }
+
   @Tracking
   struct LetState {
 
@@ -90,6 +102,8 @@ public macro COWTrackingProperty() =
 
       var stored_2: Int
 
+      var stored_3: Int?
+
       var name = ""
 
       init(stored: Int) {

Sources/StateStructMacros/COWTrackingPropertyMacro.swift

@@ -1,8 +1,8 @@
 import SwiftCompilerPlugin
 import SwiftSyntax
 import SwiftSyntaxBuilder
-import SwiftSyntaxMacros
 import SwiftSyntaxMacroExpansion
+import SwiftSyntaxMacros
 
 public struct COWTrackingPropertyMacro {
 
@@ -44,15 +44,34 @@ extension COWTrackingPropertyMacro: PeerMacro {
     var _variableDecl = variableDecl.trimmed
     _variableDecl.attributes = [.init(.init(stringLiteral: "@TrackingIgnored"))]
 
-    _variableDecl = _variableDecl
-      .renamingIdentifier(with: "_backing_")
-      .modifyingTypeAnnotation({ type in
-        return "_BackingStorage<\(type.trimmed)>"
-      })
-      .modifyingInit({ initializer in                
-        return .init(value: "_BackingStorage.init(\(initializer.value))" as ExprSyntax)        
-      })
-    
+    if variableDecl.isOptional {
+      _variableDecl =
+        _variableDecl
+        .renamingIdentifier(with: "_backing_")
+        .modifyingTypeAnnotation({ type in
+          return "_BackingStorage<\(type.trimmed)>"
+        })
+
+      _variableDecl = _variableDecl.with(
+        \.bindings,
+        .init(
+          _variableDecl.bindings.map { binding in
+            binding.with(\.initializer, .init(value: "_BackingStorage.init(nil)" as ExprSyntax))
+          })
+      )
+
+    } else {
+      _variableDecl =
+        _variableDecl
+        .renamingIdentifier(with: "_backing_")
+        .modifyingTypeAnnotation({ type in
+          return "_BackingStorage<\(type.trimmed)>"
+        })
+        .modifyingInit({ initializer in
+          return .init(value: "_BackingStorage.init(\(initializer.value))" as ExprSyntax)
+        })
+    }
+
     newMembers.append(DeclSyntax(_variableDecl))
 
     return newMembers
@@ -88,7 +107,7 @@ extension COWTrackingPropertyMacro: AccessorMacro {
       }
       """
     )
-    
+
     let readAccessor = AccessorDeclSyntax(
       """
       _read {
@@ -113,7 +132,7 @@ extension COWTrackingPropertyMacro: AccessorMacro {
         } else {
           \(raw: backingName).value = newValue
         }
-      
+
       }
       """
     )
@@ -132,17 +151,19 @@ extension COWTrackingPropertyMacro: AccessorMacro {
       }
       """
     )
-    
+
     var accessors: [AccessorDeclSyntax] = []
-       
+
+    if binding.initializer == nil {
+      accessors.append(initAccessor)
+    }
+
     accessors.append(readAccessor)
+
     if !isConstant {
-      accessors.append(setAccessor)      
+      accessors.append(setAccessor)
       accessors.append(modifyAccessor)
     }
-    if binding.initializer == nil {
-      accessors.append(initAccessor)
-    }
 
     return accessors
 
@@ -153,28 +174,28 @@ extension COWTrackingPropertyMacro: AccessorMacro {
 extension VariableDeclSyntax {
   func renamingIdentifier(with newName: String) -> VariableDeclSyntax {
     let newBindings = self.bindings.map { binding -> PatternBindingSyntax in
-      
+
       if let identifierPattern = binding.pattern.as(IdentifierPatternSyntax.self) {
-        
+
         let propertyName = identifierPattern.identifier.text
-        
+
         let newIdentifierPattern = identifierPattern.with(
           \.identifier, "\(raw: newName)\(raw: propertyName)")
         return binding.with(\.pattern, .init(newIdentifierPattern))
       }
       return binding
     }
-    
+
     return self.with(\.bindings, .init(newBindings))
   }
 }
 
 extension VariableDeclSyntax {
   func withPrivateModifier() -> VariableDeclSyntax {
-    
+
     let privateModifier = DeclModifierSyntax.init(
       name: .keyword(.private), trailingTrivia: .spaces(1))
-    
+
     var modifiers = self.modifiers
     if modifiers.contains(where: { $0.name.tokenKind == .keyword(.private) }) {
       return self
@@ -185,7 +206,15 @@ extension VariableDeclSyntax {
 }
 
 extension VariableDeclSyntax {
-  
+
+  var isOptional: Bool {
+
+    return self.bindings.contains(where: {
+      $0.typeAnnotation?.type.is(OptionalTypeSyntax.self) ?? false
+    })
+
+  }
+
   func modifyingTypeAnnotation(_ modifier: (TypeSyntax) -> TypeSyntax) -> VariableDeclSyntax {
     let newBindings = self.bindings.map { binding -> PatternBindingSyntax in
       if let typeAnnotation = binding.typeAnnotation {
@@ -195,21 +224,23 @@ extension VariableDeclSyntax {
       }
       return binding
     }
-    
+
     return self.with(\.bindings, .init(newBindings))
   }
-  
-  func modifyingInit(_ modifier: (InitializerClauseSyntax) -> InitializerClauseSyntax) -> VariableDeclSyntax {
-    
-    let newBindings = self.bindings.map { binding -> PatternBindingSyntax in      
+
+  func modifyingInit(_ modifier: (InitializerClauseSyntax) -> InitializerClauseSyntax)
+    -> VariableDeclSyntax
+  {
+
+    let newBindings = self.bindings.map { binding -> PatternBindingSyntax in
       if let initializer = binding.initializer {
         let newInitializer = modifier(initializer)
         return binding.with(\.initializer, newInitializer)
       }
       return binding
     }
-    
+
     return self.with(\.bindings, .init(newBindings))
   }
-  
+
 }

Tests/StateStructMacroTests/COWTrackingProperyMacroTests.swift

@@ -17,19 +17,113 @@ final class COWTrackingProperyMacroTests: XCTestCase {
       super.invokeTest()
     }
   }
-    
+
+  func test_optional_init() {
+    assertMacro {
+      """
+      struct OptinalPropertyState {
+        
+        @COWTrackingProperty
+        var stored_1: Int?
+        
+        init() {        
+        }
+        
+      }
+      """
+    } expansion: {
+      """
+      struct OptinalPropertyState {
+
+        var stored_1: Int? {
+          
+        @storageRestrictions(initializes: _backing_stored_1)
+          
+        init(initialValue) {
+          
+          _backing_stored_1 = .init(initialValue)
+          
+        }
+          
+        _read {
+          
+          (_backing_stored_1.value as? TrackingObject)?._tracking_context.path = _tracking_context.path?.pushed(.init("stored_1"))
+          
+          _Tracking._tracking_modifyStorage {
+          
+            $0.accessorRead(path: _tracking_context.path?.pushed(.init("stored_1")))
+          
+          }
+          
+          yield _backing_stored_1.value
+          
+        }
+          
+        set {
+          
+          (_backing_stored_1.value as? TrackingObject)?._tracking_context.path = _tracking_context.path?.pushed(.init("stored_1"))
+          
+          _Tracking._tracking_modifyStorage {
+          
+            $0.accessorSet(path: _tracking_context.path?.pushed(.init("stored_1")))
+          
+          }
+          
+          if !isKnownUniquelyReferenced(&_backing_stored_1) {
+          
+            _backing_stored_1 = .init(newValue)
+          
+          } else {
+          
+            _backing_stored_1.value = newValue
+          
+          }
+
+          
+        }
+          
+        _modify {
+          
+          (_backing_stored_1.value as? TrackingObject)?._tracking_context.path = _tracking_context.path?.pushed(.init("stored_1"))
+          
+          _Tracking._tracking_modifyStorage {
+          
+            $0.accessorModify(path: _tracking_context.path?.pushed(.init("stored_1")))
+          
+          }
+          
+          if !isKnownUniquelyReferenced(&_backing_stored_1) {
+          
+            _backing_stored_1 = .init(_backing_stored_1.value)
+          
+          }
+          
+          yield &_backing_stored_1.value
+          
+        }
+        }
+          var _backing_stored_1: _BackingStorage<Int?> = _BackingStorage.init(nil)
+        
+        init() {        
+        }
+        
+      }
+      """
+    }
+  }
+
   func test_macro() {
 
     assertMacro {
       """
       struct MyState {
-      
+
         @COWTrackingProperty  
         private var stored_0: Int = 18
-      
+
         @COWTrackingProperty  
         public var stored_1: Int = 18
-      
+
         func compute() {
         }
       }