Merge branch 'feature/generated-accessors-1' into develop

Author: helje5

Sources/ManagedModelMacros/CompilerPlugin.swift

@@ -9,9 +9,10 @@ import SwiftSyntaxMacros
 @main
 struct ModelsPlugin: CompilerPlugin {
   let providingMacros: [ Macro.Type ] = [
-    TransientMacro.self,
-    AttributeMacro.self,
-    RelationshipMacro.self,
-    ModelMacro.self
+    TransientMacro        .self,
+    AttributeMacro        .self,
+    RelationshipMacro     .self,
+    PersistedPropertyMacro.self,
+    ModelMacro            .self
   ]
 }

Sources/ManagedModelMacros/ModelMacro/MetadataSlot.swift

@@ -78,7 +78,7 @@ extension ModelMacro {
     func metadata(for property: ModelProperty) -> ExprSyntax {
       let metaExpr : ExprSyntax? = switch property.type {
         case .plain: generateInfo(for: property)
-        case .attribute   (let attribute): 
+        case .attribute   (let attribute, isTransformable: _):
           attributeInfo   (for: property, attribute: attribute)
         case .relationship(let attribute):
           relationshipInfo(for: property, attribute: attribute)

Sources/ManagedModelMacros/ModelMacro/ModelMemberAttributes.swift

@@ -9,10 +9,10 @@ import SwiftSyntaxBuilder
 import SwiftSyntaxMacros
 
 /**
- * Attaches attributes (`@NSManaged` etc) to members.
+ * Attaches attributes, `@_PersistedProperty`, to members.
  *
  * This is attached to tracked properties:
- * - `@NSManaged`
+ * - `@_PersistedProperty`
  */
 extension ModelMacro: MemberAttributeMacro { // @attached(memberAttribute)
 
@@ -30,7 +30,8 @@ extension ModelMacro: MemberAttributeMacro { // @attached(memberAttribute)
     }
 
     var properties = [ ModelProperty ]()
-    addModelProperties(in: member, to: &properties, context: context)
+    addModelProperties(in: member, to: &properties,
+                       context: context)
 
     guard let property = properties.first else { return [] } // other member
 
@@ -41,6 +42,6 @@ extension ModelMacro: MemberAttributeMacro { // @attached(memberAttribute)
 
     guard !property.isTransient else { return [] }
 
-    return [ "@NSManaged" ]
+    return [ "@_PersistedProperty" ]
   }
 }

Sources/ManagedModelMacros/Models/ModelProperty.swift

@@ -31,7 +31,7 @@ struct ModelProperty {
     case relationship(AttributeSyntax)
 
     /// The property was explicitly tagged as an `Attribute`.
-    case attribute   (AttributeSyntax)
+    case attribute   (AttributeSyntax, isTransformable: Bool)
   }
 
   let binding           : PatternBindingSyntax
@@ -46,6 +46,17 @@ struct ModelProperty {
   let initExpression    : ExprSyntax?
 }
 
+extension ModelProperty {
+  
+  var isTransformable : Bool {
+    switch type {
+      case .plain           : return false
+      case .relationship(_) : return false
+      case .attribute(_, isTransformable: let value): return value
+    }
+  }
+}
+
 extension ModelProperty {
 
   /**
@@ -67,14 +78,14 @@ extension ModelProperty {
 
   var isKnownAttributePropertyType: Bool {
     switch type {
-      case .attribute(_)    : return true
+      case .attribute(_, _) : return true
       case .relationship(_) : return false
       case .plain: return valueType?.isKnownAttributePropertyType ?? false
     }
   }
   var isKnownRelationshipPropertyType: Bool {
     switch type {
-      case .attribute(_)    : return false
+      case .attribute(_, _) : return false
       case .relationship(_) : return true
       case .plain: return valueType?.isKnownRelationshipPropertyType ?? false
     }
@@ -100,8 +111,9 @@ extension ModelProperty.PropertyType: CustomStringConvertible {
   var description: String {
     switch self {
       case .plain           : return "plain"
-      case .attribute   (_) : return "Attribute"
       case .relationship(_) : return "Relationship"
+      case .attribute(_, isTransformable: let isTransformable) :
+        return isTransformable ? "TransformableAttribute" : "Attribute"
     }
   }
 }
@@ -222,8 +234,11 @@ extension ModelMacro {
             case "Attribute":
               switch propertyType {
                 case .plain:
-                  propertyType = .attribute(attribute)
-                case .attribute(_):
+                  propertyType = .attribute(
+                    attribute,
+                    isTransformable: isTransformableAttribute(attribute)
+                  )
+                case .attribute(_, _):
                   context.diagnose(.multipleAttributeMacrosAppliedOnProperty,
                                    on: attributes)
                 case .relationship(_):
@@ -242,7 +257,7 @@ extension ModelMacro {
                     .multipleRelationshipMacrosAppliedOnProperty,
                     on: attributes
                   )
-                case .attribute(_):
+                case .attribute(_, _):
                   context.diagnose(
                     .attributeAndRelationshipMacrosAppliedOnProperty,
                     on: attributes
@@ -258,4 +273,39 @@ extension ModelMacro {
 
     return ( propertyType, isTransient )
   }
+ 
+  // Check whether the attribute specified a `.transformable` option.
+  // Check for: `@Attribute(.transformable(by: xx))`,
+  // Signature: (_ options: Option..., originalName...)
+  private static func isTransformableAttribute(_ syntax: AttributeSyntax)
+                      -> Bool
+  {
+    guard let arguments = syntax.arguments,
+          case .argumentList(let labeledExpressions) = arguments else
+    {
+      return false
+    }
+
+    for labeledExpression in labeledExpressions {
+      guard labeledExpression.label == nil else { break }
+      
+      guard let funCall = labeledExpression.expression
+                            .as(FunctionCallExprSyntax.self),
+            let member = funCall.calledExpression
+                            .as(MemberAccessExprSyntax.self)
+      else {
+        continue
+      }
+      guard case .identifier(let name) =
+              member.declName.baseName.tokenKind else
+      {
+        continue
+      }
+      
+      // Could be more advanced :-)
+      if name == "transformable" { return true }
+    }
+    
+    return false
+  }
 }

Sources/ManagedModelMacros/PropertyMacros/PersistedPropertyMacro.swift

@@ -0,0 +1,32 @@
+import SwiftCompilerPlugin
+import SwiftSyntax
+import SwiftSyntaxBuilder
+import SwiftSyntaxMacros
+
+// @attached(accessor) macro
+public struct PersistedPropertyMacro: AccessorMacro {
+  
+  public static func expansion(
+    of                     macroNode : AttributeSyntax,
+    providingAccessorsOf declaration : some DeclSyntaxProtocol,
+    in                       context : some MacroExpansionContext
+  ) throws -> [ AccessorDeclSyntax ]
+  {
+    assert(declaration.parent == nil, "We do have access to the parent?!")
+
+    var properties = [ ModelProperty ]()
+    ModelMacro
+      .addModelProperties(in: declaration, to: &properties, context: context)
+    guard let property = properties.first else { return [] }
+    if properties.count > 1 {
+      context.diagnose(.multipleMembersInAttributesMacroCall, on: macroNode)
+      return []
+    }
+    
+    return property.isTransformable
+    ? [ "set { setTransformableValue(forKey: \(literal: property.name), to: newValue) }",
+        "get { getTransformableValue(forKey: \(literal: property.name)) }" ]
+    : [ "set { setValue(forKey: \(literal: property.name), to: newValue) }",
+        "get { getValue(forKey: \(literal: property.name)) }" ]
+  }
+}

Sources/ManagedModels/ModelMacroDefinition.swift

@@ -55,6 +55,14 @@ public macro Relationship(
 public macro Transient() =
   #externalMacro(module: "ManagedModelMacros", type: "TransientMacro")
 
+/**
+ * An internal helper macro. Don't use this.
+ */
+@available(swift 5.9)
+@attached(accessor, names: named(init))
+public macro _PersistedProperty() =
+  #externalMacro(module: "ManagedModelMacros", type: "PersistedPropertyMacro")
+
 
 // MARK: - Model Macro