[ASTGen] Generate CustomAttr

Update macro tests

Author: rintaro

include/swift/AST/ASTBridging.h

@@ -605,6 +605,13 @@ BridgedCDeclAttr BridgedCDeclAttr_createParsed(BridgedASTContext cContext,
                                                BridgedSourceRange cRange,
                                                BridgedStringRef cName);
 
+SWIFT_NAME(
+    "BridgedCustomAttr.createParsed(_:atLoc:type:initContext:argumentList:)")
+BridgedCustomAttr BridgedCustomAttr_createParsed(
+    BridgedASTContext cContext, BridgedSourceLoc cAtLoc, BridgedTypeRepr cType,
+    BridgedNullablePatternBindingInitializer cInitContext,
+    BridgedNullableArgumentList cArgumentList);
+
 SWIFT_NAME(
     "BridgedDynamicReplacementAttr.createParsed(_:atLoc:attrNameLoc:lParenLoc:"
     "replacedFunction:rParenLoc:)")

lib/AST/Bridging/DeclAttributeBridging.cpp

@@ -14,6 +14,7 @@
 
 #include "swift/AST/ASTContext.h"
 #include "swift/AST/Attr.h"
+#include "swift/AST/Expr.h"
 #include "swift/AST/Identifier.h"
 #include "swift/Basic/Assertions.h"
 
@@ -129,6 +130,16 @@ BridgedCDeclAttr BridgedCDeclAttr_createParsed(BridgedASTContext cContext,
                 /*Implicit=*/false);
 }
 
+BridgedCustomAttr BridgedCustomAttr_createParsed(
+    BridgedASTContext cContext, BridgedSourceLoc cAtLoc, BridgedTypeRepr cType,
+    BridgedNullablePatternBindingInitializer cInitContext,
+    BridgedNullableArgumentList cArgumentList) {
+  ASTContext &context = cContext.unbridged();
+  return CustomAttr::create(
+      context, cAtLoc.unbridged(), new (context) TypeExpr(cType.unbridged()),
+      cInitContext.unbridged(), cArgumentList.unbridged());
+}
+
 BridgedDynamicReplacementAttr BridgedDynamicReplacementAttr_createParsed(
     BridgedASTContext cContext, BridgedSourceLoc cAtLoc,
     BridgedSourceLoc cAttrNameLoc, BridgedSourceLoc cLParenLoc,

lib/ASTGen/Sources/ASTGen/ASTGen.swift

@@ -68,6 +68,7 @@ class Boxed<Value> {
   }
 }
 
+/// Generate AST from ``SwiftSyntax/Syntax``.
 struct ASTGenVisitor {
   let diagnosticEngine: BridgedDiagnosticEngine
 

lib/ASTGen/Sources/ASTGen/DeclAttrs.swift

@@ -22,6 +22,7 @@ extension ASTGenVisitor {
     var attributes: BridgedDeclAttributes
     var staticSpelling: BridgedStaticSpelling
     var staticLoc: BridgedSourceLoc
+    var initContext: BridgedPatternBindingInitializer?
   }
 
   func generateDeclAttributes(_ node: some WithAttributesSyntax & WithModifiersSyntax, allowStatic: Bool) -> DeclAttributesResult {
@@ -54,6 +55,7 @@ extension ASTGenVisitor {
     }
 
     // '@' attributes.
+    var initContext: BridgedPatternBindingInitializer? = nil
     visitIfConfigElements(node.attributes, of: AttributeSyntax.self) { element in
       switch element {
       case .ifConfigDecl(let ifConfigDecl):
@@ -62,7 +64,7 @@ extension ASTGenVisitor {
         return .underlying(attribute)
       }
     } body: { attribute in
-      addAttribute(self.generateDeclAttribute(attribute: attribute))
+      addAttribute(self.generateDeclAttribute(attribute: attribute, initContext: &initContext))
     }
 
     func genStatic(node: DeclModifierSyntax, spelling: BridgedStaticSpelling) {
@@ -89,14 +91,15 @@ extension ASTGenVisitor {
     return DeclAttributesResult(
       attributes: attrs,
       staticSpelling: staticSpelling,
-      staticLoc: staticLoc
+      staticLoc: staticLoc,
+      initContext: initContext
     )
   }
 }
 
 // MARK: - Decl attributes
 extension ASTGenVisitor {
-  func generateDeclAttribute(attribute node: AttributeSyntax) -> BridgedDeclAttribute? {
+  func generateDeclAttribute(attribute node: AttributeSyntax, initContext: inout BridgedPatternBindingInitializer?) -> BridgedDeclAttribute? {
     if let identTy = node.attributeName.as(IdentifierTypeSyntax.self) {
       let attrName = identTy.name.rawText
       let attrKind = BridgedDeclAttrKind(from: attrName.bridged)
@@ -319,7 +322,7 @@ extension ASTGenVisitor {
       }
     }
 
-    return self.generateCustomAttr(attribute: node)?.asDeclAttribute
+    return self.generateCustomAttr(attribute: node, initContext: &initContext)?.asDeclAttribute
   }
 
   func generateAlignmentAttr(attribute node: AttributeSyntax) -> BridgedAlignmentAttr? {
@@ -1163,16 +1166,39 @@ extension ASTGenVisitor {
     )
   }
 
-  func generateCustomAttr(attribute node: AttributeSyntax) -> BridgedCustomAttr? {
-    guard
-      let args = node.arguments?.as(LabeledExprListSyntax.self)?[...]
-    else {
-      // TODO: Diagnose.
-      return nil
+  func generateCustomAttr(attribute node: AttributeSyntax, initContext: inout BridgedPatternBindingInitializer?) -> BridgedCustomAttr? {
+    let type = self.generate(type: node.attributeName)
+
+    let argList: BridgedArgumentList?
+    if let args = node.arguments {
+      guard let args = args.as(LabeledExprListSyntax.self) else {
+        // TODO: Diagnose?
+        return nil
+      }
+
+      if !self.declContext.isLocalContext && initContext == nil {
+        initContext = BridgedPatternBindingInitializer.create(declContext: self.declContext)
+      }
+      argList = withDeclContext(initContext?.asDeclContext ?? self.declContext) {
+        self.generateArgumentList(
+          leftParen: node.leftParen,
+          labeledExprList: args,
+          rightParen: node.rightParen,
+          trailingClosure: nil,
+          additionalTrailingClosures: nil
+        )
+      }
+    } else {
+      argList = nil
     }
 
-    _ = args
-    fatalError("unimplemented")
+    return .createParsed(
+      self.ctx,
+      atLoc: self.generateSourceLoc(node.atSign),
+      type: type,
+      initContext: initContext.asNullable,
+      argumentList: argList.asNullable
+    )
   }
 
   func generateStringLiteralTextIfNotInterpolated(expr node: some ExprSyntaxProtocol) -> BridgedStringRef? {

lib/ASTGen/Sources/ASTGen/Decls.swift

@@ -460,7 +460,8 @@ extension ASTGenVisitor {
     }
   }
 
-  func generate(patternBinding binding: PatternBindingSyntax) -> BridgedPatternBindingEntry {
+  func generate(patternBinding binding: PatternBindingSyntax, attrs: DeclAttributesResult) -> BridgedPatternBindingEntry {
+    // FIXME: Apply attributes.
     let pattern = generate(pattern: binding.pattern)
     let equalLoc = generateSourceLoc(binding.initializer?.equal)
 
@@ -471,7 +472,7 @@ extension ASTGenVisitor {
       // ensures that property initializers are correctly treated as being in a
       // local context).
       if !self.declContext.isLocalContext {
-        initContext = .create(declContext: self.declContext)
+        initContext = attrs.initContext ?? .create(declContext: self.declContext)
       }
       initExpr = withDeclContext(initContext?.asDeclContext ?? self.declContext) {
         generate(expr: initializer.value)
@@ -495,14 +496,14 @@ extension ASTGenVisitor {
     )
   }
 
-  private func generateBindingEntries(for node: VariableDeclSyntax) -> BridgedArrayRef {
+  private func generateBindingEntries(for node: VariableDeclSyntax, attrs: DeclAttributesResult) -> BridgedArrayRef {
     var propagatedType: BridgedTypeRepr?
     var entries: [BridgedPatternBindingEntry] = []
 
     // Generate the bindings in reverse, keeping track of the TypeRepr to
     // propagate to earlier patterns if needed.
     for binding in node.bindings.reversed() {
-      var entry = self.generate(patternBinding: binding)
+      var entry = self.generate(patternBinding: binding, attrs: attrs)
 
       // We can potentially propagate a type annotation back if we don't have an initializer, and are a bare NamedPattern.
       let canPropagateType = binding.initializer == nil && binding.pattern.is(IdentifierPatternSyntax.self)
@@ -536,16 +537,15 @@ extension ASTGenVisitor {
   }
 
   func generate(variableDecl node: VariableDeclSyntax) -> BridgedPatternBindingDecl {
-    // TODO: Attributes and modifiers
-    let isStatic = false  // TODO: compute this
+    let attrs = self.generateDeclAttributes(node, allowStatic: true)
     let isLet = node.bindingSpecifier.keywordKind == .let
 
     return .createParsed(
       self.ctx,
       declContext: self.declContext,
       bindingKeywordLoc: self.generateSourceLoc(node.bindingSpecifier),
-      entries: self.generateBindingEntries(for: node),
-      isStatic: isStatic,
+      entries: self.generateBindingEntries(for: node, attrs: attrs),
+      isStatic: attrs.staticLoc.isValid,
       isLet: isLet
     )
   }

lib/ASTGen/Sources/ASTGen/Exprs.swift

@@ -290,7 +290,8 @@ extension ASTGenVisitor {
         return .underlying(attribute)
       }
     } body: { node in
-      if let attr = self.generateDeclAttribute(attribute: node) {
+      var initCtx: BridgedPatternBindingInitializer?
+      if let attr = self.generateDeclAttribute(attribute: node, initContext: &initCtx) {
         result.attributes.add(attr)
       }
     }

test/ASTGen/macros.swift

@@ -17,3 +17,53 @@ func foo(a: Int) {
 struct Outer {
   #anonymousTypes { "test" }
 }
+
+@attached(extension, conformances: P1, P2)
+macro AddAllConformances() = #externalMacro(module: "MacroDefinition", type: "AddAllConformancesMacro")
+
+protocol P1 {}
+protocol P2 {}
+
+@AddAllConformances
+struct MultipleConformances {}
+
+func testConformances() {
+  func eat(arg: some P1) {}
+  eat(arg: MultipleConformances())
+}
+
+protocol DefaultInit {
+  init()
+}
+
+@attached(extension, conformances: Equatable, names: named(==))
+macro Equatable() = #externalMacro(module: "MacroDefinition", type: "EquatableViaMembersMacro")
+
+@propertyWrapper
+struct NotEquatable<T> {
+  var wrappedValue: T
+}
+
+@Equatable
+struct HasPropertyWrappers {
+  @NotEquatable
+  var value: Int = 0
+}
+
+func requiresEquatable<T: Equatable>(_: T) { }
+func testHasPropertyWrappers(hpw: HasPropertyWrappers) {
+  requiresEquatable(hpw)
+}
+
+@attached(extension, conformances: DefaultInit)
+@attached(member, conformances: DefaultInit, names: named(init()), named(f()))
+macro DefaultInit() = #externalMacro(module: "MacroDefinition", type: "RequiredDefaultInitMacro")
+
+@DefaultInit
+class C { }
+
+@DefaultInit
+class D: C { }
+
+@DefaultInit
+struct E { }