Merge pull request #63039 from hborla/attribute-macros

[Macros] Implement attached macros that generate member attributes.

Author: hborla

include/swift/AST/Attr.h

@@ -2369,6 +2369,18 @@ class AttachedAttr final
   }
 };
 
+/// Predicate used to filter MatchingAttributeRange.
+template <typename ATTR, bool AllowInvalid> struct ToAttributeKind {
+  ToAttributeKind() {}
+
+  Optional<const ATTR *>
+  operator()(const DeclAttribute *Attr) const {
+    if (isa<ATTR>(Attr) && (Attr->isValid() || AllowInvalid))
+      return cast<ATTR>(Attr);
+    return None;
+  }
+};
+
 /// Attributes that may be applied to declarations.
 class DeclAttributes {
   /// Linked list of declaration attributes.
@@ -2542,19 +2554,6 @@ class DeclAttributes {
          const_cast<const DeclAttributes *>(this)->getEffectiveSendableAttr());
   }
 
-private:
-  /// Predicate used to filter MatchingAttributeRange.
-  template <typename ATTR, bool AllowInvalid> struct ToAttributeKind {
-    ToAttributeKind() {}
-
-    Optional<const ATTR *>
-    operator()(const DeclAttribute *Attr) const {
-      if (isa<ATTR>(Attr) && (Attr->isValid() || AllowInvalid))
-        return cast<ATTR>(Attr);
-      return None;
-    }
-  };
-
 public:
   template <typename ATTR, bool AllowInvalid>
   using AttributeKindRange =
@@ -2610,6 +2609,55 @@ class DeclAttributes {
   SourceLoc getStartLoc(bool forModifiers = false) const;
 };
 
+/// Semantic attributes that are applied to a declaration.
+///
+/// This attribute list can include attributes that are not written in
+/// source on a declaration, such as attributes that are applied during
+/// macro expansion or inferred from the declaration context.
+class SemanticDeclAttributes {
+  llvm::SmallVector<DeclAttribute *, 4> attrList;
+
+public:
+  SemanticDeclAttributes() {}
+
+  /// Add a constructed DeclAttribute to this list.
+  void add(DeclAttribute *attr) {
+    attrList.push_back(attr);
+  }
+
+  using SemanticAttrList = llvm::SmallVectorImpl<DeclAttribute *>;
+
+  template <typename AttrType, bool AllowInvalid>
+  using AttributeKindRange =
+      OptionalTransformRange<iterator_range<SemanticAttrList::const_iterator>,
+                             ToAttributeKind<AttrType, AllowInvalid>,
+                             SemanticAttrList::const_iterator>;
+
+  template <typename AttrType, bool AllowInvalid = false>
+  AttributeKindRange<AttrType, AllowInvalid> getAttributes() const {
+    return AttributeKindRange<AttrType, AllowInvalid>(
+        make_range(attrList.begin(), attrList.end()),
+                   ToAttributeKind<AttrType, AllowInvalid>());
+  }
+
+  /// Retrieve the first attribute of the given attribute class.
+  template <typename AttrType>
+  const AttrType *getAttribute(bool allowInvalid = false) const {
+    for (auto attr : attrList)
+      if (auto *specificAttr = dyn_cast<AttrType>(attr))
+        if (specificAttr->isValid() || allowInvalid)
+          return specificAttr;
+
+    return nullptr;
+  }
+
+  /// Determine whether there is an attribute with the given attribute class.
+  template <typename AttrType>
+  bool hasAttribute(bool allowInvalid = false) const {
+    return getAttribute<AttrType>(allowInvalid) != nullptr;
+  }
+};
+
 /// TypeAttributes - These are attributes that may be applied to types.
 class TypeAttributes {
   // Get a SourceLoc for every possible attribute that can be parsed in source.

include/swift/AST/Decl.h

@@ -191,6 +191,7 @@ enum class DescriptiveDeclKind : uint8_t {
   DidSet,
   EnumElement,
   Module,
+  Missing,
   MissingMember,
   Requirement,
   OpaqueResultType,
@@ -849,6 +850,12 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl> {
     return Attrs;
   }
 
+  /// Returns the semantic attributes attached to this declaration.
+  ///
+  /// \c getSemanticAttrs is intended to be a requestified replacement
+  /// for \c getAttrs
+  SemanticDeclAttributes getSemanticAttrs() const;
+
   /// Returns the innermost enclosing decl with an availability annotation.
   const Decl *getInnermostDeclWithAvailability() const;
 
@@ -8276,6 +8283,34 @@ class PostfixOperatorDecl : public OperatorDecl {
   }
 };
 
+/// Represents a missing declaration in the source code. This
+/// is used for parser recovery, e.g. when parsing a floating
+/// attribute list.
+class MissingDecl: public Decl {
+  MissingDecl(DeclContext *DC) : Decl(DeclKind::Missing, DC) {
+    setImplicit();
+  }
+
+  friend class Decl;
+  SourceLoc getLocFromSource() const {
+    return SourceLoc();
+  }
+
+public:
+  static MissingDecl *
+  create(ASTContext &ctx, DeclContext *DC) {
+    return new (ctx) MissingDecl(DC);
+  }
+
+  SourceRange getSourceRange() const {
+    return SourceRange();
+  }
+
+  static bool classof(const Decl *D) {
+    return D->getKind() == DeclKind::Missing;
+  }
+};
+
 /// Represents a hole where a declaration should have been.
 ///
 /// Among other things, these are used to keep vtable layout consistent.

include/swift/AST/DeclNodes.def

@@ -181,6 +181,7 @@ DECL(Import, Decl)
 DECL(IfConfig, Decl)
 DECL(PoundDiagnostic, Decl)
 DECL(PrecedenceGroup, Decl)
+DECL(Missing, Decl)
 DECL(MissingMember, Decl)
 DECL(PatternBinding, Decl)
 DECL(EnumCase, Decl)

include/swift/AST/DiagnosticsParse.def

@@ -2044,6 +2044,10 @@ ERROR(macro_attribute_introduced_name_requires_argument,PointsToFirstBadToken,
 ERROR(macro_attribute_introduced_name_requires_no_argument,PointsToFirstBadToken,
       "introduced name kind %0 must not have an argument", (Identifier))
 
+ERROR(unexpected_attribute_expansion,PointsToFirstBadToken,
+      "unexpected token '%0' in expanded attribute list'",
+      (StringRef))
+
 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

@@ -32,6 +32,9 @@ enum class MacroRole: uint32_t {
   /// An attached macro that declares accessors for a variable or subscript
   /// declaration.
   Accessor = 0x04,
+  /// An attached macro that generates attributes for the
+  /// members inside the declaration.
+  MemberAttribute = 0x08,
 };
 
 /// The contexts in which a particular macro declaration can be used.

include/swift/AST/SourceFile.h

@@ -500,6 +500,17 @@ class SourceFile final : public FileUnit {
   /// the \c SourceFileKind is \c MacroExpansion.
   ASTNode getMacroExpansion() const;
 
+  /// For source files created to hold the source code created by expanding
+  /// an attached macro, this is the custom attribute that describes the macro
+  /// expansion.
+  ///
+  /// The source location of this attribute is the place in the source that
+  /// triggered the creation of the macro expansion whose resulting source
+  /// code is in this source file. This will only produce a non-null value when
+  /// the \c SourceFileKind is \c MacroExpansion , and the macro is an attached
+  /// macro.
+  CustomAttr *getAttachedMacroAttribute() 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.

include/swift/AST/TypeCheckRequests.h

@@ -742,6 +742,26 @@ class AttachedPropertyWrappersRequest :
   bool isCached() const { return true; }
 };
 
+/// Request the semantic attributes attached to the given declaration.
+class AttachedSemanticAttrsRequest :
+    public SimpleRequest<AttachedSemanticAttrsRequest,
+                         SemanticDeclAttributes(Decl *),
+                         RequestFlags::Cached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  // Evaluation.
+  SemanticDeclAttributes
+  evaluate(Evaluator &evaluator, Decl *decl) const;
+
+public:
+  // Caching
+  bool isCached() const { return true; }
+};
+
 /// Request the raw (possibly unbound generic) type of the property wrapper
 /// that is attached to the given variable.
 class AttachedPropertyWrapperTypeRequest :

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -29,6 +29,9 @@ SWIFT_REQUEST(TypeChecker, AttachedPropertyWrapperTypeRequest,
 SWIFT_REQUEST(TypeChecker, AttachedPropertyWrappersRequest,
               llvm::TinyPtrVector<CustomAttr *>(VarDecl *), Cached,
               NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, AttachedSemanticAttrsRequest,
+              SemanticDeclAttributes(Decl *), Cached,
+              NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, CallerSideDefaultArgExprRequest,
               Expr *(DefaultArgumentExpr *), SeparatelyCached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, CheckInconsistentImplementationOnlyImportsRequest,

include/swift/Basic/SourceManager.h

@@ -32,8 +32,17 @@ class GeneratedSourceInfo {
 public:
   /// The kind of generated source code.
   enum Kind {
-    /// The expansion of a macro.
-    MacroExpansion,
+    /// The expansion of a freestanding expression macro.
+    ExpressionMacroExpansion,
+
+    /// The expansion of a freestanding declaration macro.
+    FreestandingDeclMacroExpansion,
+
+    /// The expansion of an accessor attached macro.
+    AccessorMacroExpansion,
+
+    /// The expansion of a member attribute attached macro.
+    MemberAttributeMacroExpansion,
 
     /// A new function body that is replacing an existing function body.
     ReplacedFunctionBody,

include/swift/Parse/Parser.h

@@ -903,6 +903,11 @@ class Parser {
   /// Each item will be a declaration, statement, or expression.
   void parseTopLevelItems(SmallVectorImpl<ASTNode> &items);
 
+  /// Parse the source file via the Swift Parser using the ASTGen library.
+  void parseSourceFileViaASTGen(SmallVectorImpl<ASTNode> &items,
+                                Optional<DiagnosticTransaction> &transaction,
+                                bool suppressDiagnostics = false);
+
   /// Parse the top-level SIL decls into the SIL module.
   /// \returns \c true if there was a parsing error.
   bool parseTopLevelSIL();
@@ -1225,6 +1230,13 @@ class Parser {
       AbstractStorageDecl *storage, SmallVectorImpl<ASTNode> &items
   );
 
+  /// Parse the result of attribute macro expansion, which is a floating
+  /// attribute list.
+  ///
+  /// Parsing a floating attribute list will produce a `MissingDecl` with
+  /// the attribute list attached.
+  void parseExpandedAttributeList(SmallVectorImpl<ASTNode> &items);
+
   ParserResult<FuncDecl> parseDeclFunc(SourceLoc StaticLoc,
                                        StaticSpellingKind StaticSpelling,
                                        ParseDeclOptions Flags,