Add attributes, isLazy, and keyword to Property

Author: stackotter

Sources/MacroToolkit/DeclGroupProtocol.swift

@@ -38,7 +38,7 @@ extension DeclGroupProtocol {
     public var properties: [Property] {
         members.compactMap(\.asVariable).flatMap { variable in
             var bindings = variable._syntax.bindings.flatMap { binding in
-                Property.properties(from: binding)
+                Property.properties(from: binding, in: variable)
             }
             // For the declaration `var a, b: Int` where `a` doesn't have an annotation,
             // `a` gets given the type of `b` (`Int`). To implement this, we 'drag' the

Sources/MacroToolkit/Property.swift

@@ -1,8 +1,17 @@
 import SwiftSyntax
 
+// TODO: Handle all modifiers
+// TODO: Make keyword enum-typed instead of stringly-typed
+// TODO: Improve attribute API, perhaps with a way to ignore attributes in compiler
+//   directive control flow blocks.
+// TODO: Implement a way for devs to easily verify the usage of their macros, e.g. not
+//   attached to the same decl twice, only attached to static vars, etc.
 /// A property of a declaration group such as a `struct`.
 public struct Property {
     public var _syntax: TokenSyntax
+    public var attributes: [AttributeListElement]
+    public var isLazy: Bool
+    public var keyword: String
     public var identifier: String
     public var type: Type?
     public var initialValue: Expr?
@@ -20,7 +29,9 @@ public struct Property {
         getter == nil
     }
 
-    static func properties(from binding: PatternBindingSyntax) -> [Property] {
+    static func properties(from binding: PatternBindingSyntax, in decl: Variable)
+        -> [Property]
+    {
         let accessors: [AccessorDeclSyntax] = switch binding.accessorBlock?.accessors {
             case .accessors(let block):
                 Array(block)
@@ -29,19 +40,30 @@ public struct Property {
             case .none:
                 []
         }
+        let attributes: [AttributeListElement] = if decl.bindings.count == 1 {
+            decl.attributes
+        } else {
+            []
+        }
         return properties(
             pattern: binding.pattern,
             initialValue: (binding.initializer?.value).map(Expr.init),
             type: (binding.typeAnnotation?.type).map(Type.init),
-            accessors: accessors
+            accessors: accessors,
+            attributes: attributes,
+            keyword: decl._syntax.bindingSpecifier.text,
+            isLazy: decl._syntax.modifiers.contains { $0.name.text == "lazy" }
         )
     }
 
     private static func properties(
         pattern: PatternSyntax,
         initialValue: Expr?,
         type: Type?,
-        accessors: [AccessorDeclSyntax]
+        accessors: [AccessorDeclSyntax],
+        attributes: [AttributeListElement],
+        keyword: String,
+        isLazy: Bool
     ) -> [Property] {
         switch pattern.asProtocol(PatternSyntaxProtocol.self) {
             case let pattern as IdentifierPatternSyntax:
@@ -67,6 +89,9 @@ public struct Property {
                 return [
                     Property(
                         _syntax: pattern.identifier,
+                        attributes: attributes,
+                        isLazy: isLazy,
+                        keyword: keyword,
                         identifier: pattern.identifier.text,
                         type: type,
                         initialValue: initialValue,
@@ -117,10 +142,10 @@ public struct Property {
                         tupleType?.elements[index]
                     }
 
-                    // Tuple bindings can't have accessors
+                    // Tuple bindings can't have accessors or attributes (i.e. property wrappers or macros)
                     return properties(
                         pattern: element.pattern, initialValue: initialValue, type: type,
-                        accessors: []
+                        accessors: [], attributes: [], keyword: keyword, isLazy: isLazy
                     )
                 }
             case _ as WildcardPatternSyntax:

Tests/MacroToolkitTests/MacroToolkitTests.swift

@@ -446,13 +446,18 @@ final class MacroToolkitTests: XCTestCase {
         let decl: DeclSyntax = """
             struct MyStruct {
                 var a: String, b: Int = 2
+                @MyMacro
                 var c, d: Int
-                var e: Float
+                var e: Float {
+                    1.0
+                }
+                @MyPropertyWrapper
                 var f = 2
-                var g = ""
+                let g = ""
+                @MyMacro
                 var (h, i) = (1.0, [])
                 var ((j, (k, l)), m): ((Int, (String, Float)), Int) = ((1, ("abc", 2)), 3)
-                var n = [1, 2.5]
+                lazy var n = [1, 2.5]
             }
             """
 
@@ -470,50 +475,66 @@ final class MacroToolkitTests: XCTestCase {
         XCTAssertEqual(a.identifier, "a")
         XCTAssertEqual(a.type?.description, "String")
         XCTAssertEqual(a.initialValue.debugDescription, "nil")
+        XCTAssertEqual(a.isStored, true)
+        XCTAssertEqual(a.isLazy, false)
+        XCTAssertEqual(a.attributes.count, 0)
+        XCTAssertEqual(a.keyword, "var")
         // Assignment in a multi-binding declaration.
         let b = declGroup.properties[1]
         XCTAssertEqual(b.identifier, "b")
         XCTAssertEqual(b.type?.description, "Int")
         XCTAssertEqual(b.initialValue?.asIntegerLiteral?.value, 2)
 
         // The type of `c` should be inferred to be the same as `d` (`Int`), since `c`
-        // doesn't have an annotation.
+        // doesn't have an annotation. The attribute should be ignored as it isn't
+        // attached to either of the properties, just the declaration of both together.
         let c = declGroup.properties[2]
         XCTAssertEqual(c.identifier, "c")
         XCTAssertEqual(c.type?.description, "Int")
         XCTAssertEqual(c.initialValue.debugDescription, "nil")
+        XCTAssertEqual(c.attributes.count, 0)
         // Simple annotated binding in a multi-binding declaration.
         let d = declGroup.properties[3]
         XCTAssertEqual(d.identifier, "d")
         XCTAssertEqual(d.type?.description, "Int")
         XCTAssertEqual(d.initialValue.debugDescription, "nil")
+        XCTAssertEqual(d.attributes.count, 0)
 
         // Simple annotated binding in a single-binding declaration.
         let e = declGroup.properties[4]
         XCTAssertEqual(e.identifier, "e")
         XCTAssertEqual(e.type?.description, "Float")
         XCTAssertEqual(e.initialValue.debugDescription, "nil")
+        XCTAssertEqual(e.isStored, false)
+        XCTAssert(e.getter != nil)
+        XCTAssert(e.setter == nil)
 
         // Inferring a type from a literal.
         let f = declGroup.properties[5]
         XCTAssertEqual(f.identifier, "f")
         XCTAssertEqual(f.type?.description, "Int")
         XCTAssertEqual(f.initialValue?.asIntegerLiteral?.value, 2)
+        XCTAssertEqual(f.attributes.count, 1)
         // Same as `f` but with a string literal.
         let g = declGroup.properties[6]
         XCTAssertEqual(g.identifier, "g")
         XCTAssertEqual(g.type?.description, "String")
         XCTAssertEqual(g.initialValue?.asStringLiteral?.value, "")
+        XCTAssertEqual(g.keyword, "let")
 
-        // Tuple binding with types inferred from literals.
+        // Tuple binding with types inferred from literals. The attribute should be
+        // ignored as it isn't attached to either of the properties, just the declaration
+        // of both together.
         let h = declGroup.properties[7]
         XCTAssertEqual(h.identifier, "h")
         XCTAssertEqual(h.type?.description, "Double")
         XCTAssertEqual(h.initialValue?.asFloatLiteral?.value, 1.0)
+        XCTAssertEqual(h.attributes.count, 0)
         let i = declGroup.properties[8]
         XCTAssertEqual(i.identifier, "i")
         XCTAssertEqual(i.type?.description, "Array<Any>")
         XCTAssertEqual(i.initialValue?._syntax.description, "[]")
+        XCTAssertEqual(i.attributes.count, 0)
 
         // A horrible nested annotated tuple binding with a literal initial value.
         let j = declGroup.properties[9]
@@ -538,5 +559,6 @@ final class MacroToolkitTests: XCTestCase {
         XCTAssertEqual(n.identifier, "n")
         XCTAssertEqual(n.type?.description, "Array<Double>")
         XCTAssertEqual(n.initialValue?._syntax.description, "[1, 2.5]")
+        XCTAssertEqual(n.isLazy, true)
     }
 }