Merge pull request swiftlang#63059 from hborla/synthesized-member-macros

hborla · web-flow · commit c7076433962b · 2023-01-25T07:28:16.000-08:00
[Macros] Initial support for synthesized member macros.
diff --git a/include/swift/AST/Decl.h b/include/swift/AST/Decl.h
@@ -80,6 +80,7 @@ namespace swift {
   class GenericSignature;
   class GenericTypeParamDecl;
   class GenericTypeParamType;
+  class MacroDecl;
   class MacroDefinition;
   class ModuleDecl;
   class NamedPattern;
@@ -856,6 +857,13 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl> {
   /// attribute macro expansion.
   DeclAttributes getSemanticAttrs() const;
 
+  using MacroCallback = llvm::function_ref<void(CustomAttr *, MacroDecl *)>;
+
+  /// Iterate over each attached macro with the given role, invoking the
+  /// given callback with each macro custom attribute and corresponding macro
+  /// declaration.
+  void forEachAttachedMacro(MacroRole role, MacroCallback) const;
+
   /// Returns the innermost enclosing decl with an availability annotation.
   const Decl *getInnermostDeclWithAvailability() const;
 
diff --git a/include/swift/AST/MacroDeclaration.h b/include/swift/AST/MacroDeclaration.h
@@ -35,6 +35,9 @@ enum class MacroRole: uint32_t {
   /// An attached macro that generates attributes for the
   /// members inside the declaration.
   MemberAttribute = 0x08,
+  /// An attached macro that generates synthesized members
+  /// inside the declaration.
+  SynthesizedMembers = 0x10,
 };
 
 /// The contexts in which a particular macro declaration can be used.
diff --git a/include/swift/AST/SourceFile.h b/include/swift/AST/SourceFile.h
@@ -511,6 +511,13 @@ class SourceFile final : public FileUnit {
   /// macro.
   CustomAttr *getAttachedMacroAttribute() const;
 
+  /// For source files created to hold the source code created by expanding
+  /// an attached macro, this is the macro role that the expansion fulfills.
+  ///
+  /// \Returns the fulfilled macro role, or \c None if this source file is not
+  /// for a macro expansion.
+  Optional<MacroRole> getFulfilledMacroRole() const;
+
   /// When this source file is enclosed within another source file, for example
   /// because it describes a macro expansion, return the source file it was
   /// enclosed in.
diff --git a/include/swift/AST/TypeCheckRequests.h b/include/swift/AST/TypeCheckRequests.h
@@ -3856,6 +3856,23 @@ class ExpandMemberAttributeMacros
   bool isCached() const { return true; }
 };
 
+/// Expand synthesized member macros attached to the given declaration.
+class ExpandSynthesizedMemberMacroRequest
+    : public SimpleRequest<ExpandSynthesizedMemberMacroRequest,
+                           bool(Decl *),
+                           RequestFlags::Cached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  bool evaluate(Evaluator &evaluator, Decl *decl) const;
+
+public:
+  bool isCached() const { return true; }
+};
+
 /// Resolve an external macro given its module and type name.
 class ExternalMacroDefinitionRequest
     : public SimpleRequest<ExternalMacroDefinitionRequest,
diff --git a/include/swift/AST/TypeCheckerTypeIDZone.def b/include/swift/AST/TypeCheckerTypeIDZone.def
@@ -458,6 +458,9 @@ SWIFT_REQUEST(TypeChecker, ExpandMacroExpansionDeclRequest,
 SWIFT_REQUEST(TypeChecker, ExpandMemberAttributeMacros,
               bool(Decl *),
               Cached, NoLocationInfo)
+SWIFT_REQUEST(TypeCHecker, ExpandSynthesizedMemberMacroRequest,
+              bool(Decl *),
+              Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, SynthesizeRuntimeMetadataAttrGenerator,
               Expr *(CustomAttr *, ValueDecl *),
               Cached, NoLocationInfo)
diff --git a/include/swift/Basic/SourceManager.h b/include/swift/Basic/SourceManager.h
@@ -44,6 +44,9 @@ class GeneratedSourceInfo {
     /// The expansion of a member attribute attached macro.
     MemberAttributeMacroExpansion,
 
+    /// The expansion of a synthesized member macro.
+    SynthesizedMemberMacroExpansion,
+
     /// A new function body that is replacing an existing function body.
     ReplacedFunctionBody,
 
diff --git a/lib/AST/ASTScopeCreation.cpp b/lib/AST/ASTScopeCreation.cpp
@@ -248,7 +248,28 @@ ASTSourceFileScope::ASTSourceFileScope(SourceFile *SF,
                                        ScopeCreator *scopeCreator)
     : SF(SF), scopeCreator(scopeCreator) {
   if (auto enclosingSF = SF->getEnclosingSourceFile()) {
-    SourceLoc parentLoc = SF->getMacroExpansion().getStartLoc();
+    SourceLoc parentLoc;
+    auto macroRole = SF->getFulfilledMacroRole();
+    auto expansion = SF->getMacroExpansion();
+
+    // Determine the parent source location based on the macro role.
+    switch (*macroRole) {
+    case MacroRole::Expression:
+    case MacroRole::FreestandingDeclaration:
+    case MacroRole::Accessor:
+    case MacroRole::MemberAttribute:
+      parentLoc = expansion.getStartLoc();
+      break;
+    case MacroRole::SynthesizedMembers: {
+      // For synthesized member macros, take the end loc of the
+      // enclosing declaration (before the closing brace), because
+      // the macro expansion is inside this scope.
+      auto *decl = expansion.getAsDeclContext()->getAsDecl();
+      parentLoc = decl->getEndLoc();
+      break;
+    }
+    }
+
     if (auto parentScope = findStartingScopeForLookup(enclosingSF, parentLoc)) {
       parentAndWasExpanded.setPointer(const_cast<ASTScopeImpl *>(parentScope));
     }
diff --git a/lib/AST/ASTVerifier.cpp b/lib/AST/ASTVerifier.cpp
@@ -3654,12 +3654,13 @@ class Verifier : public ASTWalker {
     void checkSourceRanges(Decl *D) {
       PrettyStackTraceDecl debugStack("verifying ranges", D);
       const auto SR = D->getSourceRange();
+
+      // We don't care about source ranges on implicitly-generated
+      // decls.
+      if (D->isImplicit())
+        return;
+
       if (!SR.isValid()) {
-        // We don't care about source ranges on implicitly-generated
-        // decls.
-        if (D->isImplicit())
-          return;
-        
         Out << "invalid source range for decl: ";
         D->print(Out);
         Out << "\n";
diff --git a/lib/AST/Decl.cpp b/lib/AST/Decl.cpp
@@ -374,6 +374,28 @@ DeclAttributes Decl::getSemanticAttrs() const {
   return getAttrs();
 }
 
+void Decl::forEachAttachedMacro(MacroRole role,
+                                MacroCallback macroCallback) const {
+  auto *dc = getDeclContext();
+  auto &ctx = dc->getASTContext();
+
+  for (auto customAttrConst : getSemanticAttrs().getAttributes<CustomAttr>()) {
+    auto customAttr = const_cast<CustomAttr *>(customAttrConst);
+    auto *macroDecl = evaluateOrDefault(
+        ctx.evaluator,
+        ResolveAttachedMacroRequest{customAttr, dc},
+        nullptr);
+
+    if (!macroDecl)
+      continue;
+
+    if (!macroDecl->getMacroRoles().contains(role))
+      continue;
+
+    macroCallback(customAttr, macroDecl);
+  }
+}
+
 const Decl *Decl::getInnermostDeclWithAvailability() const {
   const Decl *enclosingDecl = this;
   // Find the innermost enclosing declaration with an @available annotation.
@@ -9703,6 +9725,9 @@ StringRef swift::getMacroRoleString(MacroRole role) {
 
   case MacroRole::MemberAttribute:
     return "memberAttributes";
+
+  case MacroRole::SynthesizedMembers:
+    return "synthesizedMembers";
   }
 }
 
@@ -9745,8 +9770,10 @@ static MacroRoles freestandingMacroRoles =
   (MacroRoles() |
    MacroRole::Expression |
    MacroRole::FreestandingDeclaration);
-static MacroRoles attachedMacroRoles = (MacroRoles() | MacroRole::Accessor |
-                                        MacroRole::MemberAttribute);
+static MacroRoles attachedMacroRoles = (MacroRoles() |
+                                        MacroRole::Accessor |
+                                        MacroRole::MemberAttribute |
+                                        MacroRole::SynthesizedMembers);
 
 bool swift::isFreestandingMacro(MacroRoles contexts) {
   return bool(contexts & freestandingMacroRoles);
diff --git a/lib/AST/DiagnosticEngine.cpp b/lib/AST/DiagnosticEngine.cpp
@@ -1314,7 +1314,8 @@ std::vector<Diagnostic> DiagnosticEngine::getGeneratedSourceBufferNotes(
     case GeneratedSourceInfo::ExpressionMacroExpansion:
     case GeneratedSourceInfo::FreestandingDeclMacroExpansion:
     case GeneratedSourceInfo::AccessorMacroExpansion:
-    case GeneratedSourceInfo::MemberAttributeMacroExpansion: {
+    case GeneratedSourceInfo::MemberAttributeMacroExpansion:
+    case GeneratedSourceInfo::SynthesizedMemberMacroExpansion: {
       SourceRange origRange = expansionNode.getSourceRange();
       DeclName macroName;
       if (auto customAttr = generatedInfo->attachedMacroCustomAttr) {
diff --git a/lib/AST/Module.cpp b/lib/AST/Module.cpp
@@ -896,6 +896,34 @@ CustomAttr *SourceFile::getAttachedMacroAttribute() const {
   return genInfo.attachedMacroCustomAttr;
 }
 
+Optional<MacroRole> SourceFile::getFulfilledMacroRole() const {
+  if (Kind != SourceFileKind::MacroExpansion)
+    return None;
+
+  auto genInfo =
+      *getASTContext().SourceMgr.getGeneratedSourceInfo(*getBufferID());
+  switch (genInfo.kind) {
+  case GeneratedSourceInfo::ExpressionMacroExpansion:
+    return MacroRole::Expression;
+
+  case GeneratedSourceInfo::FreestandingDeclMacroExpansion:
+    return MacroRole::FreestandingDeclaration;
+
+  case GeneratedSourceInfo::AccessorMacroExpansion:
+    return MacroRole::Accessor;
+
+  case GeneratedSourceInfo::MemberAttributeMacroExpansion:
+    return MacroRole::MemberAttribute;
+
+  case GeneratedSourceInfo::SynthesizedMemberMacroExpansion:
+    return MacroRole::SynthesizedMembers;
+
+  case GeneratedSourceInfo::ReplacedFunctionBody:
+  case GeneratedSourceInfo::PrettyPrinted:
+    return None;
+  }
+}
+
 SourceFile *SourceFile::getEnclosingSourceFile() const {
   auto macroExpansion = getMacroExpansion();
   if (!macroExpansion)
diff --git a/lib/ASTGen/Sources/ASTGen/Macros.swift b/lib/ASTGen/Sources/ASTGen/Macros.swift
@@ -31,6 +31,14 @@ struct ExportedMacro {
   var macro: Macro.Type
 }
 
+enum MacroRole: UInt8 {
+  case Expression = 0x01
+  case FreestandingDeclaration = 0x02
+  case Accessor = 0x04
+  case MemberAttribute = 0x08
+  case SynthesizedMembers = 0x10
+}
+
 /// Resolve a reference to type metadata into a macro, if posible.
 ///
 /// Returns an unmanaged pointer to an ExportedMacro instance that describes
@@ -262,6 +270,7 @@ private func findSyntaxNodeInSourceFile<Node: SyntaxProtocol>(
 func expandAttachedMacro(
   diagEnginePtr: UnsafeMutablePointer<UInt8>,
   macroPtr: UnsafeRawPointer,
+  rawMacroRole: UInt8,
   customAttrSourceFilePtr: UnsafeRawPointer,
   customAttrSourceLocPointer: UnsafePointer<UInt8>?,
   declarationSourceFilePtr: UnsafeRawPointer,
@@ -297,6 +306,7 @@ func expandAttachedMacro(
   // Get the macro.
   let macroPtr = macroPtr.bindMemory(to: ExportedMacro.self, capacity: 1)
   let macro = macroPtr.pointee.macro
+  let macroRole = MacroRole(rawValue: rawMacroRole)
 
   // FIXME: Which source file? I don't know! This should go.
   let declarationSourceFilePtr = declarationSourceFilePtr.bindMemory(
@@ -310,8 +320,8 @@ func expandAttachedMacro(
 
   var evaluatedSyntaxStr: String
   do {
-    switch macro {
-    case let attachedMacro as AccessorDeclarationMacro.Type:
+    switch (macro, macroRole) {
+    case (let attachedMacro as AccessorDeclarationMacro.Type, .Accessor):
       let accessors = try attachedMacro.expansion(
         of: customAttrNode, attachedTo: declarationNode, in: &context
       )
@@ -321,7 +331,7 @@ func expandAttachedMacro(
         $0.withoutTrivia().description
       }.joined(separator: "\n\n")
 
-    case let attachedMacro as MemberAttributeMacro.Type:
+    case (let attachedMacro as MemberAttributeMacro.Type, .MemberAttribute):
       // Dig out the node for the parent declaration of the to-expand
       // declaration. Only member attribute macros need this.
       guard let parentDeclNode = findSyntaxNodeInSourceFile(
@@ -344,6 +354,18 @@ func expandAttachedMacro(
         $0.withoutTrivia().description
       }.joined(separator: " ")
 
+    case (let attachedMacro as MemberDeclarationMacro.Type, .SynthesizedMembers):
+      let members = try attachedMacro.expansion(
+        of: customAttrNode,
+        attachedTo: declarationNode,
+        in: &context
+      )
+
+      // Form a buffer of member declarations to return to the caller.
+      evaluatedSyntaxStr = members.map {
+        $0.withoutTrivia().description
+      }.joined(separator: "\n\n")
+
     default:
       print("\(macroPtr) does not conform to any known attached macro protocol")
       return 1
diff --git a/lib/Basic/SourceLoc.cpp b/lib/Basic/SourceLoc.cpp
@@ -314,6 +314,7 @@ void SourceManager::setGeneratedSourceInfo(
   case GeneratedSourceInfo::FreestandingDeclMacroExpansion:
   case GeneratedSourceInfo::AccessorMacroExpansion:
   case GeneratedSourceInfo::MemberAttributeMacroExpansion:
+  case GeneratedSourceInfo::SynthesizedMemberMacroExpansion:
   case GeneratedSourceInfo::PrettyPrinted:
     break;
 
diff --git a/lib/Parse/ParseDecl.cpp b/lib/Parse/ParseDecl.cpp
@@ -2225,6 +2225,7 @@ static Optional<MacroRole> getMacroRole(
       .Case("expression", MacroRole::Expression)
       .Case("accessor", MacroRole::Accessor)
       .Case("memberAttributes", MacroRole::MemberAttribute)
+      .Case("synthesizedMembers", MacroRole::SynthesizedMembers)
       .Default(None);
 
   if (!role) {
diff --git a/lib/Parse/ParseRequests.cpp b/lib/Parse/ParseRequests.cpp
@@ -174,6 +174,7 @@ SourceFileParsingResult ParseSourceFileRequest::evaluate(Evaluator &evaluator,
     switch (generatedInfo->kind) {
     case GeneratedSourceInfo::FreestandingDeclMacroExpansion:
     case GeneratedSourceInfo::ExpressionMacroExpansion:
+    case GeneratedSourceInfo::SynthesizedMemberMacroExpansion:
     case GeneratedSourceInfo::ReplacedFunctionBody:
     case GeneratedSourceInfo::PrettyPrinted: {
       parser.parseTopLevelItems(items);
diff --git a/lib/Sema/TypeCheckDecl.cpp b/lib/Sema/TypeCheckDecl.cpp
@@ -2792,6 +2792,13 @@ static ArrayRef<Decl *> evaluateMembersRequest(
     }
   }
 
+  // Expand synthesized member macros.
+  auto *mutableDecl = const_cast<Decl *>(idc->getDecl());
+  (void)evaluateOrDefault(
+      ctx.evaluator,
+      ExpandSynthesizedMemberMacroRequest{mutableDecl},
+      false);
+
   // If the decl has a @main attribute, we need to force synthesis of the
   // $main function.
   (void) evaluateOrDefault(
diff --git a/lib/Sema/TypeCheckMacros.cpp b/lib/Sema/TypeCheckMacros.cpp
diff --git a/lib/Sema/TypeCheckMacros.h b/lib/Sema/TypeCheckMacros.h
diff --git a/lib/Sema/TypeCheckStorage.cpp b/lib/Sema/TypeCheckStorage.cpp
diff --git a/lib/Serialization/ModuleFormat.h b/lib/Serialization/ModuleFormat.h
diff --git a/lib/Serialization/Serialization.cpp b/lib/Serialization/Serialization.cpp
diff --git a/test/Macros/Inputs/syntax_macro_definitions.swift b/test/Macros/Inputs/syntax_macro_definitions.swift
diff --git a/test/Macros/composed_macro.swift b/test/Macros/composed_macro.swift
diff --git a/test/Macros/macro_expand_synthesized_members.swift b/test/Macros/macro_expand_synthesized_members.swift
