[Attr] Allow ParsedAttr to be constructor for any Attribute

[jdoerfert]

Summary

ParsedAttr is used for clang attribute push/pop a utility that is
reusable in other contexts as well. This allows us to create "fake"
parsed attributes from other attributes, e.g., implicit ones.

[erichkeane]

I don't see anything glaring here, but I would love some better explanation as to the goal here. I don't see this used anywhere, the commit message is a bit underwhelming in its reasoning, and there is no test/etc showing why I would want this.

clang/include/clang/Sema/ParsedAttr.h

116

Can you update this comment?

[jdoerfert]

In D75210#1894370, @erichkeane wrote:

I don't see anything glaring here, but I would love some better explanation as to the goal here. I don't see this used anywhere, the commit message is a bit underwhelming in its reasoning, and there is no test/etc showing why I would want this.

Agreed. The followup "user" patch is going to be put on phab very soon. I did rush this one out because I saw D31337 land today. Wanted to make sure people see what I hope to achieve here.

The reason for this is omp begin/end declare variant which I implement via attribute push/pop. The idea of both are basically the same, attach some information (=Attribute) on all function (definitions) in the scope. I have a new function definition matcher and the rest of the logic basically done, some overloading work is still missing.

clang/include/clang/Sema/ParsedAttr.h

116

Will do.

[aaron.ballman]

I think this direction is reasonable to go with, but would prefer to land this with the code actually using this functionality (as there's not really a good way to test it, otherwise).

[jdoerfert]

In D75210#1898012, @aaron.ballman wrote:

I think this direction is reasonable to go with, but would prefer to land this with the code actually using this functionality (as there's not really a good way to test it, otherwise).

Agreed. I'll put the other patch as a dependence up soon and this only goes in if the other one does.

[jdoerfert]

Pass parsed attribute kind explicitly

[aaron.ballman]

LGTM aside from the issue with keeping the comment up to date from Erich (but please only land this once D75779 is approved, as that's what carries the testing load for this.

[jdoerfert]

The reason for this patch is not there anymore. I'm fine with postponing this patch until there is a user again, thoughts?

[aaron.ballman]

In D75210#1920206, @jdoerfert wrote:

The reason for this patch is not there anymore. I'm fine with postponing this patch until there is a user again, thoughts?

If we don't have a use for it currently, I think we should postpone it until there is a need.

[jdoerfert]

Code is good and usable but no users anymore. If anyone wants to pick this up, feel free!

clang/include/clang/Sema/ParsedAttr.h

 //======- ParsedAttr.h - Parsed attribute sets ------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines the ParsedAttr class, which is used to collect
 // parsed attributes.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_SEMA_ATTRIBUTELIST_H
 #define LLVM_CLANG_SEMA_ATTRIBUTELIST_H
 
+#include "clang/AST/Attr.h"
 #include "clang/Basic/AttrSubjectMatchRules.h"
 #include "clang/Basic/AttributeCommonInfo.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Sema/Ownership.h"
 #include "llvm/ADT/PointerUnion.h"
 #include "llvm/ADT/SmallVector.h"

 
 /// ParsedAttr - Represents a syntactic attribute.
 ///
 /// For a GNU attribute, there are four forms of this construct:
 ///
 /// 1: __attribute__(( const )). ParmName/Args/NumArgs will all be unused.
 /// 2: __attribute__(( mode(byte) )). ParmName used, Args/NumArgs unused.
 /// 3: __attribute__(( format(printf, 1, 2) )). ParmName/Args/NumArgs all used.
 /// 4: __attribute__(( aligned(16) )). ParmName is unused, Args/Num used.
 ///
 class ParsedAttr final
     : public AttributeCommonInfo,
-      private llvm::TrailingObjects<
-          ParsedAttr, ArgsUnion, detail::AvailabilityData,
-          detail::TypeTagForDatatypeData, ParsedType, detail::PropertyData> {
+      private llvm::TrailingObjects<ParsedAttr, ArgsUnion,
+                                    detail::AvailabilityData,
+                                    detail::TypeTagForDatatypeData, ParsedType,
+                                    detail::PropertyData, Attr *> {
   friend TrailingObjects;
 
   size_t numTrailingObjects(OverloadToken<ArgsUnion>) const { return NumArgs; }
   size_t numTrailingObjects(OverloadToken<detail::AvailabilityData>) const {
     return IsAvailability;
   }
   size_t
       numTrailingObjects(OverloadToken<detail::TypeTagForDatatypeData>) const {
     return IsTypeTagForDatatype;
   }
   size_t numTrailingObjects(OverloadToken<ParsedType>) const {
     return HasParsedType;
   }
   size_t numTrailingObjects(OverloadToken<detail::PropertyData>) const {
     return IsProperty;
   }
+  size_t numTrailingObjects(OverloadToken<Attr *>) const { return HasAttrPtr; }
 
 private:
   IdentifierInfo *MacroII = nullptr;
   SourceLocation MacroExpansionLoc;
   SourceLocation EllipsisLoc;
 
   /// The number of expression arguments this attribute has.
   /// The expressions themselves are stored after the object.
-  unsigned NumArgs : 16;
+  unsigned NumArgs : 15;
 
   /// True if already diagnosed as invalid.
   mutable unsigned Invalid : 1;
 
   /// True if this attribute was used as a type attribute.
   mutable unsigned UsedAsTypeAttr : 1;
 
   /// True if this has the extra information associated with an
   /// availability attribute.
   unsigned IsAvailability : 1;
 
   /// True if this has extra information associated with a
   /// type_tag_for_datatype attribute.
   unsigned IsTypeTagForDatatype : 1;
 
   /// True if this has extra information associated with a
   /// Microsoft __delcspec(property) attribute.
   unsigned IsProperty : 1;
 
   /// True if this has a ParsedType
   unsigned HasParsedType : 1;
 
+  /// True if this has an attribute pointer.
+  unsigned HasAttrPtr : 1;
+
   /// True if the processing cache is valid.
   mutable unsigned HasProcessingCache : 1;
 
   /// A cached value.
   mutable unsigned ProcessingCache : 8;
 
   /// True if the attribute is specified using '#pragma clang attribute'.
   mutable unsigned IsPragmaClangAttribute : 1;
ParsedAttr(IdentifierInfo *attrName, SourceRange attrRange,
              IdentifierInfo *scopeName, SourceLocation scopeLoc,
              ArgsUnion *args, unsigned numArgs, Syntax syntaxUsed,
              SourceLocation ellipsisLoc)
       : AttributeCommonInfo(attrName, scopeName, attrRange, scopeLoc,
                             syntaxUsed),
         EllipsisLoc(ellipsisLoc), NumArgs(numArgs), Invalid(false),
         UsedAsTypeAttr(false), IsAvailability(false),
         IsTypeTagForDatatype(false), IsProperty(false), HasParsedType(false),
-        HasProcessingCache(false), IsPragmaClangAttribute(false) {
+        HasAttrPtr(false), HasProcessingCache(false),
+        IsPragmaClangAttribute(false) {
     if (numArgs)
       memcpy(getArgsBuffer(), args, numArgs * sizeof(ArgsUnion));
   }
 
   /// Constructor for availability attributes.
   ParsedAttr(IdentifierInfo *attrName, SourceRange attrRange,
              IdentifierInfo *scopeName, SourceLocation scopeLoc,
              IdentifierLoc *Parm, const AvailabilityChange &introduced,
              const AvailabilityChange &deprecated,
              const AvailabilityChange &obsoleted, SourceLocation unavailable,
              const Expr *messageExpr, Syntax syntaxUsed, SourceLocation strict,
              const Expr *replacementExpr)
       : AttributeCommonInfo(attrName, scopeName, attrRange, scopeLoc,
                             syntaxUsed),
         NumArgs(1), Invalid(false), UsedAsTypeAttr(false), IsAvailability(true),
         IsTypeTagForDatatype(false), IsProperty(false), HasParsedType(false),
-        HasProcessingCache(false), IsPragmaClangAttribute(false),
-        UnavailableLoc(unavailable), MessageExpr(messageExpr) {
+        HasAttrPtr(false), HasProcessingCache(false),
+        IsPragmaClangAttribute(false), UnavailableLoc(unavailable),
+        MessageExpr(messageExpr) {
     ArgsUnion PVal(Parm);
     memcpy(getArgsBuffer(), &PVal, sizeof(ArgsUnion));
     new (getAvailabilityData()) detail::AvailabilityData(
         introduced, deprecated, obsoleted, strict, replacementExpr);
   }
 
   /// Constructor for objc_bridge_related attributes.
   ParsedAttr(IdentifierInfo *attrName, SourceRange attrRange,
              IdentifierInfo *scopeName, SourceLocation scopeLoc,
              IdentifierLoc *Parm1, IdentifierLoc *Parm2, IdentifierLoc *Parm3,
              Syntax syntaxUsed)
       : AttributeCommonInfo(attrName, scopeName, attrRange, scopeLoc,
                             syntaxUsed),
         NumArgs(3), Invalid(false), UsedAsTypeAttr(false),
         IsAvailability(false), IsTypeTagForDatatype(false), IsProperty(false),
-        HasParsedType(false), HasProcessingCache(false),
+        HasParsedType(false), HasAttrPtr(false), HasProcessingCache(false),
         IsPragmaClangAttribute(false) {
     ArgsUnion *Args = getArgsBuffer();
     Args[0] = Parm1;
     Args[1] = Parm2;
     Args[2] = Parm3;
   }
 
   /// Constructor for type_tag_for_datatype attribute.
   ParsedAttr(IdentifierInfo *attrName, SourceRange attrRange,
              IdentifierInfo *scopeName, SourceLocation scopeLoc,
              IdentifierLoc *ArgKind, ParsedType matchingCType,
              bool layoutCompatible, bool mustBeNull, Syntax syntaxUsed)
       : AttributeCommonInfo(attrName, scopeName, attrRange, scopeLoc,
                             syntaxUsed),
         NumArgs(1), Invalid(false), UsedAsTypeAttr(false),
         IsAvailability(false), IsTypeTagForDatatype(true), IsProperty(false),
-        HasParsedType(false), HasProcessingCache(false),
+        HasParsedType(false), HasAttrPtr(false), HasProcessingCache(false),
         IsPragmaClangAttribute(false) {
     ArgsUnion PVal(ArgKind);
     memcpy(getArgsBuffer(), &PVal, sizeof(ArgsUnion));
     detail::TypeTagForDatatypeData &ExtraData = getTypeTagForDatatypeDataSlot();
     new (&ExtraData.MatchingCType) ParsedType(matchingCType);
     ExtraData.LayoutCompatible = layoutCompatible;
     ExtraData.MustBeNull = mustBeNull;
   }
 
   /// Constructor for attributes with a single type argument.
   ParsedAttr(IdentifierInfo *attrName, SourceRange attrRange,
              IdentifierInfo *scopeName, SourceLocation scopeLoc,
              ParsedType typeArg, Syntax syntaxUsed)
       : AttributeCommonInfo(attrName, scopeName, attrRange, scopeLoc,
                             syntaxUsed),
         NumArgs(0), Invalid(false), UsedAsTypeAttr(false),
         IsAvailability(false), IsTypeTagForDatatype(false), IsProperty(false),
-        HasParsedType(true), HasProcessingCache(false),
+        HasParsedType(true), HasAttrPtr(false), HasProcessingCache(false),
         IsPragmaClangAttribute(false) {
     new (&getTypeBuffer()) ParsedType(typeArg);
   }
 
   /// Constructor for microsoft __declspec(property) attribute.
   ParsedAttr(IdentifierInfo *attrName, SourceRange attrRange,
              IdentifierInfo *scopeName, SourceLocation scopeLoc,
              IdentifierInfo *getterId, IdentifierInfo *setterId,
              Syntax syntaxUsed)
       : AttributeCommonInfo(attrName, scopeName, attrRange, scopeLoc,
                             syntaxUsed),
         NumArgs(0), Invalid(false), UsedAsTypeAttr(false),
         IsAvailability(false), IsTypeTagForDatatype(false), IsProperty(true),
-        HasParsedType(false), HasProcessingCache(false),
+        HasParsedType(false), HasAttrPtr(false), HasProcessingCache(false),
         IsPragmaClangAttribute(false) {
     new (&getPropertyDataBuffer()) detail::PropertyData(getterId, setterId);
   }
 
+  /// Constructor for attributes with a single non-parsed attribute pointer as
+  /// argument.
+  ParsedAttr(IdentifierInfo *attrName, SourceRange attrRange,
+             IdentifierInfo *scopeName, SourceLocation scopeLoc,
+             Attr *attrPtrArg, AttributeCommonInfo::Kind Kind,
+             Syntax syntaxUsed)
+      : AttributeCommonInfo(attrName, scopeName, attrRange, scopeLoc, Kind,
+                            syntaxUsed, SpellingNotCalculated),
+        NumArgs(0), Invalid(false), UsedAsTypeAttr(false),
+        IsAvailability(false), IsTypeTagForDatatype(false), IsProperty(false),
+        HasParsedType(false), HasAttrPtr(true), HasProcessingCache(false),
+        IsPragmaClangAttribute(false) {
+    new (&getAttrPtrBuffer())(Attr *)(attrPtrArg);
+  }
+
   /// Type tag information is stored immediately following the arguments, if
   /// any, at the end of the object.  They are mutually exclusive with
   /// availability slots.
   detail::TypeTagForDatatypeData &getTypeTagForDatatypeDataSlot() {
     return *getTrailingObjects<detail::TypeTagForDatatypeData>();
   }
   const detail::TypeTagForDatatypeData &getTypeTagForDatatypeDataSlot() const {
     return *getTrailingObjects<detail::TypeTagForDatatypeData>();
   }
 
   /// The type buffer immediately follows the object and are mutually exclusive
   /// with arguments.
   ParsedType &getTypeBuffer() { return *getTrailingObjects<ParsedType>(); }
   const ParsedType &getTypeBuffer() const {
     return *getTrailingObjects<ParsedType>();
   }
 
+  /// The attribute pointer immediately follows the object and are mutually
+  /// exclusive with arguments.
+  Attr *&getAttrPtrBuffer() { return *getTrailingObjects<Attr *>(); }
+  Attr *const &getAttrPtrBuffer() const {
+    return *getTrailingObjects<Attr *>();
+  }
+
   /// The property data immediately follows the object is is mutually exclusive
   /// with arguments.
   detail::PropertyData &getPropertyDataBuffer() {
     assert(IsProperty);
     return *getTrailingObjects<detail::PropertyData>();
   }
   const detail::PropertyData &getPropertyDataBuffer() const {
     assert(IsProperty);
     return *getTrailingObjects<detail::PropertyData>();
   }
 
   size_t allocated_size() const;
 
 public:
   ParsedAttr(const ParsedAttr &) = delete;
   ParsedAttr(ParsedAttr &&) = delete;
   ParsedAttr &operator=(const ParsedAttr &) = delete;
   ParsedAttr &operator=(ParsedAttr &&) = delete;
   ~ParsedAttr() = delete;
 
   void operator delete(void *) = delete;
 
   bool hasParsedType() const { return HasParsedType; }
 
+  bool hasAttrPtr() const { return HasAttrPtr; }
+
   /// Is this the Microsoft __declspec(property) attribute?
   bool isDeclspecPropertyAttribute() const  {
     return IsProperty;
   }
 
   bool isInvalid() const { return Invalid; }
   void setInvalid(bool b = true) const { Invalid = b; }
 
bool getMustBeNull() const {
     return getTypeTagForDatatypeDataSlot().MustBeNull;
   }
 
   const ParsedType &getTypeArg() const {
     assert(HasParsedType && "Not a type attribute");
     return getTypeBuffer();
   }
 
+  const Attr *getAttrPtr() const {
+    assert(hasAttrPtr() && "Not an attribute pointer attribute");
+    return getAttrPtrBuffer();
+  }
+
   IdentifierInfo *getPropertyDataGetter() const {
     assert(isDeclspecPropertyAttribute() &&
            "Not a __delcspec(property) attribute");
     return getPropertyDataBuffer().GetterId;
   }
 
   IdentifierInfo *getPropertyDataSetter() const {
     assert(isDeclspecPropertyAttribute() &&

 /// A factory, from which one makes pools, from which one creates
 /// individual attributes which are deallocated with the pool.
 ///
 /// Note that it's tolerably cheap to create and destroy one of
 /// these as long as you don't actually allocate anything in it.
 class AttributeFactory {
 public:
   enum {
-    AvailabilityAllocSize =
-        ParsedAttr::totalSizeToAlloc<ArgsUnion, detail::AvailabilityData,
-                                     detail::TypeTagForDatatypeData, ParsedType,
-                                     detail::PropertyData>(1, 1, 0, 0, 0),
-    TypeTagForDatatypeAllocSize =
-        ParsedAttr::totalSizeToAlloc<ArgsUnion, detail::AvailabilityData,
-                                     detail::TypeTagForDatatypeData, ParsedType,
-                                     detail::PropertyData>(1, 0, 1, 0, 0),
-    PropertyAllocSize =
-        ParsedAttr::totalSizeToAlloc<ArgsUnion, detail::AvailabilityData,
-                                     detail::TypeTagForDatatypeData, ParsedType,
-                                     detail::PropertyData>(0, 0, 0, 0, 1),
+    AvailabilityAllocSize = ParsedAttr::totalSizeToAlloc<
+        ArgsUnion, detail::AvailabilityData, detail::TypeTagForDatatypeData,
+        ParsedType, detail::PropertyData, Attr *>(1, 1, 0, 0, 0, 0),
+    TypeTagForDatatypeAllocSize = ParsedAttr::totalSizeToAlloc<
+        ArgsUnion, detail::AvailabilityData, detail::TypeTagForDatatypeData,
+        ParsedType, detail::PropertyData, Attr *>(1, 0, 1, 0, 0, 0),
+    PropertyAllocSize = ParsedAttr::totalSizeToAlloc<
+        ArgsUnion, detail::AvailabilityData, detail::TypeTagForDatatypeData,
+        ParsedType, detail::PropertyData, Attr *>(0, 0, 0, 0, 1, 0),
+    AttrPtrAllocSize = ParsedAttr::totalSizeToAlloc<
+        ArgsUnion, detail::AvailabilityData, detail::TypeTagForDatatypeData,
+        ParsedType, detail::PropertyData, Attr *>(0, 0, 0, 0, 0, 1),
   };
 
 private:
   enum {
     /// The number of free lists we want to be sure to support
     /// inline.  This is just enough that availability attributes
     /// don't surpass it.  It's actually very unlikely we'll see an
     /// attribute that needs more than that; on x86-64 you'd need 10
public:
   ParsedAttr *create(IdentifierInfo *attrName, SourceRange attrRange,
                      IdentifierInfo *scopeName, SourceLocation scopeLoc,
                      ArgsUnion *args, unsigned numArgs,
                      ParsedAttr::Syntax syntax,
                      SourceLocation ellipsisLoc = SourceLocation()) {
     size_t temp =
         ParsedAttr::totalSizeToAlloc<ArgsUnion, detail::AvailabilityData,
                                      detail::TypeTagForDatatypeData, ParsedType,
-                                     detail::PropertyData>(numArgs, 0, 0, 0, 0);
+                                     detail::PropertyData, Attr *>(numArgs, 0,
+                                                                   0, 0, 0, 0);
     (void)temp;
     void *memory = allocate(
         ParsedAttr::totalSizeToAlloc<ArgsUnion, detail::AvailabilityData,
                                      detail::TypeTagForDatatypeData, ParsedType,
-                                     detail::PropertyData>(numArgs, 0, 0, 0,
-                                                           0));
+                                     detail::PropertyData, Attr *>(numArgs, 0,
+                                                                   0, 0, 0, 0));
     return add(new (memory) ParsedAttr(attrName, attrRange, scopeName, scopeLoc,
                                        args, numArgs, syntax, ellipsisLoc));
   }
 
   ParsedAttr *create(IdentifierInfo *attrName, SourceRange attrRange,
                      IdentifierInfo *scopeName, SourceLocation scopeLoc,
                      IdentifierLoc *Param, const AvailabilityChange &introduced,
                      const AvailabilityChange &deprecated,
public:
 
   ParsedAttr *create(IdentifierInfo *attrName, SourceRange attrRange,
                      IdentifierInfo *scopeName, SourceLocation scopeLoc,
                      IdentifierLoc *Param1, IdentifierLoc *Param2,
                      IdentifierLoc *Param3, ParsedAttr::Syntax syntax) {
     void *memory = allocate(
         ParsedAttr::totalSizeToAlloc<ArgsUnion, detail::AvailabilityData,
                                      detail::TypeTagForDatatypeData, ParsedType,
-                                     detail::PropertyData>(3, 0, 0, 0, 0));
+                                     detail::PropertyData, Attr *>(3, 0, 0, 0,
+                                                                   0, 0));
     return add(new (memory) ParsedAttr(attrName, attrRange, scopeName, scopeLoc,
                                        Param1, Param2, Param3, syntax));
   }
 
   ParsedAttr *
   createTypeTagForDatatype(IdentifierInfo *attrName, SourceRange attrRange,
                            IdentifierInfo *scopeName, SourceLocation scopeLoc,
                            IdentifierLoc *argumentKind,
                            ParsedType matchingCType, bool layoutCompatible,
                            bool mustBeNull, ParsedAttr::Syntax syntax) {
     void *memory = allocate(AttributeFactory::TypeTagForDatatypeAllocSize);
     return add(new (memory) ParsedAttr(attrName, attrRange, scopeName, scopeLoc,
                                        argumentKind, matchingCType,
                                        layoutCompatible, mustBeNull, syntax));
   }
 
   ParsedAttr *createTypeAttribute(IdentifierInfo *attrName,
                                   SourceRange attrRange,
                                   IdentifierInfo *scopeName,
                                   SourceLocation scopeLoc, ParsedType typeArg,
                                   ParsedAttr::Syntax syntaxUsed) {
     void *memory = allocate(
         ParsedAttr::totalSizeToAlloc<ArgsUnion, detail::AvailabilityData,
                                      detail::TypeTagForDatatypeData, ParsedType,
-                                     detail::PropertyData>(0, 0, 0, 1, 0));
+                                     detail::PropertyData, Attr *>(0, 0, 0, 1,
+                                                                   0, 0));
     return add(new (memory) ParsedAttr(attrName, attrRange, scopeName, scopeLoc,
                                        typeArg, syntaxUsed));
   }
 
   ParsedAttr *
   createPropertyAttribute(IdentifierInfo *attrName, SourceRange attrRange,
                           IdentifierInfo *scopeName, SourceLocation scopeLoc,
                           IdentifierInfo *getterId, IdentifierInfo *setterId,
                           ParsedAttr::Syntax syntaxUsed) {
     void *memory = allocate(AttributeFactory::PropertyAllocSize);
     return add(new (memory) ParsedAttr(attrName, attrRange, scopeName, scopeLoc,
                                        getterId, setterId, syntaxUsed));
   }
+
+  ParsedAttr *createAttrPtrAttribute(IdentifierInfo *attrName,
+                                     SourceRange attrRange,
+                                     IdentifierInfo *scopeName,
+                                     SourceLocation scopeLoc, Attr *attrPtrArg,
+                                     AttributeCommonInfo::Kind Kind,
+                                     ParsedAttr::Syntax syntaxUsed) {
+    void *memory = allocate(AttributeFactory::AttrPtrAllocSize);
+    return add(new (memory) ParsedAttr(attrName, attrRange, scopeName, scopeLoc,
+                                       attrPtrArg, Kind, syntaxUsed));
+  }
 };
 
 class ParsedAttributesView {
   using VecTy = llvm::TinyPtrVector<ParsedAttr *>;
   using SizeType = decltype(std::declval<VecTy>().size());
 
 public:
   bool empty() const { return AttrList.empty(); }
addNewPropertyAttr(IdentifierInfo *attrName, SourceRange attrRange,
                      ParsedAttr::Syntax syntaxUsed) {
     ParsedAttr *attr =
         pool.createPropertyAttribute(attrName, attrRange, scopeName, scopeLoc,
                                      getterId, setterId, syntaxUsed);
     addAtEnd(attr);
     return attr;
   }
 
+  ParsedAttr *addNewAttrPtrAttr(IdentifierInfo *attrName, SourceRange attrRange,
+                                IdentifierInfo *scopeName,
+                                SourceLocation scopeLoc, Attr *attrPtrArg,
+                                AttributeCommonInfo::Kind Kind,
+                                ParsedAttr::Syntax syntaxUsed) {
+    ParsedAttr *attr = pool.createAttrPtrAttribute(
+        attrName, attrRange, scopeName, scopeLoc, attrPtrArg, Kind, syntaxUsed);
+    addAtEnd(attr);
+    return attr;
+  }
+
 private:
   mutable AttributePool pool;
 };
 
 /// These constants match the enumerated choices of
 /// err_attribute_argument_n_type and err_attribute_argument_type.
 enum AttributeArgumentNType {
   AANT_ArgumentIntOrBool,

clang/lib/Sema/ParsedAttr.cpp

size_t ParsedAttr::allocated_size() const {
   if (IsAvailability) return AttributeFactory::AvailabilityAllocSize;
   else if (IsTypeTagForDatatype)
     return AttributeFactory::TypeTagForDatatypeAllocSize;
   else if (IsProperty)
     return AttributeFactory::PropertyAllocSize;
   else if (HasParsedType)
     return totalSizeToAlloc<ArgsUnion, detail::AvailabilityData,
                             detail::TypeTagForDatatypeData, ParsedType,
-                            detail::PropertyData>(0, 0, 0, 1, 0);
+                            detail::PropertyData, Attr *>(0, 0, 0, 1, 0, 0);
   return totalSizeToAlloc<ArgsUnion, detail::AvailabilityData,
                           detail::TypeTagForDatatypeData, ParsedType,
-                          detail::PropertyData>(NumArgs, 0, 0, 0, 0);
+                          detail::PropertyData, Attr *>(NumArgs, 0, 0, 0, 0, 0);
 }
 
 AttributeFactory::AttributeFactory() {
   // Go ahead and configure all the inline capacity.  This is just a memset.
   FreeLists.resize(InlineFreeListsCapacity);
 }
 AttributeFactory::~AttributeFactory() = default;