[Macros] Introduce the @attached attribute for declaring attached macros.

Describe attached macros with the `@attached` attribute, providing the
macro role and affected names as arguments to the macro. The form of
this macro will remain the same as it gains other kinds of attached
macro roles beyond "accessor".

Remove the "accessors" role from `@declaration`, which will be going
away.

Author: DougGregor

include/swift/AST/Attr.h

@@ -2308,17 +2308,17 @@ class DeclarationAttr final
       private llvm::TrailingObjects<DeclarationAttr, MacroIntroducedDeclName> {
   friend TrailingObjects;
 
-  MacroContext macroContext;
+  MacroRole role;
   unsigned numPeerNames, numMemberNames;
 
-  DeclarationAttr(SourceLoc atLoc, SourceRange range, MacroContext macroContext,
+  DeclarationAttr(SourceLoc atLoc, SourceRange range, MacroRole role,
                   ArrayRef<MacroIntroducedDeclName> peerNames,
                   ArrayRef<MacroIntroducedDeclName> memberNames,
                   bool implicit);
 
 public:
   static DeclarationAttr *create(ASTContext &ctx, SourceLoc atLoc,
-                                 SourceRange range, MacroContext macroContext,
+                                 SourceRange range, MacroRole role,
                                  ArrayRef<MacroIntroducedDeclName> peerNames,
                                  ArrayRef<MacroIntroducedDeclName> memberNames,
                                  bool implicit);
@@ -2327,7 +2327,7 @@ class DeclarationAttr final
     return numPeerNames + numMemberNames;
   }
 
-  MacroContext getMacroContext() const { return macroContext; }
+  MacroRole getMacroRole() const { return role; }
   ArrayRef<MacroIntroducedDeclName> getPeerAndMemberNames() const;
   ArrayRef<MacroIntroducedDeclName> getPeerNames() const;
   ArrayRef<MacroIntroducedDeclName> getMemberNames() const;
@@ -2337,6 +2337,38 @@ class DeclarationAttr final
   }
 };
 
+/// The @attached attribute, which declares that a given macro can be
+/// "attached" as an attribute to declarations.
+class AttachedAttr final
+    : public DeclAttribute,
+      private llvm::TrailingObjects<AttachedAttr, MacroIntroducedDeclName> {
+  friend TrailingObjects;
+
+  MacroRole role;
+  unsigned numNames;
+
+  AttachedAttr(SourceLoc atLoc, SourceRange range, MacroRole role,
+               ArrayRef<MacroIntroducedDeclName> names,
+               bool implicit);
+
+public:
+  static AttachedAttr *create(ASTContext &ctx, SourceLoc atLoc,
+                              SourceRange range, MacroRole role,
+                              ArrayRef<MacroIntroducedDeclName> names,
+                              bool implicit);
+
+  size_t numTrailingObjects(OverloadToken<MacroIntroducedDeclName>) const {
+    return numNames;
+  }
+
+  MacroRole getMacroRole() const { return role; }
+  ArrayRef<MacroIntroducedDeclName> getNames() const;
+
+  static bool classof(const DeclAttribute *DA) {
+    return DA->getKind() == DAK_Attached;
+  }
+};
+
 /// Attributes that may be applied to declarations.
 class DeclAttributes {
   /// Linked list of declaration attributes.

include/swift/AST/Decl.h

@@ -8372,7 +8372,7 @@ class MacroDecl : public GenericContext, public ValueDecl {
   Type getResultInterfaceType() const;
 
   /// Determine the contexts in which this macro can be applied.
-  MacroContexts getMacroContexts() const;
+  MacroRoles getMacroRoles() const;
 
   /// Retrieve the definition of this macro.
   MacroDefinition getDefinition() const;

include/swift/AST/DiagnosticsParse.def

@@ -2020,6 +2020,30 @@ ERROR(macro_expansion_decl_expected_macro_identifier,PointsToFirstBadToken,
 ERROR(declaration_attr_expected_kind,PointsToFirstBadToken,
       "expected a declaration macro kind ('freestanding' or 'attached')", ())
 
+ERROR(macro_role_attr_expected_kind,PointsToFirstBadToken,
+      "expected %select{a freestanding|an attached}0 macro role such as "
+      "%select{'expression'|'accessor'}0", (bool))
+ERROR(macro_role_syntax_mismatch,PointsToFirstBadToken,
+      "expected %select{a freestanding|an attached}0 macro cannot have "
+      "the %1 role", (bool, Identifier))
+ERROR(macro_attribute_unknown_label,PointsToFirstBadToken,
+      "@%select{freestanding|attached}0 has no argument with label %1",
+      (bool, Identifier))
+ERROR(macro_attribute_duplicate_label,PointsToFirstBadToken,
+      "@%select{freestanding|attached}0 already has an argument with "
+      "label %1", (bool, Identifier))
+ERROR(macro_attribute_missing_label,PointsToFirstBadToken,
+      "@%select{freestanding|attached}0 argument is missing label '%1'",
+      (bool, StringRef))
+ERROR(macro_attribute_unknown_name_kind,PointsToFirstBadToken,
+      "unknown introduced name kind %0", (Identifier))
+ERROR(macro_attribute_unknown_argument_form,PointsToFirstBadToken,
+      "introduced name argument should be an identifier", ())
+ERROR(macro_attribute_introduced_name_requires_argument,PointsToFirstBadToken,
+      "introduced name kind %0 requires a single argument '(name)'", (Identifier))
+ERROR(macro_attribute_introduced_name_requires_no_argument,PointsToFirstBadToken,
+      "introduced name kind %0 must not have an argument", (Identifier))
+
 ERROR(parser_round_trip_error,none,
       "source file did not round-trip through the new Swift parser", ())
 ERROR(parser_new_parser_errors,none,

include/swift/AST/MacroDeclaration.h

@@ -23,23 +23,31 @@ namespace swift {
 
 /// The context in which a macro can be used, which determines the syntax it
 /// uses.
-enum class MacroContext: uint8_t {
+enum class MacroRole: uint32_t {
   /// An expression macro, referenced explicitly via "#stringify" or similar
   /// in the source code.
   Expression = 0x01,
   /// A freestanding declaration macro.
   FreestandingDeclaration = 0x02,
-  /// An attached declaration macro.
-  AttachedDeclaration = 0x04,
+  /// An attached macro that declares accessors for a variable or subscript
+  /// declaration.
+  Accessor = 0x04,
 };
 
 /// The contexts in which a particular macro declaration can be used.
-using MacroContexts = OptionSet<MacroContext>;
+using MacroRoles = OptionSet<MacroRole>;
+
+/// Whether a macro with the given set of macro contexts is freestanding, i.e.,
+/// written in the source code with the `#` syntax.
+bool isFreestandingMacro(MacroRoles contexts);
+
+/// Whether a macro with the given set of macro contexts is attached, i.e.,
+/// written in the source code as an attribute with the `@` syntax.
+bool isAttachedMacro(MacroRoles contexts);
 
 enum class MacroIntroducedDeclNameKind {
   Named,
   Overloaded,
-  Accessors,
   Prefixed,
   Suffixed,
   Arbitrary,
@@ -65,10 +73,6 @@ class MacroIntroducedDeclName {
     return MacroIntroducedDeclName(Kind::Overloaded);
   }
 
-  static MacroIntroducedDeclName getAccessors() {
-    return MacroIntroducedDeclName(Kind::Accessors);
-  }
-
   static MacroIntroducedDeclName getPrefixed(Identifier prefix) {
     return MacroIntroducedDeclName(Kind::Prefixed, prefix);
   }

include/swift/Parse/Parser.h

@@ -1100,6 +1100,10 @@ class Parser {
   ParserResult<DeclarationAttr> parseDeclarationAttribute(SourceLoc AtLoc,
                                                           SourceLoc Loc);
 
+  /// Parse the @attached attribute.
+  ParserResult<AttachedAttr> parseAttachedAttribute(SourceLoc AtLoc,
+                                                    SourceLoc Loc);
+
   /// Parse a specific attribute.
   ParserStatus parseDeclAttribute(DeclAttributes &Attributes, SourceLoc AtLoc,
                                   PatternBindingInitializer *&initContext,

lib/AST/Attr.cpp

@@ -1485,6 +1485,8 @@ StringRef DeclAttribute::getAttrName() const {
     return "_documentation";
   case DAK_Declaration:
     return "declaration";
+  case DAK_Attached:
+    return "attached";
   }
   llvm_unreachable("bad DeclAttrKind");
 }
@@ -2311,12 +2313,12 @@ bool CustomAttr::isArgUnsafe() const {
 }
 
 DeclarationAttr::DeclarationAttr(SourceLoc atLoc, SourceRange range,
-                                 MacroContext macroContext,
+                                 MacroRole role,
                                  ArrayRef<MacroIntroducedDeclName> peerNames,
                                  ArrayRef<MacroIntroducedDeclName> memberNames,
                                  bool implicit)
     : DeclAttribute(DAK_Declaration, atLoc, range, implicit),
-      macroContext(macroContext), numPeerNames(peerNames.size()),
+      role(role), numPeerNames(peerNames.size()),
       numMemberNames(memberNames.size()) {
   auto *trailingNamesBuffer = getTrailingObjects<MacroIntroducedDeclName>();
   std::uninitialized_copy(peerNames.begin(), peerNames.end(),
@@ -2327,14 +2329,14 @@ DeclarationAttr::DeclarationAttr(SourceLoc atLoc, SourceRange range,
 
 DeclarationAttr *
 DeclarationAttr::create(ASTContext &ctx, SourceLoc atLoc, SourceRange range,
-                        MacroContext macroContext,
+                        MacroRole role,
                         ArrayRef<MacroIntroducedDeclName> peerNames,
                         ArrayRef<MacroIntroducedDeclName> memberNames,
                         bool implicit) {
   unsigned size = totalSizeToAlloc<MacroIntroducedDeclName>(
       peerNames.size() + memberNames.size());
   auto *mem = ctx.Allocate(size, alignof(DeclarationAttr));
-  return new (mem) DeclarationAttr(atLoc, range, macroContext, peerNames,
+  return new (mem) DeclarationAttr(atLoc, range, role, peerNames,
                                    memberNames, implicit);
 }
 
@@ -2356,6 +2358,34 @@ ArrayRef<MacroIntroducedDeclName> DeclarationAttr::getMemberNames() const {
   };
 }
 
+AttachedAttr::AttachedAttr(SourceLoc atLoc, SourceRange range,
+                           MacroRole role,
+                           ArrayRef<MacroIntroducedDeclName> names,
+                           bool implicit)
+    : DeclAttribute(DAK_Attached, atLoc, range, implicit),
+      role(role), numNames(names.size()) {
+  auto *trailingNamesBuffer = getTrailingObjects<MacroIntroducedDeclName>();
+  std::uninitialized_copy(names.begin(), names.end(), trailingNamesBuffer);
+}
+
+AttachedAttr *
+AttachedAttr::create(ASTContext &ctx, SourceLoc atLoc, SourceRange range,
+                     MacroRole role,
+                     ArrayRef<MacroIntroducedDeclName> names,
+                     bool implicit) {
+  unsigned size = totalSizeToAlloc<MacroIntroducedDeclName>(names.size());
+  auto *mem = ctx.Allocate(size, alignof(AttachedAttr));
+  return new (mem) AttachedAttr(atLoc, range, role, names, implicit);
+}
+
+ArrayRef<MacroIntroducedDeclName> AttachedAttr::getNames() const {
+  return {
+    getTrailingObjects<MacroIntroducedDeclName>(),
+    numNames
+  };
+}
+
+
 const DeclAttribute *
 DeclAttributes::getEffectiveSendableAttr() const {
   const NonSendableAttr *assumedAttr = nullptr;

lib/AST/Decl.cpp

@@ -9672,6 +9672,20 @@ BuiltinTupleDecl::BuiltinTupleDecl(Identifier Name, DeclContext *Parent)
     : NominalTypeDecl(DeclKind::BuiltinTuple, Parent, Name, SourceLoc(),
                       ArrayRef<InheritedEntry>(), nullptr) {}
 
+static MacroRoles freestandingMacroRoles =
+  (MacroRoles() |
+   MacroRole::Expression |
+   MacroRole::FreestandingDeclaration);
+static MacroRoles attachedMacroRoles = (MacroRoles() | MacroRole::Accessor);
+
+bool swift::isFreestandingMacro(MacroRoles contexts) {
+  return bool(contexts & freestandingMacroRoles);
+}
+
+bool swift::isAttachedMacro(MacroRoles contexts) {
+  return bool(contexts & attachedMacroRoles);
+}
+
 MacroDecl::MacroDecl(
     SourceLoc macroLoc, DeclName name, SourceLoc nameLoc,
     GenericParamList *genericParams,
@@ -9712,12 +9726,14 @@ SourceRange MacroDecl::getSourceRange() const {
   return SourceRange(macroLoc, endLoc);
 }
 
-MacroContexts MacroDecl::getMacroContexts() const {
-  MacroContexts contexts = None;
+MacroRoles MacroDecl::getMacroRoles() const {
+  MacroRoles contexts = None;
   if (getAttrs().hasAttribute<ExpressionAttr>())
-    contexts |= MacroContext::Expression;
+    contexts |= MacroRole::Expression;
   for (auto attr : getAttrs().getAttributes<DeclarationAttr>())
-    contexts |= attr->getMacroContext();
+    contexts |= attr->getMacroRole();
+  for (auto attr : getAttrs().getAttributes<AttachedAttr>())
+    contexts |= attr->getMacroRole();
   return contexts;
 }
 

lib/AST/NameLookup.cpp

@@ -3061,7 +3061,7 @@ static MacroDecl *findMacroForCustomAttr(CustomAttr *attr, DeclContext *dc) {
   for (const auto &result : lookup.allResults()) {
     // Only keep attached macros, which can be spelled as custom attributes.
     if (auto macro = dyn_cast<MacroDecl>(result.getValueDecl()))
-      if (macro->getMacroContexts().contains(MacroContext::AttachedDeclaration))
+      if (isAttachedMacro(macro->getMacroRoles()))
         macros.push_back(macro);
   }