[Macros] Introduce member attribute macros.

For each member of the declaration the macro attribute is attached to, the macro
can produce a set of attributes to attach to that member.

Author: hborla

Sources/_SwiftSyntaxMacros/CMakeLists.txt

@@ -14,6 +14,7 @@ add_swift_host_library(_SwiftSyntaxMacros
   Macro.swift
   MacroExpansionContext.swift
   MacroSystem.swift
+  MemberAttributeMacro.swift
   MemberDeclarationMacro.swift
   PeerDeclarationMacro.swift
   Syntax+MacroEvaluation.swift

Sources/_SwiftSyntaxMacros/MacroSystem.swift

@@ -65,6 +65,9 @@ class MacroApplication: SyntaxRewriter {
   var context: MacroExpansionContext
   var skipNodes: Set<Syntax> = []
 
+  /// A stack of member attribute macos to expand when iterating over a `MemberDeclListSyntax`.
+  var memberAttributeMacros: [([(CustomAttributeSyntax, MemberAttributeMacro.Type)], DeclSyntax)] = []
+
   init(
     macroSystem: MacroSystem,
     context: MacroExpansionContext
@@ -106,7 +109,7 @@ class MacroApplication: SyntaxRewriter {
           return true
         }
 
-        return !(macro is PeerDeclarationMacro.Type || macro is MemberDeclarationMacro.Type || macro is AccessorDeclarationMacro.Type)
+        return !(macro is PeerDeclarationMacro.Type || macro is MemberDeclarationMacro.Type || macro is AccessorDeclarationMacro.Type || macro is MemberAttributeMacro.Type)
       }
 
       if newAttributes.isEmpty {
@@ -203,9 +206,21 @@ class MacroApplication: SyntaxRewriter {
         continue
       }
 
+      // Expand member attribute members attached to the declaration context.
+      let attributedMember: MemberDeclListSyntax.Element
+      if let (macroAttributes, decl) = memberAttributeMacros.last {
+        attributedMember = expandAttributes(
+          for: macroAttributes,
+          attachedTo: decl,
+          annotating: item
+        )
+      } else {
+        attributedMember = item
+      }
+
       // Recurse on the child node.
-      let newDecl = visit(item.decl)
-      newItems.append(item.withDecl(newDecl))
+      let newDecl = visit(attributedMember.decl)
+      newItems.append(attributedMember.withDecl(newDecl))
 
       // Expand any peer declarations triggered by macros used as attributes.
       let peers = expandPeers(of: item.decl)
@@ -222,6 +237,14 @@ class MacroApplication: SyntaxRewriter {
   func visit<DeclType: DeclGroupSyntax & DeclSyntaxProtocol>(
     declGroup: DeclType
   ) -> DeclSyntax {
+    memberAttributeMacros.append(
+      (
+        getMacroAttributes(attachedTo: DeclSyntax(declGroup), ofType: MemberAttributeMacro.Type.self),
+        DeclSyntax(declGroup)
+      )
+    )
+    defer { memberAttributeMacros.removeLast() }
+
     // Expand any attached member macros.
     let expandedDeclGroup = expandMembers(of: declGroup)
 
@@ -392,6 +415,45 @@ extension MacroApplication {
       }
     )
   }
+
+  private func expandAttributes(
+    for macroAttributes: [(CustomAttributeSyntax, MemberAttributeMacro.Type)],
+    attachedTo decl: DeclSyntax,
+    annotating member: MemberDeclListSyntax.Element
+  ) -> MemberDeclListSyntax.Element {
+    guard let attributedDecl = member.decl.asProtocol(AttributedSyntax.self) else {
+      return member
+    }
+
+    var attributes: [CustomAttributeSyntax] = []
+    for (attribute, attributeMacro) in macroAttributes {
+      do {
+        try attributes.append(
+          contentsOf: attributeMacro.expansion(
+            of: attribute,
+            attachedTo: DeclSyntax(decl),
+            annotating: member.decl,
+            in: &context
+          )
+        )
+      } catch {
+        // Record the error
+        context.diagnose(
+          Diagnostic(
+            node: Syntax(attribute),
+            message: ThrownErrorDiagnostic(message: String(describing: error))
+          )
+        )
+      }
+    }
+
+    let newAttributes = attributes.reduce(attributedDecl.attributes ?? .init([])) {
+      $0.appending(AttributeListSyntax.Element($1))
+    }
+
+    let newDecl = attributedDecl.withAttributes(newAttributes).as(DeclSyntax.self)!
+    return member.withDecl(newDecl)
+  }
 }
 
 extension SyntaxProtocol {

Sources/_SwiftSyntaxMacros/MemberAttributeMacro.swift

@@ -0,0 +1,34 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2022 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import SwiftSyntax
+
+/// Describes a macro that can add attributes to the members inside the
+/// declaration it's attached to.
+public protocol MemberAttributeMacro: DeclarationMacro {
+  /// Expand an attached declaration macro to produce an attribute list for
+  /// a given member.
+  ///
+  /// - Parameters:
+  ///   - node: The custom attribute describing the attached macro.
+  ///   - declaration: The declaration the macro attribute is attached to.
+  ///   - member: The member delcaration to attach the resulting attributes to.
+  ///   - context: The context in which to perform the macro expansion.
+  ///
+  /// - Returns: the set of attributes to apply to the given member.
+  static func expansion(
+    of node: CustomAttributeSyntax,
+    attachedTo declaration: DeclSyntax,
+    annotating member: DeclSyntax,
+    in context: inout MacroExpansionContext
+  ) throws -> [CustomAttributeSyntax]
+}

Tests/SwiftSyntaxMacrosTest/MacroSystemTests.swift

@@ -403,6 +403,70 @@ public struct AddBackingStorage: MemberDeclarationMacro {
   }
 }
 
+public struct WrapAllProperties: MemberAttributeMacro {
+  public static func expansion(
+    of node: CustomAttributeSyntax,
+    attachedTo decl: DeclSyntax,
+    annotating member: DeclSyntax,
+    in context: inout MacroExpansionContext
+  ) throws -> [CustomAttributeSyntax] {
+    guard member.is(VariableDeclSyntax.self) else {
+      return []
+    }
+
+    return [
+      CustomAttributeSyntax(
+        attributeName: SimpleTypeIdentifierSyntax(
+          name: .identifier("Wrapper")
+        )
+      )
+      .withLeadingTrivia([.newlines(1), .spaces(2)])
+    ]
+  }
+}
+
+public struct WrapStoredProperties: MemberAttributeMacro {
+  public static func expansion(
+    of node: CustomAttributeSyntax,
+    attachedTo decl: DeclSyntax,
+    annotating member: DeclSyntax,
+    in context: inout MacroExpansionContext
+  ) throws -> [CustomAttributeSyntax] {
+    guard let property = member.as(VariableDeclSyntax.self),
+      property.bindings.count == 1
+    else {
+      return []
+    }
+
+    let binding = property.bindings.first!
+    switch binding.accessor {
+    case .none:
+      break
+    case .accessors(let node):
+      for accessor in node.accessors {
+        switch accessor.accessorKind.tokenKind {
+        case .contextualKeyword(.get), .contextualKeyword(.set):
+          return []
+        default:
+          break
+        }
+      }
+      break
+    case .getter:
+      return []
+    }
+
+    return [
+      CustomAttributeSyntax(
+        attributeName: SimpleTypeIdentifierSyntax(
+          name: .identifier("Wrapper")
+        )
+      )
+      .withLeadingTrivia([.newlines(1), .spaces(2)])
+    ]
+  }
+}
+
 // MARK: Assertion helper functions
 
 /// Assert that expanding the given macros in the original source produces
@@ -467,6 +531,8 @@ public let testMacros: [String: Macro.Type] = [
   "wrapProperty": PropertyWrapper.self,
   "addCompletionHandler": AddCompletionHandler.self,
   "addBackingStorage": AddBackingStorage.self,
+  "wrapAllProperties": WrapAllProperties.self,
+  "wrapStoredProperties": WrapStoredProperties.self,
 ]
 
 final class MacroSystemTests: XCTestCase {
@@ -645,4 +711,80 @@ final class MacroSystemTests: XCTestCase {
       """
     )
   }
+
+  func testWrapAllProperties() {
+    AssertMacroExpansion(
+      macros: testMacros,
+      """
+      @wrapAllProperties
+      struct Point {
+        var x: Int
+        var y: Int
+        var description: String { "" }
+        var computed: Int {
+          get { 0 }
+          set {}
+        }
+
+        func test() {}
+      }
+      """,
+      """
+
+      struct Point {
+        @Wrapper
+        var x: Int
+        @Wrapper
+        var y: Int
+        @Wrapper
+        var description: String { "" }
+        @Wrapper
+        var computed: Int {
+          get { 0 }
+          set {}
+        }
+
+        func test() {}
+      }
+      """
+    )
+
+    AssertMacroExpansion(
+      macros: testMacros,
+      """
+      @wrapStoredProperties
+      struct Point {
+        var x: Int
+        var y: Int
+
+        var description: String { "" }
+
+        var computed: Int {
+          get { 0 }
+          set {}
+        }
+
+        func test() {}
+      }
+      """,
+      """
+
+      struct Point {
+        @Wrapper
+        var x: Int
+        @Wrapper
+        var y: Int
+
+        var description: String { "" }
+
+        var computed: Int {
+          get { 0 }
+          set {}
+        }
+
+        func test() {}
+      }
+      """
+    )
+  }
 }