Back to home page

EIC code displayed by LXR
 
 

    

Warning, /include/clang/AST/Attrs.inc is written in an unsupported language. File is not indexed. 

0001 /*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
0002 |*                                                                            *|
0003 |* Attribute classes' definitions                                             *|
0004 |*                                                                            *|
0005 |* Automatically generated file, do not edit!                                 *|
0006 |* From: Attr.td                                                              *|
0007 |*                                                                            *|
0008 \*===----------------------------------------------------------------------===*/
0009 
0010 #ifndef LLVM_CLANG_ATTR_CLASSES_INC
0011 #define LLVM_CLANG_ATTR_CLASSES_INC
0012 static inline void DelimitAttributeArgument(raw_ostream& OS, bool& IsFirst) {
0013   if (IsFirst) {
0014     IsFirst = false;
0015     OS << "(";
0016   } else
0017     OS << ", ";
0018 }
0019 class CLANG_ABI AArch64SVEPcsAttr : public InheritableAttr {
0020 public:
0021   enum Spelling {
0022     GNU_aarch64_sve_pcs = 0,
0023     CXX11_clang_aarch64_sve_pcs = 1,
0024     C23_clang_aarch64_sve_pcs = 2,
0025   SpellingNotCalculated = 15
0026 
0027   };
0028 
0029   // Factory methods
0030   static AArch64SVEPcsAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
0031   static AArch64SVEPcsAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
0032   static AArch64SVEPcsAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_aarch64_sve_pcs);
0033   static AArch64SVEPcsAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_aarch64_sve_pcs);
0034 
0035   // Constructors
0036   AArch64SVEPcsAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
0037              );
0038 
0039   AArch64SVEPcsAttr *clone(ASTContext &C) const;
0040   void printPretty(raw_ostream &OS,
0041                    const PrintingPolicy &Policy) const;
0042   const char *getSpelling() const;
0043 
0044 
0045   static bool classof(const Attr *A) { return A->getKind() == attr::AArch64SVEPcs; }
0046 };
0047 
0048 class CLANG_ABI AArch64VectorPcsAttr : public InheritableAttr {
0049 public:
0050   enum Spelling {
0051     GNU_aarch64_vector_pcs = 0,
0052     CXX11_clang_aarch64_vector_pcs = 1,
0053     C23_clang_aarch64_vector_pcs = 2,
0054   SpellingNotCalculated = 15
0055 
0056   };
0057 
0058   // Factory methods
0059   static AArch64VectorPcsAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
0060   static AArch64VectorPcsAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
0061   static AArch64VectorPcsAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_aarch64_vector_pcs);
0062   static AArch64VectorPcsAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_aarch64_vector_pcs);
0063 
0064   // Constructors
0065   AArch64VectorPcsAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
0066              );
0067 
0068   AArch64VectorPcsAttr *clone(ASTContext &C) const;
0069   void printPretty(raw_ostream &OS,
0070                    const PrintingPolicy &Policy) const;
0071   const char *getSpelling() const;
0072 
0073 
0074   static bool classof(const Attr *A) { return A->getKind() == attr::AArch64VectorPcs; }
0075 };
0076 
0077 class CLANG_ABI AMDGPUFlatWorkGroupSizeAttr : public InheritableAttr {
0078 Expr * min;
0079 
0080 Expr * max;
0081 
0082 public:
0083   enum Spelling {
0084     GNU_amdgpu_flat_work_group_size = 0,
0085     CXX11_clang_amdgpu_flat_work_group_size = 1,
0086   SpellingNotCalculated = 15
0087 
0088   };
0089 
0090   // Factory methods
0091   static AMDGPUFlatWorkGroupSizeAttr *CreateImplicit(ASTContext &Ctx, Expr * Min, Expr * Max, const AttributeCommonInfo &CommonInfo);
0092   static AMDGPUFlatWorkGroupSizeAttr *Create(ASTContext &Ctx, Expr * Min, Expr * Max, const AttributeCommonInfo &CommonInfo);
0093   static AMDGPUFlatWorkGroupSizeAttr *CreateImplicit(ASTContext &Ctx, Expr * Min, Expr * Max, SourceRange Range = {}, Spelling S = GNU_amdgpu_flat_work_group_size);
0094   static AMDGPUFlatWorkGroupSizeAttr *Create(ASTContext &Ctx, Expr * Min, Expr * Max, SourceRange Range = {}, Spelling S = GNU_amdgpu_flat_work_group_size);
0095 
0096   // Constructors
0097   AMDGPUFlatWorkGroupSizeAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
0098               , Expr * Min
0099               , Expr * Max
0100              );
0101 
0102   AMDGPUFlatWorkGroupSizeAttr *clone(ASTContext &C) const;
0103   void printPretty(raw_ostream &OS,
0104                    const PrintingPolicy &Policy) const;
0105   const char *getSpelling() const;
0106   Expr * getMin() const {
0107     return min;
0108   }
0109 
0110   Expr * getMax() const {
0111     return max;
0112   }
0113 
0114 
0115 
0116   static bool classof(const Attr *A) { return A->getKind() == attr::AMDGPUFlatWorkGroupSize; }
0117 };
0118 
0119 class CLANG_ABI AMDGPUKernelCallAttr : public InheritableAttr {
0120 public:
0121   enum Spelling {
0122     GNU_amdgpu_kernel = 0,
0123     CXX11_clang_amdgpu_kernel = 1,
0124     C23_clang_amdgpu_kernel = 2,
0125   SpellingNotCalculated = 15
0126 
0127   };
0128 
0129   // Factory methods
0130   static AMDGPUKernelCallAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
0131   static AMDGPUKernelCallAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
0132   static AMDGPUKernelCallAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_amdgpu_kernel);
0133   static AMDGPUKernelCallAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_amdgpu_kernel);
0134 
0135   // Constructors
0136   AMDGPUKernelCallAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
0137              );
0138 
0139   AMDGPUKernelCallAttr *clone(ASTContext &C) const;
0140   void printPretty(raw_ostream &OS,
0141                    const PrintingPolicy &Policy) const;
0142   const char *getSpelling() const;
0143 
0144 
0145   static bool classof(const Attr *A) { return A->getKind() == attr::AMDGPUKernelCall; }
0146 };
0147 
0148 class CLANG_ABI AMDGPUMaxNumWorkGroupsAttr : public InheritableAttr {
0149 Expr * maxNumWorkGroupsX;
0150 
0151 Expr * maxNumWorkGroupsY;
0152 
0153 Expr * maxNumWorkGroupsZ;
0154 
0155 public:
0156   enum Spelling {
0157     GNU_amdgpu_max_num_work_groups = 0,
0158     CXX11_clang_amdgpu_max_num_work_groups = 1,
0159   SpellingNotCalculated = 15
0160 
0161   };
0162 
0163   // Factory methods
0164   static AMDGPUMaxNumWorkGroupsAttr *CreateImplicit(ASTContext &Ctx, Expr * MaxNumWorkGroupsX, Expr * MaxNumWorkGroupsY, Expr * MaxNumWorkGroupsZ, const AttributeCommonInfo &CommonInfo);
0165   static AMDGPUMaxNumWorkGroupsAttr *Create(ASTContext &Ctx, Expr * MaxNumWorkGroupsX, Expr * MaxNumWorkGroupsY, Expr * MaxNumWorkGroupsZ, const AttributeCommonInfo &CommonInfo);
0166   static AMDGPUMaxNumWorkGroupsAttr *CreateImplicit(ASTContext &Ctx, Expr * MaxNumWorkGroupsX, Expr * MaxNumWorkGroupsY, Expr * MaxNumWorkGroupsZ, SourceRange Range = {}, Spelling S = GNU_amdgpu_max_num_work_groups);
0167   static AMDGPUMaxNumWorkGroupsAttr *Create(ASTContext &Ctx, Expr * MaxNumWorkGroupsX, Expr * MaxNumWorkGroupsY, Expr * MaxNumWorkGroupsZ, SourceRange Range = {}, Spelling S = GNU_amdgpu_max_num_work_groups);
0168 
0169   // Constructors
0170   AMDGPUMaxNumWorkGroupsAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
0171               , Expr * MaxNumWorkGroupsX
0172               , Expr * MaxNumWorkGroupsY
0173               , Expr * MaxNumWorkGroupsZ
0174              );
0175   AMDGPUMaxNumWorkGroupsAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
0176               , Expr * MaxNumWorkGroupsX
0177              );
0178 
0179   AMDGPUMaxNumWorkGroupsAttr *clone(ASTContext &C) const;
0180   void printPretty(raw_ostream &OS,
0181                    const PrintingPolicy &Policy) const;
0182   const char *getSpelling() const;
0183   Expr * getMaxNumWorkGroupsX() const {
0184     return maxNumWorkGroupsX;
0185   }
0186 
0187   Expr * getMaxNumWorkGroupsY() const {
0188     return maxNumWorkGroupsY;
0189   }
0190 
0191   Expr * getMaxNumWorkGroupsZ() const {
0192     return maxNumWorkGroupsZ;
0193   }
0194 
0195 
0196 
0197   static bool classof(const Attr *A) { return A->getKind() == attr::AMDGPUMaxNumWorkGroups; }
0198 };
0199 
0200 class CLANG_ABI AMDGPUNumSGPRAttr : public InheritableAttr {
0201 unsigned numSGPR;
0202 
0203 public:
0204   enum Spelling {
0205     GNU_amdgpu_num_sgpr = 0,
0206     CXX11_clang_amdgpu_num_sgpr = 1,
0207   SpellingNotCalculated = 15
0208 
0209   };
0210 
0211   // Factory methods
0212   static AMDGPUNumSGPRAttr *CreateImplicit(ASTContext &Ctx, unsigned NumSGPR, const AttributeCommonInfo &CommonInfo);
0213   static AMDGPUNumSGPRAttr *Create(ASTContext &Ctx, unsigned NumSGPR, const AttributeCommonInfo &CommonInfo);
0214   static AMDGPUNumSGPRAttr *CreateImplicit(ASTContext &Ctx, unsigned NumSGPR, SourceRange Range = {}, Spelling S = GNU_amdgpu_num_sgpr);
0215   static AMDGPUNumSGPRAttr *Create(ASTContext &Ctx, unsigned NumSGPR, SourceRange Range = {}, Spelling S = GNU_amdgpu_num_sgpr);
0216 
0217   // Constructors
0218   AMDGPUNumSGPRAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
0219               , unsigned NumSGPR
0220              );
0221 
0222   AMDGPUNumSGPRAttr *clone(ASTContext &C) const;
0223   void printPretty(raw_ostream &OS,
0224                    const PrintingPolicy &Policy) const;
0225   const char *getSpelling() const;
0226   unsigned getNumSGPR() const {
0227     return numSGPR;
0228   }
0229 
0230 
0231 
0232   static bool classof(const Attr *A) { return A->getKind() == attr::AMDGPUNumSGPR; }
0233 };
0234 
0235 class CLANG_ABI AMDGPUNumVGPRAttr : public InheritableAttr {
0236 unsigned numVGPR;
0237 
0238 public:
0239   enum Spelling {
0240     GNU_amdgpu_num_vgpr = 0,
0241     CXX11_clang_amdgpu_num_vgpr = 1,
0242   SpellingNotCalculated = 15
0243 
0244   };
0245 
0246   // Factory methods
0247   static AMDGPUNumVGPRAttr *CreateImplicit(ASTContext &Ctx, unsigned NumVGPR, const AttributeCommonInfo &CommonInfo);
0248   static AMDGPUNumVGPRAttr *Create(ASTContext &Ctx, unsigned NumVGPR, const AttributeCommonInfo &CommonInfo);
0249   static AMDGPUNumVGPRAttr *CreateImplicit(ASTContext &Ctx, unsigned NumVGPR, SourceRange Range = {}, Spelling S = GNU_amdgpu_num_vgpr);
0250   static AMDGPUNumVGPRAttr *Create(ASTContext &Ctx, unsigned NumVGPR, SourceRange Range = {}, Spelling S = GNU_amdgpu_num_vgpr);
0251 
0252   // Constructors
0253   AMDGPUNumVGPRAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
0254               , unsigned NumVGPR
0255              );
0256 
0257   AMDGPUNumVGPRAttr *clone(ASTContext &C) const;
0258   void printPretty(raw_ostream &OS,
0259                    const PrintingPolicy &Policy) const;
0260   const char *getSpelling() const;
0261   unsigned getNumVGPR() const {
0262     return numVGPR;
0263   }
0264 
0265 
0266 
0267   static bool classof(const Attr *A) { return A->getKind() == attr::AMDGPUNumVGPR; }
0268 };
0269 
0270 class CLANG_ABI AMDGPUWavesPerEUAttr : public InheritableAttr {
0271 Expr * min;
0272 
0273 Expr * max;
0274 
0275 public:
0276   enum Spelling {
0277     GNU_amdgpu_waves_per_eu = 0,
0278     CXX11_clang_amdgpu_waves_per_eu = 1,
0279   SpellingNotCalculated = 15
0280 
0281   };
0282 
0283   // Factory methods
0284   static AMDGPUWavesPerEUAttr *CreateImplicit(ASTContext &Ctx, Expr * Min, Expr * Max, const AttributeCommonInfo &CommonInfo);
0285   static AMDGPUWavesPerEUAttr *Create(ASTContext &Ctx, Expr * Min, Expr * Max, const AttributeCommonInfo &CommonInfo);
0286   static AMDGPUWavesPerEUAttr *CreateImplicit(ASTContext &Ctx, Expr * Min, Expr * Max, SourceRange Range = {}, Spelling S = GNU_amdgpu_waves_per_eu);
0287   static AMDGPUWavesPerEUAttr *Create(ASTContext &Ctx, Expr * Min, Expr * Max, SourceRange Range = {}, Spelling S = GNU_amdgpu_waves_per_eu);
0288 
0289   // Constructors
0290   AMDGPUWavesPerEUAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
0291               , Expr * Min
0292               , Expr * Max
0293              );
0294   AMDGPUWavesPerEUAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
0295               , Expr * Min
0296              );
0297 
0298   AMDGPUWavesPerEUAttr *clone(ASTContext &C) const;
0299   void printPretty(raw_ostream &OS,
0300                    const PrintingPolicy &Policy) const;
0301   const char *getSpelling() const;
0302   Expr * getMin() const {
0303     return min;
0304   }
0305 
0306   Expr * getMax() const {
0307     return max;
0308   }
0309 
0310 
0311 
0312   static bool classof(const Attr *A) { return A->getKind() == attr::AMDGPUWavesPerEU; }
0313 };
0314 
0315 class CLANG_ABI ARMInterruptAttr : public InheritableAttr {
0316 public:
0317   enum InterruptType {
0318     IRQ,
0319     FIQ,
0320     SWI,
0321     ABORT,
0322     UNDEF,
0323     Generic
0324   };
0325 private:
0326   ARMInterruptAttr::InterruptType interrupt;
0327 
0328 public:
0329   enum Spelling {
0330     GNU_interrupt = 0,
0331     CXX11_gnu_interrupt = 1,
0332     C23_gnu_interrupt = 2,
0333   SpellingNotCalculated = 15
0334 
0335   };
0336 
0337   // Factory methods
0338   static ARMInterruptAttr *CreateImplicit(ASTContext &Ctx, ARMInterruptAttr::InterruptType Interrupt, const AttributeCommonInfo &CommonInfo);
0339   static ARMInterruptAttr *Create(ASTContext &Ctx, ARMInterruptAttr::InterruptType Interrupt, const AttributeCommonInfo &CommonInfo);
0340   static ARMInterruptAttr *CreateImplicit(ASTContext &Ctx, ARMInterruptAttr::InterruptType Interrupt, SourceRange Range = {}, Spelling S = GNU_interrupt);
0341   static ARMInterruptAttr *Create(ASTContext &Ctx, ARMInterruptAttr::InterruptType Interrupt, SourceRange Range = {}, Spelling S = GNU_interrupt);
0342 
0343   // Constructors
0344   ARMInterruptAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
0345               , ARMInterruptAttr::InterruptType Interrupt
0346              );
0347   ARMInterruptAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
0348              );
0349 
0350   ARMInterruptAttr *clone(ASTContext &C) const;
0351   void printPretty(raw_ostream &OS,
0352                    const PrintingPolicy &Policy) const;
0353   const char *getSpelling() const;
0354   ARMInterruptAttr::InterruptType getInterrupt() const {
0355     return interrupt;
0356   }
0357 
0358   static bool ConvertStrToInterruptType(StringRef Val, ARMInterruptAttr::InterruptType &Out);
0359   static const char *ConvertInterruptTypeToStr(ARMInterruptAttr::InterruptType Val);
0360 
0361 
0362   static bool classof(const Attr *A) { return A->getKind() == attr::ARMInterrupt; }
0363 };
0364 
0365 class CLANG_ABI AVRInterruptAttr : public InheritableAttr {
0366 public:
0367   enum Spelling {
0368     GNU_interrupt = 0,
0369     CXX11_gnu_interrupt = 1,
0370     C23_gnu_interrupt = 2,
0371   SpellingNotCalculated = 15
0372 
0373   };
0374 
0375   // Factory methods
0376   static AVRInterruptAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
0377   static AVRInterruptAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
0378   static AVRInterruptAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_interrupt);
0379   static AVRInterruptAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_interrupt);
0380 
0381   // Constructors
0382   AVRInterruptAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
0383              );
0384 
0385   AVRInterruptAttr *clone(ASTContext &C) const;
0386   void printPretty(raw_ostream &OS,
0387                    const PrintingPolicy &Policy) const;
0388   const char *getSpelling() const;
0389 
0390 
0391   static bool classof(const Attr *A) { return A->getKind() == attr::AVRInterrupt; }
0392 };
0393 
0394 class CLANG_ABI AVRSignalAttr : public InheritableAttr {
0395 public:
0396   enum Spelling {
0397     GNU_signal = 0,
0398     CXX11_gnu_signal = 1,
0399     C23_gnu_signal = 2,
0400   SpellingNotCalculated = 15
0401 
0402   };
0403 
0404   // Factory methods
0405   static AVRSignalAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
0406   static AVRSignalAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
0407   static AVRSignalAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_signal);
0408   static AVRSignalAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_signal);
0409 
0410   // Constructors
0411   AVRSignalAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
0412              );
0413 
0414   AVRSignalAttr *clone(ASTContext &C) const;
0415   void printPretty(raw_ostream &OS,
0416                    const PrintingPolicy &Policy) const;
0417   const char *getSpelling() const;
0418 
0419 
0420   static bool classof(const Attr *A) { return A->getKind() == attr::AVRSignal; }
0421 };
0422 
0423 class CLANG_ABI AbiTagAttr : public Attr {
0424   unsigned tags_Size;
0425   StringRef *tags_;
0426 
0427 public:
0428   enum Spelling {
0429     GNU_abi_tag = 0,
0430     CXX11_gnu_abi_tag = 1,
0431   SpellingNotCalculated = 15
0432 
0433   };
0434 
0435   // Factory methods
0436   static AbiTagAttr *CreateImplicit(ASTContext &Ctx, StringRef *Tags, unsigned TagsSize, const AttributeCommonInfo &CommonInfo);
0437   static AbiTagAttr *Create(ASTContext &Ctx, StringRef *Tags, unsigned TagsSize, const AttributeCommonInfo &CommonInfo);
0438   static AbiTagAttr *CreateImplicit(ASTContext &Ctx, StringRef *Tags, unsigned TagsSize, SourceRange Range = {}, Spelling S = GNU_abi_tag);
0439   static AbiTagAttr *Create(ASTContext &Ctx, StringRef *Tags, unsigned TagsSize, SourceRange Range = {}, Spelling S = GNU_abi_tag);
0440 
0441   // Constructors
0442   AbiTagAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
0443               , StringRef *Tags, unsigned TagsSize
0444              );
0445   AbiTagAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
0446              );
0447 
0448   AbiTagAttr *clone(ASTContext &C) const;
0449   void printPretty(raw_ostream &OS,
0450                    const PrintingPolicy &Policy) const;
0451   const char *getSpelling() const;
0452   typedef StringRef* tags_iterator;
0453   tags_iterator tags_begin() const { return tags_; }
0454   tags_iterator tags_end() const { return tags_ + tags_Size; }
0455   unsigned tags_size() const { return tags_Size; }
0456   llvm::iterator_range<tags_iterator> tags() const { return llvm::make_range(tags_begin(), tags_end()); }
0457 
0458 
0459 
0460 
0461   static bool classof(const Attr *A) { return A->getKind() == attr::AbiTag; }
0462 };
0463 
0464 class CLANG_ABI AcquireCapabilityAttr : public InheritableAttr {
0465   unsigned args_Size;
0466   Expr * *args_;
0467 
0468 public:
0469   enum Spelling {
0470     GNU_acquire_capability = 0,
0471     CXX11_clang_acquire_capability = 1,
0472     GNU_acquire_shared_capability = 2,
0473     CXX11_clang_acquire_shared_capability = 3,
0474     GNU_exclusive_lock_function = 4,
0475     GNU_shared_lock_function = 5,
0476   SpellingNotCalculated = 15
0477 
0478   };
0479 
0480   // Factory methods
0481   static AcquireCapabilityAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo);
0482   static AcquireCapabilityAttr *Create(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo);
0483   static AcquireCapabilityAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Range = {}, Spelling S = GNU_acquire_capability);
0484   static AcquireCapabilityAttr *Create(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Range = {}, Spelling S = GNU_acquire_capability);
0485 
0486   // Constructors
0487   AcquireCapabilityAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
0488               , Expr * *Args, unsigned ArgsSize
0489              );
0490   AcquireCapabilityAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
0491              );
0492 
0493   AcquireCapabilityAttr *clone(ASTContext &C) const;
0494   void printPretty(raw_ostream &OS,
0495                    const PrintingPolicy &Policy) const;
0496   const char *getSpelling() const;
0497   Spelling getSemanticSpelling() const;
0498   bool isShared() const { return getAttributeSpellingListIndex() == 2 ||
0499     getAttributeSpellingListIndex() == 3 ||
0500     getAttributeSpellingListIndex() == 5; }
0501   typedef Expr ** args_iterator;
0502   args_iterator args_begin() const { return args_; }
0503   args_iterator args_end() const { return args_ + args_Size; }
0504   unsigned args_size() const { return args_Size; }
0505   llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }
0506 
0507 
0508 
0509 
0510   static bool classof(const Attr *A) { return A->getKind() == attr::AcquireCapability; }
0511 };
0512 
0513 class CLANG_ABI AcquireHandleAttr : public InheritableAttr {
0514 unsigned handleTypeLength;
0515 char *handleType;
0516 
0517 public:
0518   enum Spelling {
0519     GNU_acquire_handle = 0,
0520     CXX11_clang_acquire_handle = 1,
0521     C23_clang_acquire_handle = 2,
0522   SpellingNotCalculated = 15
0523 
0524   };
0525 
0526   // Factory methods
0527   static AcquireHandleAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef HandleType, const AttributeCommonInfo &CommonInfo);
0528   static AcquireHandleAttr *Create(ASTContext &Ctx, llvm::StringRef HandleType, const AttributeCommonInfo &CommonInfo);
0529   static AcquireHandleAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef HandleType, SourceRange Range = {}, Spelling S = GNU_acquire_handle);
0530   static AcquireHandleAttr *Create(ASTContext &Ctx, llvm::StringRef HandleType, SourceRange Range = {}, Spelling S = GNU_acquire_handle);
0531 
0532   // Constructors
0533   AcquireHandleAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
0534               , llvm::StringRef HandleType
0535              );
0536 
0537   AcquireHandleAttr *clone(ASTContext &C) const;
0538   void printPretty(raw_ostream &OS,
0539                    const PrintingPolicy &Policy) const;
0540   const char *getSpelling() const;
0541   llvm::StringRef getHandleType() const {
0542     return llvm::StringRef(handleType, handleTypeLength);
0543   }
0544   unsigned getHandleTypeLength() const {
0545     return handleTypeLength;
0546   }
0547   void setHandleType(ASTContext &C, llvm::StringRef S) {
0548     handleTypeLength = S.size();
0549     this->handleType = new (C, 1) char [handleTypeLength];
0550     if (!S.empty())
0551       std::memcpy(this->handleType, S.data(), handleTypeLength);
0552   }
0553 
0554 
0555 
0556   static bool classof(const Attr *A) { return A->getKind() == attr::AcquireHandle; }
0557 };
0558 
0559 class CLANG_ABI AcquiredAfterAttr : public InheritableAttr {
0560   unsigned args_Size;
0561   Expr * *args_;
0562 
0563 public:
0564   // Factory methods
0565   static AcquiredAfterAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo);
0566   static AcquiredAfterAttr *Create(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo);
0567   static AcquiredAfterAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Range = {});
0568   static AcquiredAfterAttr *Create(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Range = {});
0569 
0570   // Constructors
0571   AcquiredAfterAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
0572               , Expr * *Args, unsigned ArgsSize
0573              );
0574   AcquiredAfterAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
0575              );
0576 
0577   AcquiredAfterAttr *clone(ASTContext &C) const;
0578   void printPretty(raw_ostream &OS,
0579                    const PrintingPolicy &Policy) const;
0580   const char *getSpelling() const;
0581   typedef Expr ** args_iterator;
0582   args_iterator args_begin() const { return args_; }
0583   args_iterator args_end() const { return args_ + args_Size; }
0584   unsigned args_size() const { return args_Size; }
0585   llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }
0586 
0587 
0588 
0589 
0590   static bool classof(const Attr *A) { return A->getKind() == attr::AcquiredAfter; }
0591 };
0592 
0593 class CLANG_ABI AcquiredBeforeAttr : public InheritableAttr {
0594   unsigned args_Size;
0595   Expr * *args_;
0596 
0597 public:
0598   // Factory methods
0599   static AcquiredBeforeAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo);
0600   static AcquiredBeforeAttr *Create(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo);
0601   static AcquiredBeforeAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Range = {});
0602   static AcquiredBeforeAttr *Create(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Range = {});
0603 
0604   // Constructors
0605   AcquiredBeforeAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
0606               , Expr * *Args, unsigned ArgsSize
0607              );
0608   AcquiredBeforeAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
0609              );
0610 
0611   AcquiredBeforeAttr *clone(ASTContext &C) const;
0612   void printPretty(raw_ostream &OS,
0613                    const PrintingPolicy &Policy) const;
0614   const char *getSpelling() const;
0615   typedef Expr ** args_iterator;
0616   args_iterator args_begin() const { return args_; }
0617   args_iterator args_end() const { return args_ + args_Size; }
0618   unsigned args_size() const { return args_Size; }
0619   llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }
0620 
0621 
0622 
0623 
0624   static bool classof(const Attr *A) { return A->getKind() == attr::AcquiredBefore; }
0625 };
0626 
0627 class CLANG_ABI AddressSpaceAttr : public TypeAttr {
0628 int addressSpace;
0629 
0630 public:
0631   enum Spelling {
0632     GNU_address_space = 0,
0633     CXX11_clang_address_space = 1,
0634     C23_clang_address_space = 2,
0635   SpellingNotCalculated = 15
0636 
0637   };
0638 
0639   // Factory methods
0640   static AddressSpaceAttr *CreateImplicit(ASTContext &Ctx, int AddressSpace, const AttributeCommonInfo &CommonInfo);
0641   static AddressSpaceAttr *Create(ASTContext &Ctx, int AddressSpace, const AttributeCommonInfo &CommonInfo);
0642   static AddressSpaceAttr *CreateImplicit(ASTContext &Ctx, int AddressSpace, SourceRange Range = {}, Spelling S = GNU_address_space);
0643   static AddressSpaceAttr *Create(ASTContext &Ctx, int AddressSpace, SourceRange Range = {}, Spelling S = GNU_address_space);
0644 
0645   // Constructors
0646   AddressSpaceAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
0647               , int AddressSpace
0648              );
0649 
0650   AddressSpaceAttr *clone(ASTContext &C) const;
0651   void printPretty(raw_ostream &OS,
0652                    const PrintingPolicy &Policy) const;
0653   const char *getSpelling() const;
0654   int getAddressSpace() const {
0655     return addressSpace;
0656   }
0657 
0658 
0659 
0660   static bool classof(const Attr *A) { return A->getKind() == attr::AddressSpace; }
0661 };
0662 
0663 class CLANG_ABI AliasAttr : public Attr {
0664 unsigned aliaseeLength;
0665 char *aliasee;
0666 
0667 public:
0668   enum Spelling {
0669     GNU_alias = 0,
0670     CXX11_gnu_alias = 1,
0671     C23_gnu_alias = 2,
0672   SpellingNotCalculated = 15
0673 
0674   };
0675 
0676   // Factory methods
0677   static AliasAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Aliasee, const AttributeCommonInfo &CommonInfo);
0678   static AliasAttr *Create(ASTContext &Ctx, llvm::StringRef Aliasee, const AttributeCommonInfo &CommonInfo);
0679   static AliasAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Aliasee, SourceRange Range = {}, Spelling S = GNU_alias);
0680   static AliasAttr *Create(ASTContext &Ctx, llvm::StringRef Aliasee, SourceRange Range = {}, Spelling S = GNU_alias);
0681 
0682   // Constructors
0683   AliasAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
0684               , llvm::StringRef Aliasee
0685              );
0686 
0687   AliasAttr *clone(ASTContext &C) const;
0688   void printPretty(raw_ostream &OS,
0689                    const PrintingPolicy &Policy) const;
0690   const char *getSpelling() const;
0691   llvm::StringRef getAliasee() const {
0692     return llvm::StringRef(aliasee, aliaseeLength);
0693   }
0694   unsigned getAliaseeLength() const {
0695     return aliaseeLength;
0696   }
0697   void setAliasee(ASTContext &C, llvm::StringRef S) {
0698     aliaseeLength = S.size();
0699     this->aliasee = new (C, 1) char [aliaseeLength];
0700     if (!S.empty())
0701       std::memcpy(this->aliasee, S.data(), aliaseeLength);
0702   }
0703 
0704 
0705 
0706   static bool classof(const Attr *A) { return A->getKind() == attr::Alias; }
0707 };
0708 
0709 class CLANG_ABI AlignMac68kAttr : public InheritableAttr {
0710 public:
0711   // Factory methods
0712   static AlignMac68kAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
0713   static AlignMac68kAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
0714   static AlignMac68kAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {});
0715   static AlignMac68kAttr *Create(ASTContext &Ctx, SourceRange Range = {});
0716 
0717   // Constructors
0718   AlignMac68kAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
0719              );
0720 
0721   AlignMac68kAttr *clone(ASTContext &C) const;
0722   void printPretty(raw_ostream &OS,
0723                    const PrintingPolicy &Policy) const;
0724   const char *getSpelling() const;
0725 
0726 
0727   static bool classof(const Attr *A) { return A->getKind() == attr::AlignMac68k; }
0728 };
0729 
0730 class CLANG_ABI AlignNaturalAttr : public InheritableAttr {
0731 public:
0732   // Factory methods
0733   static AlignNaturalAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
0734   static AlignNaturalAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
0735   static AlignNaturalAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {});
0736   static AlignNaturalAttr *Create(ASTContext &Ctx, SourceRange Range = {});
0737 
0738   // Constructors
0739   AlignNaturalAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
0740              );
0741 
0742   AlignNaturalAttr *clone(ASTContext &C) const;
0743   void printPretty(raw_ostream &OS,
0744                    const PrintingPolicy &Policy) const;
0745   const char *getSpelling() const;
0746 
0747 
0748   static bool classof(const Attr *A) { return A->getKind() == attr::AlignNatural; }
0749 };
0750 
0751 class CLANG_ABI AlignValueAttr : public Attr {
0752 Expr * alignment;
0753 
0754 public:
0755   // Factory methods
0756   static AlignValueAttr *CreateImplicit(ASTContext &Ctx, Expr * Alignment, const AttributeCommonInfo &CommonInfo);
0757   static AlignValueAttr *Create(ASTContext &Ctx, Expr * Alignment, const AttributeCommonInfo &CommonInfo);
0758   static AlignValueAttr *CreateImplicit(ASTContext &Ctx, Expr * Alignment, SourceRange Range = {});
0759   static AlignValueAttr *Create(ASTContext &Ctx, Expr * Alignment, SourceRange Range = {});
0760 
0761   // Constructors
0762   AlignValueAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
0763               , Expr * Alignment
0764              );
0765 
0766   AlignValueAttr *clone(ASTContext &C) const;
0767   void printPretty(raw_ostream &OS,
0768                    const PrintingPolicy &Policy) const;
0769   const char *getSpelling() const;
0770   Expr * getAlignment() const {
0771     return alignment;
0772   }
0773 
0774 
0775 
0776   static bool classof(const Attr *A) { return A->getKind() == attr::AlignValue; }
0777 };
0778 
0779 class CLANG_ABI AlignedAttr : public InheritableAttr {
0780 bool isalignmentExpr;
0781 union {
0782 Expr *alignmentExpr;
0783 TypeSourceInfo *alignmentType;
0784 };
0785 std::optional<unsigned> alignmentCache;
0786 
0787 
0788 public:
0789   enum Spelling {
0790     GNU_aligned = 0,
0791     CXX11_gnu_aligned = 1,
0792     C23_gnu_aligned = 2,
0793     Declspec_align = 3,
0794     Keyword_alignas = 4,
0795     Keyword_Alignas = 5,
0796   SpellingNotCalculated = 15
0797 
0798   };
0799 
0800   // Factory methods
0801   static AlignedAttr *CreateImplicit(ASTContext &Ctx, bool IsAlignmentExpr, void *Alignment, const AttributeCommonInfo &CommonInfo);
0802   static AlignedAttr *Create(ASTContext &Ctx, bool IsAlignmentExpr, void *Alignment, const AttributeCommonInfo &CommonInfo);
0803   static AlignedAttr *CreateImplicit(ASTContext &Ctx, bool IsAlignmentExpr, void *Alignment, SourceRange Range = {}, Spelling S = GNU_aligned);
0804   static AlignedAttr *Create(ASTContext &Ctx, bool IsAlignmentExpr, void *Alignment, SourceRange Range = {}, Spelling S = GNU_aligned);
0805 
0806   // Constructors
0807   AlignedAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
0808               , bool IsAlignmentExpr, void *Alignment
0809              );
0810   AlignedAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
0811              );
0812 
0813   AlignedAttr *clone(ASTContext &C) const;
0814   void printPretty(raw_ostream &OS,
0815                    const PrintingPolicy &Policy) const;
0816   const char *getSpelling() const;
0817   Spelling getSemanticSpelling() const;
0818   bool isGNU() const { return getAttributeSpellingListIndex() == 0 ||
0819     getAttributeSpellingListIndex() == 1 ||
0820     getAttributeSpellingListIndex() == 2; }
0821   bool isC11() const { return getAttributeSpellingListIndex() == 5; }
0822   bool isAlignas() const { return getAttributeSpellingListIndex() == 4 ||
0823     getAttributeSpellingListIndex() == 5; }
0824   bool isDeclspec() const { return getAttributeSpellingListIndex() == 3; }
0825   bool isAlignmentDependent() const;
0826   bool isAlignmentErrorDependent() const;
0827   unsigned getAlignment(ASTContext &Ctx) const;
0828   bool isAlignmentExpr() const {
0829     return isalignmentExpr;
0830   }
0831   Expr *getAlignmentExpr() const {
0832     assert(isalignmentExpr);
0833     return alignmentExpr;
0834   }
0835   TypeSourceInfo *getAlignmentType() const {
0836     assert(!isalignmentExpr);
0837     return alignmentType;
0838   }  std::optional<unsigned> getCachedAlignmentValue() const {
0839     return alignmentCache;
0840   }  void setCachedAlignmentValue(unsigned AlignVal) {
0841     alignmentCache = AlignVal;
0842   }
0843 
0844 
0845 
0846   static bool classof(const Attr *A) { return A->getKind() == attr::Aligned; }
0847 };
0848 
0849 class CLANG_ABI AllocAlignAttr : public InheritableAttr {
0850 ParamIdx paramIndex;
0851 
0852 public:
0853   enum Spelling {
0854     GNU_alloc_align = 0,
0855     CXX11_gnu_alloc_align = 1,
0856     C23_gnu_alloc_align = 2,
0857   SpellingNotCalculated = 15
0858 
0859   };
0860 
0861   // Factory methods
0862   static AllocAlignAttr *CreateImplicit(ASTContext &Ctx, ParamIdx ParamIndex, const AttributeCommonInfo &CommonInfo);
0863   static AllocAlignAttr *Create(ASTContext &Ctx, ParamIdx ParamIndex, const AttributeCommonInfo &CommonInfo);
0864   static AllocAlignAttr *CreateImplicit(ASTContext &Ctx, ParamIdx ParamIndex, SourceRange Range = {}, Spelling S = GNU_alloc_align);
0865   static AllocAlignAttr *Create(ASTContext &Ctx, ParamIdx ParamIndex, SourceRange Range = {}, Spelling S = GNU_alloc_align);
0866 
0867   // Constructors
0868   AllocAlignAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
0869               , ParamIdx ParamIndex
0870              );
0871 
0872   AllocAlignAttr *clone(ASTContext &C) const;
0873   void printPretty(raw_ostream &OS,
0874                    const PrintingPolicy &Policy) const;
0875   const char *getSpelling() const;
0876   ParamIdx getParamIndex() const {
0877     return paramIndex;
0878   }
0879 
0880 
0881 
0882   static bool classof(const Attr *A) { return A->getKind() == attr::AllocAlign; }
0883 };
0884 
0885 class CLANG_ABI AllocSizeAttr : public InheritableAttr {
0886 ParamIdx elemSizeParam;
0887 
0888 ParamIdx numElemsParam;
0889 
0890 public:
0891   enum Spelling {
0892     GNU_alloc_size = 0,
0893     CXX11_gnu_alloc_size = 1,
0894     C23_gnu_alloc_size = 2,
0895   SpellingNotCalculated = 15
0896 
0897   };
0898 
0899   // Factory methods
0900   static AllocSizeAttr *CreateImplicit(ASTContext &Ctx, ParamIdx ElemSizeParam, ParamIdx NumElemsParam, const AttributeCommonInfo &CommonInfo);
0901   static AllocSizeAttr *Create(ASTContext &Ctx, ParamIdx ElemSizeParam, ParamIdx NumElemsParam, const AttributeCommonInfo &CommonInfo);
0902   static AllocSizeAttr *CreateImplicit(ASTContext &Ctx, ParamIdx ElemSizeParam, ParamIdx NumElemsParam, SourceRange Range = {}, Spelling S = GNU_alloc_size);
0903   static AllocSizeAttr *Create(ASTContext &Ctx, ParamIdx ElemSizeParam, ParamIdx NumElemsParam, SourceRange Range = {}, Spelling S = GNU_alloc_size);
0904 
0905   // Constructors
0906   AllocSizeAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
0907               , ParamIdx ElemSizeParam
0908               , ParamIdx NumElemsParam
0909              );
0910   AllocSizeAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
0911               , ParamIdx ElemSizeParam
0912              );
0913 
0914   AllocSizeAttr *clone(ASTContext &C) const;
0915   void printPretty(raw_ostream &OS,
0916                    const PrintingPolicy &Policy) const;
0917   const char *getSpelling() const;
0918   ParamIdx getElemSizeParam() const {
0919     return elemSizeParam;
0920   }
0921 
0922   ParamIdx getNumElemsParam() const {
0923     return numElemsParam;
0924   }
0925 
0926 
0927 
0928   static bool classof(const Attr *A) { return A->getKind() == attr::AllocSize; }
0929 };
0930 
0931 class CLANG_ABI AllocatingAttr : public TypeAttr {
0932 public:
0933   enum Spelling {
0934     GNU_allocating = 0,
0935     CXX11_clang_allocating = 1,
0936     C23_clang_allocating = 2,
0937   SpellingNotCalculated = 15
0938 
0939   };
0940 
0941   // Factory methods
0942   static AllocatingAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
0943   static AllocatingAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
0944   static AllocatingAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_allocating);
0945   static AllocatingAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_allocating);
0946 
0947   // Constructors
0948   AllocatingAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
0949              );
0950 
0951   AllocatingAttr *clone(ASTContext &C) const;
0952   void printPretty(raw_ostream &OS,
0953                    const PrintingPolicy &Policy) const;
0954   const char *getSpelling() const;
0955 
0956 
0957   static bool classof(const Attr *A) { return A->getKind() == attr::Allocating; }
0958 };
0959 
0960 class CLANG_ABI AlwaysDestroyAttr : public InheritableAttr {
0961 public:
0962   enum Spelling {
0963     GNU_always_destroy = 0,
0964     CXX11_clang_always_destroy = 1,
0965   SpellingNotCalculated = 15
0966 
0967   };
0968 
0969   // Factory methods
0970   static AlwaysDestroyAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
0971   static AlwaysDestroyAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
0972   static AlwaysDestroyAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_always_destroy);
0973   static AlwaysDestroyAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_always_destroy);
0974 
0975   // Constructors
0976   AlwaysDestroyAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
0977              );
0978 
0979   AlwaysDestroyAttr *clone(ASTContext &C) const;
0980   void printPretty(raw_ostream &OS,
0981                    const PrintingPolicy &Policy) const;
0982   const char *getSpelling() const;
0983 
0984 
0985   static bool classof(const Attr *A) { return A->getKind() == attr::AlwaysDestroy; }
0986 };
0987 
0988 class CLANG_ABI AlwaysInlineAttr : public DeclOrStmtAttr {
0989 public:
0990   enum Spelling {
0991     GNU_always_inline = 0,
0992     CXX11_gnu_always_inline = 1,
0993     C23_gnu_always_inline = 2,
0994     CXX11_clang_always_inline = 3,
0995     C23_clang_always_inline = 4,
0996     Keyword_forceinline = 5,
0997   SpellingNotCalculated = 15
0998 
0999   };
1000 
1001   // Factory methods
1002   static AlwaysInlineAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
1003   static AlwaysInlineAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
1004   static AlwaysInlineAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_always_inline);
1005   static AlwaysInlineAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_always_inline);
1006 
1007   // Constructors
1008   AlwaysInlineAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
1009              );
1010 
1011   AlwaysInlineAttr *clone(ASTContext &C) const;
1012   void printPretty(raw_ostream &OS,
1013                    const PrintingPolicy &Policy) const;
1014   const char *getSpelling() const;
1015   Spelling getSemanticSpelling() const;
1016   bool isClangAlwaysInline() const { return getAttributeSpellingListIndex() == 3 ||
1017     getAttributeSpellingListIndex() == 4; }
1018 
1019 
1020   static bool classof(const Attr *A) { return A->getKind() == attr::AlwaysInline; }
1021 };
1022 
1023 class CLANG_ABI AnalyzerNoReturnAttr : public InheritableAttr {
1024 public:
1025   // Factory methods
1026   static AnalyzerNoReturnAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
1027   static AnalyzerNoReturnAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
1028   static AnalyzerNoReturnAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {});
1029   static AnalyzerNoReturnAttr *Create(ASTContext &Ctx, SourceRange Range = {});
1030 
1031   // Constructors
1032   AnalyzerNoReturnAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
1033              );
1034 
1035   AnalyzerNoReturnAttr *clone(ASTContext &C) const;
1036   void printPretty(raw_ostream &OS,
1037                    const PrintingPolicy &Policy) const;
1038   const char *getSpelling() const;
1039 
1040 
1041   static bool classof(const Attr *A) { return A->getKind() == attr::AnalyzerNoReturn; }
1042 };
1043 
1044 class CLANG_ABI AnnotateAttr : public InheritableParamOrStmtAttr {
1045 unsigned annotationLength;
1046 char *annotation;
1047 
1048   unsigned args_Size;
1049   Expr * *args_;
1050 
1051   unsigned delayedArgs_Size;
1052   Expr * *delayedArgs_;
1053 
1054 public:
1055   enum Spelling {
1056     GNU_annotate = 0,
1057     CXX11_clang_annotate = 1,
1058     C23_clang_annotate = 2,
1059   SpellingNotCalculated = 15
1060 
1061   };
1062 
1063   // Factory methods
1064   static AnnotateAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Annotation, Expr * *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo);
1065   static AnnotateAttr *Create(ASTContext &Ctx, llvm::StringRef Annotation, Expr * *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo);
1066   static AnnotateAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Annotation, Expr * *Args, unsigned ArgsSize, SourceRange Range = {}, Spelling S = GNU_annotate);
1067   static AnnotateAttr *Create(ASTContext &Ctx, llvm::StringRef Annotation, Expr * *Args, unsigned ArgsSize, SourceRange Range = {}, Spelling S = GNU_annotate);
1068   static AnnotateAttr *CreateImplicitWithDelayedArgs(ASTContext &Ctx, Expr * *DelayedArgs, unsigned DelayedArgsSize, const AttributeCommonInfo &CommonInfo);
1069   static AnnotateAttr *CreateWithDelayedArgs(ASTContext &Ctx, Expr * *DelayedArgs, unsigned DelayedArgsSize, const AttributeCommonInfo &CommonInfo);
1070   static AnnotateAttr *CreateImplicitWithDelayedArgs(ASTContext &Ctx, Expr * *DelayedArgs, unsigned DelayedArgsSize, SourceRange Range = {}, Spelling S = GNU_annotate);
1071   static AnnotateAttr *CreateWithDelayedArgs(ASTContext &Ctx, Expr * *DelayedArgs, unsigned DelayedArgsSize, SourceRange Range = {}, Spelling S = GNU_annotate);
1072 
1073   // Constructors
1074   AnnotateAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
1075               , llvm::StringRef Annotation
1076               , Expr * *Args, unsigned ArgsSize
1077              );
1078   AnnotateAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
1079               , llvm::StringRef Annotation
1080              );
1081   AnnotateAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
1082              );
1083 
1084   AnnotateAttr *clone(ASTContext &C) const;
1085   void printPretty(raw_ostream &OS,
1086                    const PrintingPolicy &Policy) const;
1087   const char *getSpelling() const;
1088   llvm::StringRef getAnnotation() const {
1089     return llvm::StringRef(annotation, annotationLength);
1090   }
1091   unsigned getAnnotationLength() const {
1092     return annotationLength;
1093   }
1094   void setAnnotation(ASTContext &C, llvm::StringRef S) {
1095     annotationLength = S.size();
1096     this->annotation = new (C, 1) char [annotationLength];
1097     if (!S.empty())
1098       std::memcpy(this->annotation, S.data(), annotationLength);
1099   }
1100 
1101   typedef Expr ** args_iterator;
1102   args_iterator args_begin() const { return args_; }
1103   args_iterator args_end() const { return args_ + args_Size; }
1104   unsigned args_size() const { return args_Size; }
1105   llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }
1106 
1107 
1108   typedef Expr ** delayedArgs_iterator;
1109   delayedArgs_iterator delayedArgs_begin() const { return delayedArgs_; }
1110   delayedArgs_iterator delayedArgs_end() const { return delayedArgs_ + delayedArgs_Size; }
1111   unsigned delayedArgs_size() const { return delayedArgs_Size; }
1112   llvm::iterator_range<delayedArgs_iterator> delayedArgs() const { return llvm::make_range(delayedArgs_begin(), delayedArgs_end()); }
1113   void setDelayedArgs(ASTContext &Ctx, Expr * *DelayedArgs, unsigned DelayedArgsSize) {
1114     delayedArgs_Size = DelayedArgsSize;
1115     delayedArgs_ = new (Ctx, 16) Expr *[delayedArgs_Size];
1116     std::copy(DelayedArgs, DelayedArgs + delayedArgs_Size, delayedArgs_);
1117   }
1118 
1119   static AnnotateAttr *Create(ASTContext &Ctx, llvm::StringRef Annotation, \
1120               const AttributeCommonInfo &CommonInfo) {
1121     return AnnotateAttr::Create(Ctx, Annotation, nullptr, 0, CommonInfo);
1122   }
1123   static AnnotateAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Annotation, \
1124               const AttributeCommonInfo &CommonInfo) {
1125     return AnnotateAttr::CreateImplicit(Ctx, Annotation, nullptr, 0, CommonInfo);
1126   }
1127   
1128 
1129   static bool classof(const Attr *A) { return A->getKind() == attr::Annotate; }
1130 };
1131 
1132 class CLANG_ABI AnnotateTypeAttr : public TypeAttr {
1133 unsigned annotationLength;
1134 char *annotation;
1135 
1136   unsigned args_Size;
1137   Expr * *args_;
1138 
1139   unsigned delayedArgs_Size;
1140   Expr * *delayedArgs_;
1141 
1142 public:
1143   enum Spelling {
1144     CXX11_clang_annotate_type = 0,
1145     C23_clang_annotate_type = 1,
1146   SpellingNotCalculated = 15
1147 
1148   };
1149 
1150   // Factory methods
1151   static AnnotateTypeAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Annotation, Expr * *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo);
1152   static AnnotateTypeAttr *Create(ASTContext &Ctx, llvm::StringRef Annotation, Expr * *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo);
1153   static AnnotateTypeAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Annotation, Expr * *Args, unsigned ArgsSize, SourceRange Range = {}, Spelling S = CXX11_clang_annotate_type);
1154   static AnnotateTypeAttr *Create(ASTContext &Ctx, llvm::StringRef Annotation, Expr * *Args, unsigned ArgsSize, SourceRange Range = {}, Spelling S = CXX11_clang_annotate_type);
1155   static AnnotateTypeAttr *CreateImplicitWithDelayedArgs(ASTContext &Ctx, Expr * *DelayedArgs, unsigned DelayedArgsSize, const AttributeCommonInfo &CommonInfo);
1156   static AnnotateTypeAttr *CreateWithDelayedArgs(ASTContext &Ctx, Expr * *DelayedArgs, unsigned DelayedArgsSize, const AttributeCommonInfo &CommonInfo);
1157   static AnnotateTypeAttr *CreateImplicitWithDelayedArgs(ASTContext &Ctx, Expr * *DelayedArgs, unsigned DelayedArgsSize, SourceRange Range = {}, Spelling S = CXX11_clang_annotate_type);
1158   static AnnotateTypeAttr *CreateWithDelayedArgs(ASTContext &Ctx, Expr * *DelayedArgs, unsigned DelayedArgsSize, SourceRange Range = {}, Spelling S = CXX11_clang_annotate_type);
1159 
1160   // Constructors
1161   AnnotateTypeAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
1162               , llvm::StringRef Annotation
1163               , Expr * *Args, unsigned ArgsSize
1164              );
1165   AnnotateTypeAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
1166               , llvm::StringRef Annotation
1167              );
1168   AnnotateTypeAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
1169              );
1170 
1171   AnnotateTypeAttr *clone(ASTContext &C) const;
1172   void printPretty(raw_ostream &OS,
1173                    const PrintingPolicy &Policy) const;
1174   const char *getSpelling() const;
1175   llvm::StringRef getAnnotation() const {
1176     return llvm::StringRef(annotation, annotationLength);
1177   }
1178   unsigned getAnnotationLength() const {
1179     return annotationLength;
1180   }
1181   void setAnnotation(ASTContext &C, llvm::StringRef S) {
1182     annotationLength = S.size();
1183     this->annotation = new (C, 1) char [annotationLength];
1184     if (!S.empty())
1185       std::memcpy(this->annotation, S.data(), annotationLength);
1186   }
1187 
1188   typedef Expr ** args_iterator;
1189   args_iterator args_begin() const { return args_; }
1190   args_iterator args_end() const { return args_ + args_Size; }
1191   unsigned args_size() const { return args_Size; }
1192   llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }
1193 
1194 
1195   typedef Expr ** delayedArgs_iterator;
1196   delayedArgs_iterator delayedArgs_begin() const { return delayedArgs_; }
1197   delayedArgs_iterator delayedArgs_end() const { return delayedArgs_ + delayedArgs_Size; }
1198   unsigned delayedArgs_size() const { return delayedArgs_Size; }
1199   llvm::iterator_range<delayedArgs_iterator> delayedArgs() const { return llvm::make_range(delayedArgs_begin(), delayedArgs_end()); }
1200   void setDelayedArgs(ASTContext &Ctx, Expr * *DelayedArgs, unsigned DelayedArgsSize) {
1201     delayedArgs_Size = DelayedArgsSize;
1202     delayedArgs_ = new (Ctx, 16) Expr *[delayedArgs_Size];
1203     std::copy(DelayedArgs, DelayedArgs + delayedArgs_Size, delayedArgs_);
1204   }
1205 
1206 
1207   static bool classof(const Attr *A) { return A->getKind() == attr::AnnotateType; }
1208 };
1209 
1210 class CLANG_ABI AnyX86InterruptAttr : public InheritableAttr {
1211 public:
1212   enum Spelling {
1213     GNU_interrupt = 0,
1214     CXX11_gnu_interrupt = 1,
1215     C23_gnu_interrupt = 2,
1216   SpellingNotCalculated = 15
1217 
1218   };
1219 
1220   // Factory methods
1221   static AnyX86InterruptAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
1222   static AnyX86InterruptAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
1223   static AnyX86InterruptAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_interrupt);
1224   static AnyX86InterruptAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_interrupt);
1225 
1226   // Constructors
1227   AnyX86InterruptAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
1228              );
1229 
1230   AnyX86InterruptAttr *clone(ASTContext &C) const;
1231   void printPretty(raw_ostream &OS,
1232                    const PrintingPolicy &Policy) const;
1233   const char *getSpelling() const;
1234 
1235 
1236   static bool classof(const Attr *A) { return A->getKind() == attr::AnyX86Interrupt; }
1237 };
1238 
1239 class CLANG_ABI AnyX86NoCallerSavedRegistersAttr : public InheritableAttr {
1240 public:
1241   enum Spelling {
1242     GNU_no_caller_saved_registers = 0,
1243     CXX11_gnu_no_caller_saved_registers = 1,
1244     C23_gnu_no_caller_saved_registers = 2,
1245   SpellingNotCalculated = 15
1246 
1247   };
1248 
1249   // Factory methods
1250   static AnyX86NoCallerSavedRegistersAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
1251   static AnyX86NoCallerSavedRegistersAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
1252   static AnyX86NoCallerSavedRegistersAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_no_caller_saved_registers);
1253   static AnyX86NoCallerSavedRegistersAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_no_caller_saved_registers);
1254 
1255   // Constructors
1256   AnyX86NoCallerSavedRegistersAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
1257              );
1258 
1259   AnyX86NoCallerSavedRegistersAttr *clone(ASTContext &C) const;
1260   void printPretty(raw_ostream &OS,
1261                    const PrintingPolicy &Policy) const;
1262   const char *getSpelling() const;
1263 
1264 
1265   static bool classof(const Attr *A) { return A->getKind() == attr::AnyX86NoCallerSavedRegisters; }
1266 };
1267 
1268 class CLANG_ABI AnyX86NoCfCheckAttr : public InheritableAttr {
1269 public:
1270   enum Spelling {
1271     GNU_nocf_check = 0,
1272     CXX11_gnu_nocf_check = 1,
1273     C23_gnu_nocf_check = 2,
1274   SpellingNotCalculated = 15
1275 
1276   };
1277 
1278   // Factory methods
1279   static AnyX86NoCfCheckAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
1280   static AnyX86NoCfCheckAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
1281   static AnyX86NoCfCheckAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_nocf_check);
1282   static AnyX86NoCfCheckAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_nocf_check);
1283 
1284   // Constructors
1285   AnyX86NoCfCheckAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
1286              );
1287 
1288   AnyX86NoCfCheckAttr *clone(ASTContext &C) const;
1289   void printPretty(raw_ostream &OS,
1290                    const PrintingPolicy &Policy) const;
1291   const char *getSpelling() const;
1292 
1293 
1294   static bool classof(const Attr *A) { return A->getKind() == attr::AnyX86NoCfCheck; }
1295 };
1296 
1297 class CLANG_ABI ArcWeakrefUnavailableAttr : public InheritableAttr {
1298 public:
1299   enum Spelling {
1300     GNU_objc_arc_weak_reference_unavailable = 0,
1301     CXX11_clang_objc_arc_weak_reference_unavailable = 1,
1302     C23_clang_objc_arc_weak_reference_unavailable = 2,
1303   SpellingNotCalculated = 15
1304 
1305   };
1306 
1307   // Factory methods
1308   static ArcWeakrefUnavailableAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
1309   static ArcWeakrefUnavailableAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
1310   static ArcWeakrefUnavailableAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_objc_arc_weak_reference_unavailable);
1311   static ArcWeakrefUnavailableAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_objc_arc_weak_reference_unavailable);
1312 
1313   // Constructors
1314   ArcWeakrefUnavailableAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
1315              );
1316 
1317   ArcWeakrefUnavailableAttr *clone(ASTContext &C) const;
1318   void printPretty(raw_ostream &OS,
1319                    const PrintingPolicy &Policy) const;
1320   const char *getSpelling() const;
1321 
1322 
1323   static bool classof(const Attr *A) { return A->getKind() == attr::ArcWeakrefUnavailable; }
1324 };
1325 
1326 class CLANG_ABI ArgumentWithTypeTagAttr : public InheritableAttr {
1327 IdentifierInfo * argumentKind;
1328 
1329 ParamIdx argumentIdx;
1330 
1331 ParamIdx typeTagIdx;
1332 
1333 bool isPointer;
1334 
1335 public:
1336   enum Spelling {
1337     GNU_argument_with_type_tag = 0,
1338     CXX11_clang_argument_with_type_tag = 1,
1339     C23_clang_argument_with_type_tag = 2,
1340     GNU_pointer_with_type_tag = 3,
1341     CXX11_clang_pointer_with_type_tag = 4,
1342     C23_clang_pointer_with_type_tag = 5,
1343   SpellingNotCalculated = 15
1344 
1345   };
1346 
1347   // Factory methods
1348   static ArgumentWithTypeTagAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * ArgumentKind, ParamIdx ArgumentIdx, ParamIdx TypeTagIdx, bool IsPointer, const AttributeCommonInfo &CommonInfo);
1349   static ArgumentWithTypeTagAttr *Create(ASTContext &Ctx, IdentifierInfo * ArgumentKind, ParamIdx ArgumentIdx, ParamIdx TypeTagIdx, bool IsPointer, const AttributeCommonInfo &CommonInfo);
1350   static ArgumentWithTypeTagAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * ArgumentKind, ParamIdx ArgumentIdx, ParamIdx TypeTagIdx, bool IsPointer, SourceRange Range = {}, Spelling S = GNU_argument_with_type_tag);
1351   static ArgumentWithTypeTagAttr *Create(ASTContext &Ctx, IdentifierInfo * ArgumentKind, ParamIdx ArgumentIdx, ParamIdx TypeTagIdx, bool IsPointer, SourceRange Range = {}, Spelling S = GNU_argument_with_type_tag);
1352   static ArgumentWithTypeTagAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * ArgumentKind, ParamIdx ArgumentIdx, ParamIdx TypeTagIdx, const AttributeCommonInfo &CommonInfo);
1353   static ArgumentWithTypeTagAttr *Create(ASTContext &Ctx, IdentifierInfo * ArgumentKind, ParamIdx ArgumentIdx, ParamIdx TypeTagIdx, const AttributeCommonInfo &CommonInfo);
1354   static ArgumentWithTypeTagAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * ArgumentKind, ParamIdx ArgumentIdx, ParamIdx TypeTagIdx, SourceRange Range = {}, Spelling S = GNU_argument_with_type_tag);
1355   static ArgumentWithTypeTagAttr *Create(ASTContext &Ctx, IdentifierInfo * ArgumentKind, ParamIdx ArgumentIdx, ParamIdx TypeTagIdx, SourceRange Range = {}, Spelling S = GNU_argument_with_type_tag);
1356 
1357   // Constructors
1358   ArgumentWithTypeTagAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
1359               , IdentifierInfo * ArgumentKind
1360               , ParamIdx ArgumentIdx
1361               , ParamIdx TypeTagIdx
1362               , bool IsPointer
1363              );
1364   ArgumentWithTypeTagAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
1365               , IdentifierInfo * ArgumentKind
1366               , ParamIdx ArgumentIdx
1367               , ParamIdx TypeTagIdx
1368              );
1369 
1370   ArgumentWithTypeTagAttr *clone(ASTContext &C) const;
1371   void printPretty(raw_ostream &OS,
1372                    const PrintingPolicy &Policy) const;
1373   const char *getSpelling() const;
1374   Spelling getSemanticSpelling() const;
1375   IdentifierInfo * getArgumentKind() const {
1376     return argumentKind;
1377   }
1378 
1379   ParamIdx getArgumentIdx() const {
1380     return argumentIdx;
1381   }
1382 
1383   ParamIdx getTypeTagIdx() const {
1384     return typeTagIdx;
1385   }
1386 
1387   bool getIsPointer() const {
1388     return isPointer;
1389   }
1390 
1391 
1392 
1393   static bool classof(const Attr *A) { return A->getKind() == attr::ArgumentWithTypeTag; }
1394 };
1395 
1396 class CLANG_ABI ArmAgnosticAttr : public TypeAttr {
1397   unsigned agnosticArgs_Size;
1398   StringRef *agnosticArgs_;
1399 
1400 public:
1401   // Factory methods
1402   static ArmAgnosticAttr *CreateImplicit(ASTContext &Ctx, StringRef *AgnosticArgs, unsigned AgnosticArgsSize, const AttributeCommonInfo &CommonInfo);
1403   static ArmAgnosticAttr *Create(ASTContext &Ctx, StringRef *AgnosticArgs, unsigned AgnosticArgsSize, const AttributeCommonInfo &CommonInfo);
1404   static ArmAgnosticAttr *CreateImplicit(ASTContext &Ctx, StringRef *AgnosticArgs, unsigned AgnosticArgsSize, SourceRange Range = {});
1405   static ArmAgnosticAttr *Create(ASTContext &Ctx, StringRef *AgnosticArgs, unsigned AgnosticArgsSize, SourceRange Range = {});
1406 
1407   // Constructors
1408   ArmAgnosticAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
1409               , StringRef *AgnosticArgs, unsigned AgnosticArgsSize
1410              );
1411   ArmAgnosticAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
1412              );
1413 
1414   ArmAgnosticAttr *clone(ASTContext &C) const;
1415   void printPretty(raw_ostream &OS,
1416                    const PrintingPolicy &Policy) const;
1417   const char *getSpelling() const;
1418   typedef StringRef* agnosticArgs_iterator;
1419   agnosticArgs_iterator agnosticArgs_begin() const { return agnosticArgs_; }
1420   agnosticArgs_iterator agnosticArgs_end() const { return agnosticArgs_ + agnosticArgs_Size; }
1421   unsigned agnosticArgs_size() const { return agnosticArgs_Size; }
1422   llvm::iterator_range<agnosticArgs_iterator> agnosticArgs() const { return llvm::make_range(agnosticArgs_begin(), agnosticArgs_end()); }
1423 
1424 
1425 
1426 
1427   static bool classof(const Attr *A) { return A->getKind() == attr::ArmAgnostic; }
1428 };
1429 
1430 class CLANG_ABI ArmBuiltinAliasAttr : public InheritableAttr {
1431 IdentifierInfo * builtinName;
1432 
1433 public:
1434   enum Spelling {
1435     GNU_clang_arm_builtin_alias = 0,
1436     CXX11_clang_clang_arm_builtin_alias = 1,
1437     C23_clang_clang_arm_builtin_alias = 2,
1438   SpellingNotCalculated = 15
1439 
1440   };
1441 
1442   // Factory methods
1443   static ArmBuiltinAliasAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * BuiltinName, const AttributeCommonInfo &CommonInfo);
1444   static ArmBuiltinAliasAttr *Create(ASTContext &Ctx, IdentifierInfo * BuiltinName, const AttributeCommonInfo &CommonInfo);
1445   static ArmBuiltinAliasAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * BuiltinName, SourceRange Range = {}, Spelling S = GNU_clang_arm_builtin_alias);
1446   static ArmBuiltinAliasAttr *Create(ASTContext &Ctx, IdentifierInfo * BuiltinName, SourceRange Range = {}, Spelling S = GNU_clang_arm_builtin_alias);
1447 
1448   // Constructors
1449   ArmBuiltinAliasAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
1450               , IdentifierInfo * BuiltinName
1451              );
1452 
1453   ArmBuiltinAliasAttr *clone(ASTContext &C) const;
1454   void printPretty(raw_ostream &OS,
1455                    const PrintingPolicy &Policy) const;
1456   const char *getSpelling() const;
1457   IdentifierInfo * getBuiltinName() const {
1458     return builtinName;
1459   }
1460 
1461 
1462 
1463   static bool classof(const Attr *A) { return A->getKind() == attr::ArmBuiltinAlias; }
1464 };
1465 
1466 class CLANG_ABI ArmInAttr : public TypeAttr {
1467   unsigned inArgs_Size;
1468   StringRef *inArgs_;
1469 
1470 public:
1471   // Factory methods
1472   static ArmInAttr *CreateImplicit(ASTContext &Ctx, StringRef *InArgs, unsigned InArgsSize, const AttributeCommonInfo &CommonInfo);
1473   static ArmInAttr *Create(ASTContext &Ctx, StringRef *InArgs, unsigned InArgsSize, const AttributeCommonInfo &CommonInfo);
1474   static ArmInAttr *CreateImplicit(ASTContext &Ctx, StringRef *InArgs, unsigned InArgsSize, SourceRange Range = {});
1475   static ArmInAttr *Create(ASTContext &Ctx, StringRef *InArgs, unsigned InArgsSize, SourceRange Range = {});
1476 
1477   // Constructors
1478   ArmInAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
1479               , StringRef *InArgs, unsigned InArgsSize
1480              );
1481   ArmInAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
1482              );
1483 
1484   ArmInAttr *clone(ASTContext &C) const;
1485   void printPretty(raw_ostream &OS,
1486                    const PrintingPolicy &Policy) const;
1487   const char *getSpelling() const;
1488   typedef StringRef* inArgs_iterator;
1489   inArgs_iterator inArgs_begin() const { return inArgs_; }
1490   inArgs_iterator inArgs_end() const { return inArgs_ + inArgs_Size; }
1491   unsigned inArgs_size() const { return inArgs_Size; }
1492   llvm::iterator_range<inArgs_iterator> inArgs() const { return llvm::make_range(inArgs_begin(), inArgs_end()); }
1493 
1494 
1495 
1496 
1497   static bool classof(const Attr *A) { return A->getKind() == attr::ArmIn; }
1498 };
1499 
1500 class CLANG_ABI ArmInOutAttr : public TypeAttr {
1501   unsigned inOutArgs_Size;
1502   StringRef *inOutArgs_;
1503 
1504 public:
1505   // Factory methods
1506   static ArmInOutAttr *CreateImplicit(ASTContext &Ctx, StringRef *InOutArgs, unsigned InOutArgsSize, const AttributeCommonInfo &CommonInfo);
1507   static ArmInOutAttr *Create(ASTContext &Ctx, StringRef *InOutArgs, unsigned InOutArgsSize, const AttributeCommonInfo &CommonInfo);
1508   static ArmInOutAttr *CreateImplicit(ASTContext &Ctx, StringRef *InOutArgs, unsigned InOutArgsSize, SourceRange Range = {});
1509   static ArmInOutAttr *Create(ASTContext &Ctx, StringRef *InOutArgs, unsigned InOutArgsSize, SourceRange Range = {});
1510 
1511   // Constructors
1512   ArmInOutAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
1513               , StringRef *InOutArgs, unsigned InOutArgsSize
1514              );
1515   ArmInOutAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
1516              );
1517 
1518   ArmInOutAttr *clone(ASTContext &C) const;
1519   void printPretty(raw_ostream &OS,
1520                    const PrintingPolicy &Policy) const;
1521   const char *getSpelling() const;
1522   typedef StringRef* inOutArgs_iterator;
1523   inOutArgs_iterator inOutArgs_begin() const { return inOutArgs_; }
1524   inOutArgs_iterator inOutArgs_end() const { return inOutArgs_ + inOutArgs_Size; }
1525   unsigned inOutArgs_size() const { return inOutArgs_Size; }
1526   llvm::iterator_range<inOutArgs_iterator> inOutArgs() const { return llvm::make_range(inOutArgs_begin(), inOutArgs_end()); }
1527 
1528 
1529 
1530 
1531   static bool classof(const Attr *A) { return A->getKind() == attr::ArmInOut; }
1532 };
1533 
1534 class CLANG_ABI ArmLocallyStreamingAttr : public InheritableAttr {
1535 public:
1536   // Factory methods
1537   static ArmLocallyStreamingAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
1538   static ArmLocallyStreamingAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
1539   static ArmLocallyStreamingAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {});
1540   static ArmLocallyStreamingAttr *Create(ASTContext &Ctx, SourceRange Range = {});
1541 
1542   // Constructors
1543   ArmLocallyStreamingAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
1544              );
1545 
1546   ArmLocallyStreamingAttr *clone(ASTContext &C) const;
1547   void printPretty(raw_ostream &OS,
1548                    const PrintingPolicy &Policy) const;
1549   const char *getSpelling() const;
1550 
1551 
1552   static bool classof(const Attr *A) { return A->getKind() == attr::ArmLocallyStreaming; }
1553 };
1554 
1555 class CLANG_ABI ArmMveStrictPolymorphismAttr : public TypeAttr {
1556 public:
1557   enum Spelling {
1558     GNU_clang_arm_mve_strict_polymorphism = 0,
1559     CXX11_clang_clang_arm_mve_strict_polymorphism = 1,
1560     C23_clang_clang_arm_mve_strict_polymorphism = 2,
1561   SpellingNotCalculated = 15
1562 
1563   };
1564 
1565   // Factory methods
1566   static ArmMveStrictPolymorphismAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
1567   static ArmMveStrictPolymorphismAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
1568   static ArmMveStrictPolymorphismAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_clang_arm_mve_strict_polymorphism);
1569   static ArmMveStrictPolymorphismAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_clang_arm_mve_strict_polymorphism);
1570 
1571   // Constructors
1572   ArmMveStrictPolymorphismAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
1573              );
1574 
1575   ArmMveStrictPolymorphismAttr *clone(ASTContext &C) const;
1576   void printPretty(raw_ostream &OS,
1577                    const PrintingPolicy &Policy) const;
1578   const char *getSpelling() const;
1579 
1580 
1581   static bool classof(const Attr *A) { return A->getKind() == attr::ArmMveStrictPolymorphism; }
1582 };
1583 
1584 class CLANG_ABI ArmNewAttr : public InheritableAttr {
1585   unsigned newArgs_Size;
1586   StringRef *newArgs_;
1587 
1588 public:
1589   // Factory methods
1590   static ArmNewAttr *CreateImplicit(ASTContext &Ctx, StringRef *NewArgs, unsigned NewArgsSize, const AttributeCommonInfo &CommonInfo);
1591   static ArmNewAttr *Create(ASTContext &Ctx, StringRef *NewArgs, unsigned NewArgsSize, const AttributeCommonInfo &CommonInfo);
1592   static ArmNewAttr *CreateImplicit(ASTContext &Ctx, StringRef *NewArgs, unsigned NewArgsSize, SourceRange Range = {});
1593   static ArmNewAttr *Create(ASTContext &Ctx, StringRef *NewArgs, unsigned NewArgsSize, SourceRange Range = {});
1594 
1595   // Constructors
1596   ArmNewAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
1597               , StringRef *NewArgs, unsigned NewArgsSize
1598              );
1599   ArmNewAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
1600              );
1601 
1602   ArmNewAttr *clone(ASTContext &C) const;
1603   void printPretty(raw_ostream &OS,
1604                    const PrintingPolicy &Policy) const;
1605   const char *getSpelling() const;
1606   typedef StringRef* newArgs_iterator;
1607   newArgs_iterator newArgs_begin() const { return newArgs_; }
1608   newArgs_iterator newArgs_end() const { return newArgs_ + newArgs_Size; }
1609   unsigned newArgs_size() const { return newArgs_Size; }
1610   llvm::iterator_range<newArgs_iterator> newArgs() const { return llvm::make_range(newArgs_begin(), newArgs_end()); }
1611 
1612 
1613 
1614     bool isNewZA() const {
1615       return llvm::is_contained(newArgs(), "za");
1616     }
1617     bool isNewZT0() const {
1618       return llvm::is_contained(newArgs(), "zt0");
1619     }
1620   
1621 
1622   static bool classof(const Attr *A) { return A->getKind() == attr::ArmNew; }
1623 };
1624 
1625 class CLANG_ABI ArmOutAttr : public TypeAttr {
1626   unsigned outArgs_Size;
1627   StringRef *outArgs_;
1628 
1629 public:
1630   // Factory methods
1631   static ArmOutAttr *CreateImplicit(ASTContext &Ctx, StringRef *OutArgs, unsigned OutArgsSize, const AttributeCommonInfo &CommonInfo);
1632   static ArmOutAttr *Create(ASTContext &Ctx, StringRef *OutArgs, unsigned OutArgsSize, const AttributeCommonInfo &CommonInfo);
1633   static ArmOutAttr *CreateImplicit(ASTContext &Ctx, StringRef *OutArgs, unsigned OutArgsSize, SourceRange Range = {});
1634   static ArmOutAttr *Create(ASTContext &Ctx, StringRef *OutArgs, unsigned OutArgsSize, SourceRange Range = {});
1635 
1636   // Constructors
1637   ArmOutAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
1638               , StringRef *OutArgs, unsigned OutArgsSize
1639              );
1640   ArmOutAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
1641              );
1642 
1643   ArmOutAttr *clone(ASTContext &C) const;
1644   void printPretty(raw_ostream &OS,
1645                    const PrintingPolicy &Policy) const;
1646   const char *getSpelling() const;
1647   typedef StringRef* outArgs_iterator;
1648   outArgs_iterator outArgs_begin() const { return outArgs_; }
1649   outArgs_iterator outArgs_end() const { return outArgs_ + outArgs_Size; }
1650   unsigned outArgs_size() const { return outArgs_Size; }
1651   llvm::iterator_range<outArgs_iterator> outArgs() const { return llvm::make_range(outArgs_begin(), outArgs_end()); }
1652 
1653 
1654 
1655 
1656   static bool classof(const Attr *A) { return A->getKind() == attr::ArmOut; }
1657 };
1658 
1659 class CLANG_ABI ArmPreservesAttr : public TypeAttr {
1660   unsigned preserveArgs_Size;
1661   StringRef *preserveArgs_;
1662 
1663 public:
1664   // Factory methods
1665   static ArmPreservesAttr *CreateImplicit(ASTContext &Ctx, StringRef *PreserveArgs, unsigned PreserveArgsSize, const AttributeCommonInfo &CommonInfo);
1666   static ArmPreservesAttr *Create(ASTContext &Ctx, StringRef *PreserveArgs, unsigned PreserveArgsSize, const AttributeCommonInfo &CommonInfo);
1667   static ArmPreservesAttr *CreateImplicit(ASTContext &Ctx, StringRef *PreserveArgs, unsigned PreserveArgsSize, SourceRange Range = {});
1668   static ArmPreservesAttr *Create(ASTContext &Ctx, StringRef *PreserveArgs, unsigned PreserveArgsSize, SourceRange Range = {});
1669 
1670   // Constructors
1671   ArmPreservesAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
1672               , StringRef *PreserveArgs, unsigned PreserveArgsSize
1673              );
1674   ArmPreservesAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
1675              );
1676 
1677   ArmPreservesAttr *clone(ASTContext &C) const;
1678   void printPretty(raw_ostream &OS,
1679                    const PrintingPolicy &Policy) const;
1680   const char *getSpelling() const;
1681   typedef StringRef* preserveArgs_iterator;
1682   preserveArgs_iterator preserveArgs_begin() const { return preserveArgs_; }
1683   preserveArgs_iterator preserveArgs_end() const { return preserveArgs_ + preserveArgs_Size; }
1684   unsigned preserveArgs_size() const { return preserveArgs_Size; }
1685   llvm::iterator_range<preserveArgs_iterator> preserveArgs() const { return llvm::make_range(preserveArgs_begin(), preserveArgs_end()); }
1686 
1687 
1688 
1689 
1690   static bool classof(const Attr *A) { return A->getKind() == attr::ArmPreserves; }
1691 };
1692 
1693 class CLANG_ABI ArmStreamingAttr : public TypeAttr {
1694 public:
1695   // Factory methods
1696   static ArmStreamingAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
1697   static ArmStreamingAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
1698   static ArmStreamingAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {});
1699   static ArmStreamingAttr *Create(ASTContext &Ctx, SourceRange Range = {});
1700 
1701   // Constructors
1702   ArmStreamingAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
1703              );
1704 
1705   ArmStreamingAttr *clone(ASTContext &C) const;
1706   void printPretty(raw_ostream &OS,
1707                    const PrintingPolicy &Policy) const;
1708   const char *getSpelling() const;
1709 
1710 
1711   static bool classof(const Attr *A) { return A->getKind() == attr::ArmStreaming; }
1712 };
1713 
1714 class CLANG_ABI ArmStreamingCompatibleAttr : public TypeAttr {
1715 public:
1716   // Factory methods
1717   static ArmStreamingCompatibleAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
1718   static ArmStreamingCompatibleAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
1719   static ArmStreamingCompatibleAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {});
1720   static ArmStreamingCompatibleAttr *Create(ASTContext &Ctx, SourceRange Range = {});
1721 
1722   // Constructors
1723   ArmStreamingCompatibleAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
1724              );
1725 
1726   ArmStreamingCompatibleAttr *clone(ASTContext &C) const;
1727   void printPretty(raw_ostream &OS,
1728                    const PrintingPolicy &Policy) const;
1729   const char *getSpelling() const;
1730 
1731 
1732   static bool classof(const Attr *A) { return A->getKind() == attr::ArmStreamingCompatible; }
1733 };
1734 
1735 class CLANG_ABI ArtificialAttr : public InheritableAttr {
1736 public:
1737   enum Spelling {
1738     GNU_artificial = 0,
1739     CXX11_gnu_artificial = 1,
1740     C23_gnu_artificial = 2,
1741   SpellingNotCalculated = 15
1742 
1743   };
1744 
1745   // Factory methods
1746   static ArtificialAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
1747   static ArtificialAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
1748   static ArtificialAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_artificial);
1749   static ArtificialAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_artificial);
1750 
1751   // Constructors
1752   ArtificialAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
1753              );
1754 
1755   ArtificialAttr *clone(ASTContext &C) const;
1756   void printPretty(raw_ostream &OS,
1757                    const PrintingPolicy &Policy) const;
1758   const char *getSpelling() const;
1759 
1760 
1761   static bool classof(const Attr *A) { return A->getKind() == attr::Artificial; }
1762 };
1763 
1764 class CLANG_ABI AsmLabelAttr : public InheritableAttr {
1765 unsigned labelLength;
1766 char *label;
1767 
1768 bool isLiteralLabel;
1769 
1770 public:
1771   enum Spelling {
1772     Keyword_asm = 0,
1773   SpellingNotCalculated = 15
1774 
1775   };
1776 
1777   // Factory methods
1778   static AsmLabelAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Label, bool IsLiteralLabel, const AttributeCommonInfo &CommonInfo);
1779   static AsmLabelAttr *Create(ASTContext &Ctx, llvm::StringRef Label, bool IsLiteralLabel, const AttributeCommonInfo &CommonInfo);
1780   static AsmLabelAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Label, bool IsLiteralLabel, SourceRange Range = {}, Spelling S = Keyword_asm);
1781   static AsmLabelAttr *Create(ASTContext &Ctx, llvm::StringRef Label, bool IsLiteralLabel, SourceRange Range = {}, Spelling S = Keyword_asm);
1782   static AsmLabelAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Label, const AttributeCommonInfo &CommonInfo);
1783   static AsmLabelAttr *Create(ASTContext &Ctx, llvm::StringRef Label, const AttributeCommonInfo &CommonInfo);
1784   static AsmLabelAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Label, SourceRange Range = {}, Spelling S = Keyword_asm);
1785   static AsmLabelAttr *Create(ASTContext &Ctx, llvm::StringRef Label, SourceRange Range = {}, Spelling S = Keyword_asm);
1786 
1787   // Constructors
1788   AsmLabelAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
1789               , llvm::StringRef Label
1790               , bool IsLiteralLabel
1791              );
1792   AsmLabelAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
1793               , llvm::StringRef Label
1794              );
1795 
1796   AsmLabelAttr *clone(ASTContext &C) const;
1797   void printPretty(raw_ostream &OS,
1798                    const PrintingPolicy &Policy) const;
1799   const char *getSpelling() const;
1800   llvm::StringRef getLabel() const {
1801     return llvm::StringRef(label, labelLength);
1802   }
1803   unsigned getLabelLength() const {
1804     return labelLength;
1805   }
1806   void setLabel(ASTContext &C, llvm::StringRef S) {
1807     labelLength = S.size();
1808     this->label = new (C, 1) char [labelLength];
1809     if (!S.empty())
1810       std::memcpy(this->label, S.data(), labelLength);
1811   }
1812 
1813   bool getIsLiteralLabel() const {
1814     return isLiteralLabel;
1815   }
1816 
1817 
1818 bool isEquivalent(AsmLabelAttr *Other) const {
1819   return getLabel() == Other->getLabel() && getIsLiteralLabel() == Other->getIsLiteralLabel();
1820 }
1821 
1822 
1823   static bool classof(const Attr *A) { return A->getKind() == attr::AsmLabel; }
1824 };
1825 
1826 class CLANG_ABI AssertCapabilityAttr : public InheritableAttr {
1827   unsigned args_Size;
1828   Expr * *args_;
1829 
1830 public:
1831   enum Spelling {
1832     GNU_assert_capability = 0,
1833     CXX11_clang_assert_capability = 1,
1834     GNU_assert_shared_capability = 2,
1835     CXX11_clang_assert_shared_capability = 3,
1836   SpellingNotCalculated = 15
1837 
1838   };
1839 
1840   // Factory methods
1841   static AssertCapabilityAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo);
1842   static AssertCapabilityAttr *Create(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo);
1843   static AssertCapabilityAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Range = {}, Spelling S = GNU_assert_capability);
1844   static AssertCapabilityAttr *Create(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Range = {}, Spelling S = GNU_assert_capability);
1845 
1846   // Constructors
1847   AssertCapabilityAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
1848               , Expr * *Args, unsigned ArgsSize
1849              );
1850   AssertCapabilityAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
1851              );
1852 
1853   AssertCapabilityAttr *clone(ASTContext &C) const;
1854   void printPretty(raw_ostream &OS,
1855                    const PrintingPolicy &Policy) const;
1856   const char *getSpelling() const;
1857   Spelling getSemanticSpelling() const;
1858   bool isShared() const { return getAttributeSpellingListIndex() == 2 ||
1859     getAttributeSpellingListIndex() == 3; }
1860   typedef Expr ** args_iterator;
1861   args_iterator args_begin() const { return args_; }
1862   args_iterator args_end() const { return args_ + args_Size; }
1863   unsigned args_size() const { return args_Size; }
1864   llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }
1865 
1866 
1867 
1868 
1869   static bool classof(const Attr *A) { return A->getKind() == attr::AssertCapability; }
1870 };
1871 
1872 class CLANG_ABI AssertExclusiveLockAttr : public InheritableAttr {
1873   unsigned args_Size;
1874   Expr * *args_;
1875 
1876 public:
1877   // Factory methods
1878   static AssertExclusiveLockAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo);
1879   static AssertExclusiveLockAttr *Create(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo);
1880   static AssertExclusiveLockAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Range = {});
1881   static AssertExclusiveLockAttr *Create(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Range = {});
1882 
1883   // Constructors
1884   AssertExclusiveLockAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
1885               , Expr * *Args, unsigned ArgsSize
1886              );
1887   AssertExclusiveLockAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
1888              );
1889 
1890   AssertExclusiveLockAttr *clone(ASTContext &C) const;
1891   void printPretty(raw_ostream &OS,
1892                    const PrintingPolicy &Policy) const;
1893   const char *getSpelling() const;
1894   typedef Expr ** args_iterator;
1895   args_iterator args_begin() const { return args_; }
1896   args_iterator args_end() const { return args_ + args_Size; }
1897   unsigned args_size() const { return args_Size; }
1898   llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }
1899 
1900 
1901 
1902 
1903   static bool classof(const Attr *A) { return A->getKind() == attr::AssertExclusiveLock; }
1904 };
1905 
1906 class CLANG_ABI AssertSharedLockAttr : public InheritableAttr {
1907   unsigned args_Size;
1908   Expr * *args_;
1909 
1910 public:
1911   // Factory methods
1912   static AssertSharedLockAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo);
1913   static AssertSharedLockAttr *Create(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo);
1914   static AssertSharedLockAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Range = {});
1915   static AssertSharedLockAttr *Create(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Range = {});
1916 
1917   // Constructors
1918   AssertSharedLockAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
1919               , Expr * *Args, unsigned ArgsSize
1920              );
1921   AssertSharedLockAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
1922              );
1923 
1924   AssertSharedLockAttr *clone(ASTContext &C) const;
1925   void printPretty(raw_ostream &OS,
1926                    const PrintingPolicy &Policy) const;
1927   const char *getSpelling() const;
1928   typedef Expr ** args_iterator;
1929   args_iterator args_begin() const { return args_; }
1930   args_iterator args_end() const { return args_ + args_Size; }
1931   unsigned args_size() const { return args_Size; }
1932   llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }
1933 
1934 
1935 
1936 
1937   static bool classof(const Attr *A) { return A->getKind() == attr::AssertSharedLock; }
1938 };
1939 
1940 class CLANG_ABI AssumeAlignedAttr : public InheritableAttr {
1941 Expr * alignment;
1942 
1943 Expr * offset;
1944 
1945 public:
1946   enum Spelling {
1947     GNU_assume_aligned = 0,
1948     CXX11_gnu_assume_aligned = 1,
1949     C23_gnu_assume_aligned = 2,
1950   SpellingNotCalculated = 15
1951 
1952   };
1953 
1954   // Factory methods
1955   static AssumeAlignedAttr *CreateImplicit(ASTContext &Ctx, Expr * Alignment, Expr * Offset, const AttributeCommonInfo &CommonInfo);
1956   static AssumeAlignedAttr *Create(ASTContext &Ctx, Expr * Alignment, Expr * Offset, const AttributeCommonInfo &CommonInfo);
1957   static AssumeAlignedAttr *CreateImplicit(ASTContext &Ctx, Expr * Alignment, Expr * Offset, SourceRange Range = {}, Spelling S = GNU_assume_aligned);
1958   static AssumeAlignedAttr *Create(ASTContext &Ctx, Expr * Alignment, Expr * Offset, SourceRange Range = {}, Spelling S = GNU_assume_aligned);
1959 
1960   // Constructors
1961   AssumeAlignedAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
1962               , Expr * Alignment
1963               , Expr * Offset
1964              );
1965   AssumeAlignedAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
1966               , Expr * Alignment
1967              );
1968 
1969   AssumeAlignedAttr *clone(ASTContext &C) const;
1970   void printPretty(raw_ostream &OS,
1971                    const PrintingPolicy &Policy) const;
1972   const char *getSpelling() const;
1973   Expr * getAlignment() const {
1974     return alignment;
1975   }
1976 
1977   Expr * getOffset() const {
1978     return offset;
1979   }
1980 
1981 
1982 
1983   static bool classof(const Attr *A) { return A->getKind() == attr::AssumeAligned; }
1984 };
1985 
1986 class CLANG_ABI AvailabilityAttr : public InheritableAttr {
1987 IdentifierInfo * platform;
1988 
1989 VersionTuple introduced;
1990 
1991 
1992 VersionTuple deprecated;
1993 
1994 
1995 VersionTuple obsoleted;
1996 
1997 
1998 bool unavailable;
1999 
2000 unsigned messageLength;
2001 char *message;
2002 
2003 bool strict;
2004 
2005 unsigned replacementLength;
2006 char *replacement;
2007 
2008 int priority;
2009 
2010 IdentifierInfo * environment;
2011 
2012 public:
2013   enum Spelling {
2014     GNU_availability = 0,
2015     CXX11_clang_availability = 1,
2016     C23_clang_availability = 2,
2017   SpellingNotCalculated = 15
2018 
2019   };
2020 
2021   // Factory methods
2022   static AvailabilityAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * Platform, VersionTuple Introduced, VersionTuple Deprecated, VersionTuple Obsoleted, bool Unavailable, llvm::StringRef Message, bool Strict, llvm::StringRef Replacement, int Priority, IdentifierInfo * Environment, const AttributeCommonInfo &CommonInfo);
2023   static AvailabilityAttr *Create(ASTContext &Ctx, IdentifierInfo * Platform, VersionTuple Introduced, VersionTuple Deprecated, VersionTuple Obsoleted, bool Unavailable, llvm::StringRef Message, bool Strict, llvm::StringRef Replacement, int Priority, IdentifierInfo * Environment, const AttributeCommonInfo &CommonInfo);
2024   static AvailabilityAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * Platform, VersionTuple Introduced, VersionTuple Deprecated, VersionTuple Obsoleted, bool Unavailable, llvm::StringRef Message, bool Strict, llvm::StringRef Replacement, int Priority, IdentifierInfo * Environment, SourceRange Range = {}, Spelling S = GNU_availability);
2025   static AvailabilityAttr *Create(ASTContext &Ctx, IdentifierInfo * Platform, VersionTuple Introduced, VersionTuple Deprecated, VersionTuple Obsoleted, bool Unavailable, llvm::StringRef Message, bool Strict, llvm::StringRef Replacement, int Priority, IdentifierInfo * Environment, SourceRange Range = {}, Spelling S = GNU_availability);
2026 
2027   // Constructors
2028   AvailabilityAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
2029               , IdentifierInfo * Platform
2030               , VersionTuple Introduced
2031               , VersionTuple Deprecated
2032               , VersionTuple Obsoleted
2033               , bool Unavailable
2034               , llvm::StringRef Message
2035               , bool Strict
2036               , llvm::StringRef Replacement
2037               , int Priority
2038               , IdentifierInfo * Environment
2039              );
2040 
2041   AvailabilityAttr *clone(ASTContext &C) const;
2042   void printPretty(raw_ostream &OS,
2043                    const PrintingPolicy &Policy) const;
2044   const char *getSpelling() const;
2045   IdentifierInfo * getPlatform() const {
2046     return platform;
2047   }
2048 
2049   VersionTuple getIntroduced() const {
2050     return introduced;
2051   }
2052   void setIntroduced(ASTContext &C, VersionTuple V) {
2053     introduced = V;
2054   }
2055 
2056   VersionTuple getDeprecated() const {
2057     return deprecated;
2058   }
2059   void setDeprecated(ASTContext &C, VersionTuple V) {
2060     deprecated = V;
2061   }
2062 
2063   VersionTuple getObsoleted() const {
2064     return obsoleted;
2065   }
2066   void setObsoleted(ASTContext &C, VersionTuple V) {
2067     obsoleted = V;
2068   }
2069 
2070   bool getUnavailable() const {
2071     return unavailable;
2072   }
2073 
2074   llvm::StringRef getMessage() const {
2075     return llvm::StringRef(message, messageLength);
2076   }
2077   unsigned getMessageLength() const {
2078     return messageLength;
2079   }
2080   void setMessage(ASTContext &C, llvm::StringRef S) {
2081     messageLength = S.size();
2082     this->message = new (C, 1) char [messageLength];
2083     if (!S.empty())
2084       std::memcpy(this->message, S.data(), messageLength);
2085   }
2086 
2087   bool getStrict() const {
2088     return strict;
2089   }
2090 
2091   llvm::StringRef getReplacement() const {
2092     return llvm::StringRef(replacement, replacementLength);
2093   }
2094   unsigned getReplacementLength() const {
2095     return replacementLength;
2096   }
2097   void setReplacement(ASTContext &C, llvm::StringRef S) {
2098     replacementLength = S.size();
2099     this->replacement = new (C, 1) char [replacementLength];
2100     if (!S.empty())
2101       std::memcpy(this->replacement, S.data(), replacementLength);
2102   }
2103 
2104   int getPriority() const {
2105     return priority;
2106   }
2107 
2108   IdentifierInfo * getEnvironment() const {
2109     return environment;
2110   }
2111 
2112 static llvm::StringRef getPrettyPlatformName(llvm::StringRef Platform) {
2113     return llvm::StringSwitch<llvm::StringRef>(Platform)
2114              .Case("android", "Android")
2115              .Case("fuchsia", "Fuchsia")
2116              .Case("ios", "iOS")
2117              .Case("macos", "macOS")
2118              .Case("tvos", "tvOS")
2119              .Case("watchos", "watchOS")
2120              .Case("driverkit", "DriverKit")
2121              .Case("ios_app_extension", "iOS (App Extension)")
2122              .Case("macos_app_extension", "macOS (App Extension)")
2123              .Case("tvos_app_extension", "tvOS (App Extension)")
2124              .Case("watchos_app_extension", "watchOS (App Extension)")
2125              .Case("maccatalyst", "macCatalyst")
2126              .Case("maccatalyst_app_extension", "macCatalyst (App Extension)")
2127              .Case("xros", "visionOS")
2128              .Case("xros_app_extension", "visionOS (App Extension)")
2129              .Case("swift", "Swift")
2130              .Case("shadermodel", "Shader Model")
2131              .Case("ohos", "OpenHarmony OS")
2132              .Default(llvm::StringRef());
2133 }
2134 static llvm::StringRef getPlatformNameSourceSpelling(llvm::StringRef Platform) {
2135     return llvm::StringSwitch<llvm::StringRef>(Platform)
2136              .Case("ios", "iOS")
2137              .Case("macos", "macOS")
2138              .Case("tvos", "tvOS")
2139              .Case("watchos", "watchOS")
2140              .Case("ios_app_extension", "iOSApplicationExtension")
2141              .Case("macos_app_extension", "macOSApplicationExtension")
2142              .Case("tvos_app_extension", "tvOSApplicationExtension")
2143              .Case("watchos_app_extension", "watchOSApplicationExtension")
2144              .Case("maccatalyst", "macCatalyst")
2145              .Case("maccatalyst_app_extension", "macCatalystApplicationExtension")
2146              .Case("xros", "visionOS")
2147              .Case("xros_app_extension", "visionOSApplicationExtension")
2148              .Case("zos", "z/OS")
2149              .Case("shadermodel", "ShaderModel")
2150              .Default(Platform);
2151 }
2152 static llvm::StringRef canonicalizePlatformName(llvm::StringRef Platform) {
2153     return llvm::StringSwitch<llvm::StringRef>(Platform)
2154              .Case("iOS", "ios")
2155              .Case("macOS", "macos")
2156              .Case("tvOS", "tvos")
2157              .Case("watchOS", "watchos")
2158              .Case("iOSApplicationExtension", "ios_app_extension")
2159              .Case("macOSApplicationExtension", "macos_app_extension")
2160              .Case("tvOSApplicationExtension", "tvos_app_extension")
2161              .Case("watchOSApplicationExtension", "watchos_app_extension")
2162              .Case("macCatalyst", "maccatalyst")
2163              .Case("macCatalystApplicationExtension", "maccatalyst_app_extension")
2164              .Case("visionOS", "xros")
2165              .Case("visionOSApplicationExtension", "xros_app_extension")
2166              .Case("visionos", "xros")
2167              .Case("visionos_app_extension", "xros_app_extension")
2168              .Case("ShaderModel", "shadermodel")
2169              .Default(Platform);
2170 }
2171 static std::vector<llvm::StringRef> equivalentPlatformNames(llvm::StringRef Platform) {
2172     return llvm::StringSwitch<std::vector<llvm::StringRef>>(Platform)
2173              .Case("ios", {"ios", "iOS"})
2174              .Case("iOS", {"ios", "iOS"})
2175              .Case("macos", {"macos", "macOS"})
2176              .Case("macOS", {"macos", "macOS"})
2177              .Case("tvos", {"tvos", "tvOS"})
2178              .Case("tvOS", {"tvos", "tvOS"})
2179              .Case("watchos", {"watchos", "watchOS"})
2180              .Case("watchOS", {"watchos", "watchOS"})
2181              .Case("ios_app_extension", {"iOSApplicationExtension", "ios_app_extension"})
2182              .Case("iOSApplicationExtension", {"iOSApplicationExtension", "ios_app_extension"})
2183              .Case("macos_app_extension", {"macOSApplicationExtension", "macos_app_extension"})
2184              .Case("macOSApplicationExtension", {"macOSApplicationExtension", "macos_app_extension"})
2185              .Case("tvos_app_extension", {"tvOSApplicationExtension", "tvos_app_extension"})
2186              .Case("tvOSApplicationExtension", {"tvOSApplicationExtension", "tvos_app_extension"})
2187              .Case("watchos_app_extension", {"watchOSApplicationExtension", "watchos_app_extension"})
2188              .Case("watchOSApplicationExtension", {"watchOSApplicationExtension", "watchos_app_extension"})
2189              .Case("maccatalyst", {"macCatalyst", "maccatalyst"})
2190              .Case("macCatalyst", {"macCatalyst", "maccatalyst"})
2191              .Case("maccatalyst_app_extension", {"macCatalystApplicationExtension", "maccatalyst_app_extension"})
2192              .Case("macCatalystApplicationExtension", {"macCatalystApplicationExtension", "maccatalyst_app_extension"})
2193              .Case("xros", {"visionos", "visionOS", "xros"})
2194              .Case("visionOS", {"visionos", "visionOS", "xros"})
2195              .Case("visionos", {"visionos", "visionOS", "xros"})
2196              .Case("xros_app_extension", {"visionOSApplicationExtension", "visionos_app_extension", "xros_app_extension"})
2197              .Case("visionOSApplicationExtension", {"visionOSApplicationExtension", "visionos_app_extension", "xros_app_extension"})
2198              .Case("visionos_app_extension", {"visionOSApplicationExtension", "visionos_app_extension", "xros_app_extension"})
2199              .Default({Platform});
2200 }
2201 static llvm::Triple::EnvironmentType getEnvironmentType(llvm::StringRef Environment) {
2202     return llvm::StringSwitch<llvm::Triple::EnvironmentType>(Environment)
2203              .Case("pixel", llvm::Triple::Pixel)
2204              .Case("vertex", llvm::Triple::Vertex)
2205              .Case("geometry", llvm::Triple::Geometry)
2206              .Case("hull", llvm::Triple::Hull)
2207              .Case("domain", llvm::Triple::Domain)
2208              .Case("compute", llvm::Triple::Compute)
2209              .Case("raygeneration", llvm::Triple::RayGeneration)
2210              .Case("intersection", llvm::Triple::Intersection)
2211              .Case("anyhit", llvm::Triple::AnyHit)
2212              .Case("closesthit", llvm::Triple::ClosestHit)
2213              .Case("miss", llvm::Triple::Miss)
2214              .Case("callable", llvm::Triple::Callable)
2215              .Case("mesh", llvm::Triple::Mesh)
2216              .Case("amplification", llvm::Triple::Amplification)
2217              .Case("library", llvm::Triple::Library)
2218              .Default(llvm::Triple::UnknownEnvironment);
2219 }
2220 
2221 
2222   static bool classof(const Attr *A) { return A->getKind() == attr::Availability; }
2223 };
2224 
2225 class CLANG_ABI AvailableOnlyInDefaultEvalMethodAttr : public InheritableAttr {
2226 public:
2227   enum Spelling {
2228     GNU_available_only_in_default_eval_method = 0,
2229     CXX11_clang_available_only_in_default_eval_method = 1,
2230     C23_clang_available_only_in_default_eval_method = 2,
2231   SpellingNotCalculated = 15
2232 
2233   };
2234 
2235   // Factory methods
2236   static AvailableOnlyInDefaultEvalMethodAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
2237   static AvailableOnlyInDefaultEvalMethodAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
2238   static AvailableOnlyInDefaultEvalMethodAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_available_only_in_default_eval_method);
2239   static AvailableOnlyInDefaultEvalMethodAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_available_only_in_default_eval_method);
2240 
2241   // Constructors
2242   AvailableOnlyInDefaultEvalMethodAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
2243              );
2244 
2245   AvailableOnlyInDefaultEvalMethodAttr *clone(ASTContext &C) const;
2246   void printPretty(raw_ostream &OS,
2247                    const PrintingPolicy &Policy) const;
2248   const char *getSpelling() const;
2249 
2250 
2251   static bool classof(const Attr *A) { return A->getKind() == attr::AvailableOnlyInDefaultEvalMethod; }
2252 };
2253 
2254 class CLANG_ABI BPFFastCallAttr : public InheritableAttr {
2255 public:
2256   enum Spelling {
2257     GNU_bpf_fastcall = 0,
2258     CXX11_clang_bpf_fastcall = 1,
2259     C23_clang_bpf_fastcall = 2,
2260   SpellingNotCalculated = 15
2261 
2262   };
2263 
2264   // Factory methods
2265   static BPFFastCallAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
2266   static BPFFastCallAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
2267   static BPFFastCallAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_bpf_fastcall);
2268   static BPFFastCallAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_bpf_fastcall);
2269 
2270   // Constructors
2271   BPFFastCallAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
2272              );
2273 
2274   BPFFastCallAttr *clone(ASTContext &C) const;
2275   void printPretty(raw_ostream &OS,
2276                    const PrintingPolicy &Policy) const;
2277   const char *getSpelling() const;
2278 
2279 
2280   static bool classof(const Attr *A) { return A->getKind() == attr::BPFFastCall; }
2281 };
2282 
2283 class CLANG_ABI BPFPreserveAccessIndexAttr : public InheritableAttr {
2284 public:
2285   enum Spelling {
2286     GNU_preserve_access_index = 0,
2287     CXX11_clang_preserve_access_index = 1,
2288     C23_clang_preserve_access_index = 2,
2289   SpellingNotCalculated = 15
2290 
2291   };
2292 
2293   // Factory methods
2294   static BPFPreserveAccessIndexAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
2295   static BPFPreserveAccessIndexAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
2296   static BPFPreserveAccessIndexAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_preserve_access_index);
2297   static BPFPreserveAccessIndexAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_preserve_access_index);
2298 
2299   // Constructors
2300   BPFPreserveAccessIndexAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
2301              );
2302 
2303   BPFPreserveAccessIndexAttr *clone(ASTContext &C) const;
2304   void printPretty(raw_ostream &OS,
2305                    const PrintingPolicy &Policy) const;
2306   const char *getSpelling() const;
2307 
2308 
2309   static bool classof(const Attr *A) { return A->getKind() == attr::BPFPreserveAccessIndex; }
2310 };
2311 
2312 class CLANG_ABI BPFPreserveStaticOffsetAttr : public InheritableAttr {
2313 public:
2314   enum Spelling {
2315     GNU_preserve_static_offset = 0,
2316     CXX11_clang_preserve_static_offset = 1,
2317     C23_clang_preserve_static_offset = 2,
2318   SpellingNotCalculated = 15
2319 
2320   };
2321 
2322   // Factory methods
2323   static BPFPreserveStaticOffsetAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
2324   static BPFPreserveStaticOffsetAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
2325   static BPFPreserveStaticOffsetAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_preserve_static_offset);
2326   static BPFPreserveStaticOffsetAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_preserve_static_offset);
2327 
2328   // Constructors
2329   BPFPreserveStaticOffsetAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
2330              );
2331 
2332   BPFPreserveStaticOffsetAttr *clone(ASTContext &C) const;
2333   void printPretty(raw_ostream &OS,
2334                    const PrintingPolicy &Policy) const;
2335   const char *getSpelling() const;
2336 
2337 
2338   static bool classof(const Attr *A) { return A->getKind() == attr::BPFPreserveStaticOffset; }
2339 };
2340 
2341 class CLANG_ABI BTFDeclTagAttr : public InheritableAttr {
2342 unsigned bTFDeclTagLength;
2343 char *bTFDeclTag;
2344 
2345 public:
2346   enum Spelling {
2347     GNU_btf_decl_tag = 0,
2348     CXX11_clang_btf_decl_tag = 1,
2349     C23_clang_btf_decl_tag = 2,
2350   SpellingNotCalculated = 15
2351 
2352   };
2353 
2354   // Factory methods
2355   static BTFDeclTagAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef BTFDeclTag, const AttributeCommonInfo &CommonInfo);
2356   static BTFDeclTagAttr *Create(ASTContext &Ctx, llvm::StringRef BTFDeclTag, const AttributeCommonInfo &CommonInfo);
2357   static BTFDeclTagAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef BTFDeclTag, SourceRange Range = {}, Spelling S = GNU_btf_decl_tag);
2358   static BTFDeclTagAttr *Create(ASTContext &Ctx, llvm::StringRef BTFDeclTag, SourceRange Range = {}, Spelling S = GNU_btf_decl_tag);
2359 
2360   // Constructors
2361   BTFDeclTagAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
2362               , llvm::StringRef BTFDeclTag
2363              );
2364 
2365   BTFDeclTagAttr *clone(ASTContext &C) const;
2366   void printPretty(raw_ostream &OS,
2367                    const PrintingPolicy &Policy) const;
2368   const char *getSpelling() const;
2369   llvm::StringRef getBTFDeclTag() const {
2370     return llvm::StringRef(bTFDeclTag, bTFDeclTagLength);
2371   }
2372   unsigned getBTFDeclTagLength() const {
2373     return bTFDeclTagLength;
2374   }
2375   void setBTFDeclTag(ASTContext &C, llvm::StringRef S) {
2376     bTFDeclTagLength = S.size();
2377     this->bTFDeclTag = new (C, 1) char [bTFDeclTagLength];
2378     if (!S.empty())
2379       std::memcpy(this->bTFDeclTag, S.data(), bTFDeclTagLength);
2380   }
2381 
2382 
2383 
2384   static bool classof(const Attr *A) { return A->getKind() == attr::BTFDeclTag; }
2385 };
2386 
2387 class CLANG_ABI BTFTypeTagAttr : public TypeAttr {
2388 unsigned bTFTypeTagLength;
2389 char *bTFTypeTag;
2390 
2391 public:
2392   enum Spelling {
2393     GNU_btf_type_tag = 0,
2394     CXX11_clang_btf_type_tag = 1,
2395     C23_clang_btf_type_tag = 2,
2396   SpellingNotCalculated = 15
2397 
2398   };
2399 
2400   // Factory methods
2401   static BTFTypeTagAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef BTFTypeTag, const AttributeCommonInfo &CommonInfo);
2402   static BTFTypeTagAttr *Create(ASTContext &Ctx, llvm::StringRef BTFTypeTag, const AttributeCommonInfo &CommonInfo);
2403   static BTFTypeTagAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef BTFTypeTag, SourceRange Range = {}, Spelling S = GNU_btf_type_tag);
2404   static BTFTypeTagAttr *Create(ASTContext &Ctx, llvm::StringRef BTFTypeTag, SourceRange Range = {}, Spelling S = GNU_btf_type_tag);
2405 
2406   // Constructors
2407   BTFTypeTagAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
2408               , llvm::StringRef BTFTypeTag
2409              );
2410 
2411   BTFTypeTagAttr *clone(ASTContext &C) const;
2412   void printPretty(raw_ostream &OS,
2413                    const PrintingPolicy &Policy) const;
2414   const char *getSpelling() const;
2415   llvm::StringRef getBTFTypeTag() const {
2416     return llvm::StringRef(bTFTypeTag, bTFTypeTagLength);
2417   }
2418   unsigned getBTFTypeTagLength() const {
2419     return bTFTypeTagLength;
2420   }
2421   void setBTFTypeTag(ASTContext &C, llvm::StringRef S) {
2422     bTFTypeTagLength = S.size();
2423     this->bTFTypeTag = new (C, 1) char [bTFTypeTagLength];
2424     if (!S.empty())
2425       std::memcpy(this->bTFTypeTag, S.data(), bTFTypeTagLength);
2426   }
2427 
2428 
2429 
2430   static bool classof(const Attr *A) { return A->getKind() == attr::BTFTypeTag; }
2431 };
2432 
2433 class CLANG_ABI BlockingAttr : public TypeAttr {
2434 public:
2435   enum Spelling {
2436     GNU_blocking = 0,
2437     CXX11_clang_blocking = 1,
2438     C23_clang_blocking = 2,
2439   SpellingNotCalculated = 15
2440 
2441   };
2442 
2443   // Factory methods
2444   static BlockingAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
2445   static BlockingAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
2446   static BlockingAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_blocking);
2447   static BlockingAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_blocking);
2448 
2449   // Constructors
2450   BlockingAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
2451              );
2452 
2453   BlockingAttr *clone(ASTContext &C) const;
2454   void printPretty(raw_ostream &OS,
2455                    const PrintingPolicy &Policy) const;
2456   const char *getSpelling() const;
2457 
2458 
2459   static bool classof(const Attr *A) { return A->getKind() == attr::Blocking; }
2460 };
2461 
2462 class CLANG_ABI BlocksAttr : public InheritableAttr {
2463 public:
2464   enum BlockType {
2465     ByRef
2466   };
2467 private:
2468   BlocksAttr::BlockType type;
2469 
2470 public:
2471   enum Spelling {
2472     GNU_blocks = 0,
2473     CXX11_clang_blocks = 1,
2474     C23_clang_blocks = 2,
2475   SpellingNotCalculated = 15
2476 
2477   };
2478 
2479   // Factory methods
2480   static BlocksAttr *CreateImplicit(ASTContext &Ctx, BlocksAttr::BlockType Type, const AttributeCommonInfo &CommonInfo);
2481   static BlocksAttr *Create(ASTContext &Ctx, BlocksAttr::BlockType Type, const AttributeCommonInfo &CommonInfo);
2482   static BlocksAttr *CreateImplicit(ASTContext &Ctx, BlocksAttr::BlockType Type, SourceRange Range = {}, Spelling S = GNU_blocks);
2483   static BlocksAttr *Create(ASTContext &Ctx, BlocksAttr::BlockType Type, SourceRange Range = {}, Spelling S = GNU_blocks);
2484 
2485   // Constructors
2486   BlocksAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
2487               , BlocksAttr::BlockType Type
2488              );
2489 
2490   BlocksAttr *clone(ASTContext &C) const;
2491   void printPretty(raw_ostream &OS,
2492                    const PrintingPolicy &Policy) const;
2493   const char *getSpelling() const;
2494   BlocksAttr::BlockType getType() const {
2495     return type;
2496   }
2497 
2498   static bool ConvertStrToBlockType(StringRef Val, BlocksAttr::BlockType &Out);
2499   static const char *ConvertBlockTypeToStr(BlocksAttr::BlockType Val);
2500 
2501 
2502   static bool classof(const Attr *A) { return A->getKind() == attr::Blocks; }
2503 };
2504 
2505 class CLANG_ABI BuiltinAttr : public InheritableAttr {
2506 unsigned iD;
2507 
2508 public:
2509   // Factory methods
2510   static BuiltinAttr *CreateImplicit(ASTContext &Ctx, unsigned ID, const AttributeCommonInfo &CommonInfo);
2511   static BuiltinAttr *Create(ASTContext &Ctx, unsigned ID, const AttributeCommonInfo &CommonInfo);
2512   static BuiltinAttr *CreateImplicit(ASTContext &Ctx, unsigned ID, SourceRange Range = {});
2513   static BuiltinAttr *Create(ASTContext &Ctx, unsigned ID, SourceRange Range = {});
2514 
2515   // Constructors
2516   BuiltinAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
2517               , unsigned ID
2518              );
2519 
2520   BuiltinAttr *clone(ASTContext &C) const;
2521   void printPretty(raw_ostream &OS,
2522                    const PrintingPolicy &Policy) const;
2523   const char *getSpelling() const;
2524   unsigned getID() const {
2525     return iD;
2526   }
2527 
2528 
2529 
2530   static bool classof(const Attr *A) { return A->getKind() == attr::Builtin; }
2531 };
2532 
2533 class CLANG_ABI BuiltinAliasAttr : public Attr {
2534 IdentifierInfo * builtinName;
2535 
2536 public:
2537   enum Spelling {
2538     CXX11_clang_builtin_alias = 0,
2539     C23_clang_builtin_alias = 1,
2540     GNU_clang_builtin_alias = 2,
2541   SpellingNotCalculated = 15
2542 
2543   };
2544 
2545   // Factory methods
2546   static BuiltinAliasAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * BuiltinName, const AttributeCommonInfo &CommonInfo);
2547   static BuiltinAliasAttr *Create(ASTContext &Ctx, IdentifierInfo * BuiltinName, const AttributeCommonInfo &CommonInfo);
2548   static BuiltinAliasAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * BuiltinName, SourceRange Range = {}, Spelling S = CXX11_clang_builtin_alias);
2549   static BuiltinAliasAttr *Create(ASTContext &Ctx, IdentifierInfo * BuiltinName, SourceRange Range = {}, Spelling S = CXX11_clang_builtin_alias);
2550 
2551   // Constructors
2552   BuiltinAliasAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
2553               , IdentifierInfo * BuiltinName
2554              );
2555 
2556   BuiltinAliasAttr *clone(ASTContext &C) const;
2557   void printPretty(raw_ostream &OS,
2558                    const PrintingPolicy &Policy) const;
2559   const char *getSpelling() const;
2560   Spelling getSemanticSpelling() const;
2561   IdentifierInfo * getBuiltinName() const {
2562     return builtinName;
2563   }
2564 
2565 
2566 
2567   static bool classof(const Attr *A) { return A->getKind() == attr::BuiltinAlias; }
2568 };
2569 
2570 class CLANG_ABI C11NoReturnAttr : public InheritableAttr {
2571 public:
2572   // Factory methods
2573   static C11NoReturnAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
2574   static C11NoReturnAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
2575   static C11NoReturnAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {});
2576   static C11NoReturnAttr *Create(ASTContext &Ctx, SourceRange Range = {});
2577 
2578   // Constructors
2579   C11NoReturnAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
2580              );
2581 
2582   C11NoReturnAttr *clone(ASTContext &C) const;
2583   void printPretty(raw_ostream &OS,
2584                    const PrintingPolicy &Policy) const;
2585   const char *getSpelling() const;
2586 
2587 
2588   static bool classof(const Attr *A) { return A->getKind() == attr::C11NoReturn; }
2589 };
2590 
2591 class CLANG_ABI CDeclAttr : public InheritableAttr {
2592 public:
2593   enum Spelling {
2594     GNU_cdecl = 0,
2595     CXX11_gnu_cdecl = 1,
2596     C23_gnu_cdecl = 2,
2597     Keyword_cdecl = 3,
2598   SpellingNotCalculated = 15
2599 
2600   };
2601 
2602   // Factory methods
2603   static CDeclAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
2604   static CDeclAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
2605   static CDeclAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_cdecl);
2606   static CDeclAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_cdecl);
2607 
2608   // Constructors
2609   CDeclAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
2610              );
2611 
2612   CDeclAttr *clone(ASTContext &C) const;
2613   void printPretty(raw_ostream &OS,
2614                    const PrintingPolicy &Policy) const;
2615   const char *getSpelling() const;
2616 
2617 
2618   static bool classof(const Attr *A) { return A->getKind() == attr::CDecl; }
2619 };
2620 
2621 class CLANG_ABI CFAuditedTransferAttr : public InheritableAttr {
2622 public:
2623   enum Spelling {
2624     GNU_cf_audited_transfer = 0,
2625     CXX11_clang_cf_audited_transfer = 1,
2626     C23_clang_cf_audited_transfer = 2,
2627   SpellingNotCalculated = 15
2628 
2629   };
2630 
2631   // Factory methods
2632   static CFAuditedTransferAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
2633   static CFAuditedTransferAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
2634   static CFAuditedTransferAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_cf_audited_transfer);
2635   static CFAuditedTransferAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_cf_audited_transfer);
2636 
2637   // Constructors
2638   CFAuditedTransferAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
2639              );
2640 
2641   CFAuditedTransferAttr *clone(ASTContext &C) const;
2642   void printPretty(raw_ostream &OS,
2643                    const PrintingPolicy &Policy) const;
2644   const char *getSpelling() const;
2645 
2646 
2647   static bool classof(const Attr *A) { return A->getKind() == attr::CFAuditedTransfer; }
2648 };
2649 
2650 class CLANG_ABI CFConsumedAttr : public InheritableParamAttr {
2651 public:
2652   enum Spelling {
2653     GNU_cf_consumed = 0,
2654     CXX11_clang_cf_consumed = 1,
2655     C23_clang_cf_consumed = 2,
2656   SpellingNotCalculated = 15
2657 
2658   };
2659 
2660   // Factory methods
2661   static CFConsumedAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
2662   static CFConsumedAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
2663   static CFConsumedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_cf_consumed);
2664   static CFConsumedAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_cf_consumed);
2665 
2666   // Constructors
2667   CFConsumedAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
2668              );
2669 
2670   CFConsumedAttr *clone(ASTContext &C) const;
2671   void printPretty(raw_ostream &OS,
2672                    const PrintingPolicy &Policy) const;
2673   const char *getSpelling() const;
2674 
2675 
2676   static bool classof(const Attr *A) { return A->getKind() == attr::CFConsumed; }
2677 };
2678 
2679 class CLANG_ABI CFGuardAttr : public InheritableAttr {
2680 public:
2681   enum GuardArg {
2682     nocf
2683   };
2684 private:
2685   CFGuardAttr::GuardArg guard;
2686 
2687 public:
2688   enum Spelling {
2689     Declspec_guard = 0,
2690     GNU_guard = 1,
2691     CXX11_clang_guard = 2,
2692     C23_clang_guard = 3,
2693   SpellingNotCalculated = 15
2694 
2695   };
2696 
2697   // Factory methods
2698   static CFGuardAttr *CreateImplicit(ASTContext &Ctx, CFGuardAttr::GuardArg Guard, const AttributeCommonInfo &CommonInfo);
2699   static CFGuardAttr *Create(ASTContext &Ctx, CFGuardAttr::GuardArg Guard, const AttributeCommonInfo &CommonInfo);
2700   static CFGuardAttr *CreateImplicit(ASTContext &Ctx, CFGuardAttr::GuardArg Guard, SourceRange Range = {}, Spelling S = Declspec_guard);
2701   static CFGuardAttr *Create(ASTContext &Ctx, CFGuardAttr::GuardArg Guard, SourceRange Range = {}, Spelling S = Declspec_guard);
2702 
2703   // Constructors
2704   CFGuardAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
2705               , CFGuardAttr::GuardArg Guard
2706              );
2707 
2708   CFGuardAttr *clone(ASTContext &C) const;
2709   void printPretty(raw_ostream &OS,
2710                    const PrintingPolicy &Policy) const;
2711   const char *getSpelling() const;
2712   CFGuardAttr::GuardArg getGuard() const {
2713     return guard;
2714   }
2715 
2716   static bool ConvertStrToGuardArg(StringRef Val, CFGuardAttr::GuardArg &Out);
2717   static const char *ConvertGuardArgToStr(CFGuardAttr::GuardArg Val);
2718 
2719 
2720   static bool classof(const Attr *A) { return A->getKind() == attr::CFGuard; }
2721 };
2722 
2723 class CLANG_ABI CFICanonicalJumpTableAttr : public InheritableAttr {
2724 public:
2725   enum Spelling {
2726     GNU_cfi_canonical_jump_table = 0,
2727     CXX11_clang_cfi_canonical_jump_table = 1,
2728     C23_clang_cfi_canonical_jump_table = 2,
2729   SpellingNotCalculated = 15
2730 
2731   };
2732 
2733   // Factory methods
2734   static CFICanonicalJumpTableAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
2735   static CFICanonicalJumpTableAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
2736   static CFICanonicalJumpTableAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_cfi_canonical_jump_table);
2737   static CFICanonicalJumpTableAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_cfi_canonical_jump_table);
2738 
2739   // Constructors
2740   CFICanonicalJumpTableAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
2741              );
2742 
2743   CFICanonicalJumpTableAttr *clone(ASTContext &C) const;
2744   void printPretty(raw_ostream &OS,
2745                    const PrintingPolicy &Policy) const;
2746   const char *getSpelling() const;
2747 
2748 
2749   static bool classof(const Attr *A) { return A->getKind() == attr::CFICanonicalJumpTable; }
2750 };
2751 
2752 class CLANG_ABI CFReturnsNotRetainedAttr : public InheritableAttr {
2753 public:
2754   enum Spelling {
2755     GNU_cf_returns_not_retained = 0,
2756     CXX11_clang_cf_returns_not_retained = 1,
2757     C23_clang_cf_returns_not_retained = 2,
2758   SpellingNotCalculated = 15
2759 
2760   };
2761 
2762   // Factory methods
2763   static CFReturnsNotRetainedAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
2764   static CFReturnsNotRetainedAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
2765   static CFReturnsNotRetainedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_cf_returns_not_retained);
2766   static CFReturnsNotRetainedAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_cf_returns_not_retained);
2767 
2768   // Constructors
2769   CFReturnsNotRetainedAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
2770              );
2771 
2772   CFReturnsNotRetainedAttr *clone(ASTContext &C) const;
2773   void printPretty(raw_ostream &OS,
2774                    const PrintingPolicy &Policy) const;
2775   const char *getSpelling() const;
2776 
2777 
2778   static bool classof(const Attr *A) { return A->getKind() == attr::CFReturnsNotRetained; }
2779 };
2780 
2781 class CLANG_ABI CFReturnsRetainedAttr : public InheritableAttr {
2782 public:
2783   enum Spelling {
2784     GNU_cf_returns_retained = 0,
2785     CXX11_clang_cf_returns_retained = 1,
2786     C23_clang_cf_returns_retained = 2,
2787   SpellingNotCalculated = 15
2788 
2789   };
2790 
2791   // Factory methods
2792   static CFReturnsRetainedAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
2793   static CFReturnsRetainedAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
2794   static CFReturnsRetainedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_cf_returns_retained);
2795   static CFReturnsRetainedAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_cf_returns_retained);
2796 
2797   // Constructors
2798   CFReturnsRetainedAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
2799              );
2800 
2801   CFReturnsRetainedAttr *clone(ASTContext &C) const;
2802   void printPretty(raw_ostream &OS,
2803                    const PrintingPolicy &Policy) const;
2804   const char *getSpelling() const;
2805 
2806 
2807   static bool classof(const Attr *A) { return A->getKind() == attr::CFReturnsRetained; }
2808 };
2809 
2810 class CLANG_ABI CFUnknownTransferAttr : public InheritableAttr {
2811 public:
2812   enum Spelling {
2813     GNU_cf_unknown_transfer = 0,
2814     CXX11_clang_cf_unknown_transfer = 1,
2815     C23_clang_cf_unknown_transfer = 2,
2816   SpellingNotCalculated = 15
2817 
2818   };
2819 
2820   // Factory methods
2821   static CFUnknownTransferAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
2822   static CFUnknownTransferAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
2823   static CFUnknownTransferAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_cf_unknown_transfer);
2824   static CFUnknownTransferAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_cf_unknown_transfer);
2825 
2826   // Constructors
2827   CFUnknownTransferAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
2828              );
2829 
2830   CFUnknownTransferAttr *clone(ASTContext &C) const;
2831   void printPretty(raw_ostream &OS,
2832                    const PrintingPolicy &Policy) const;
2833   const char *getSpelling() const;
2834 
2835 
2836   static bool classof(const Attr *A) { return A->getKind() == attr::CFUnknownTransfer; }
2837 };
2838 
2839 class CLANG_ABI CPUDispatchAttr : public InheritableAttr {
2840   unsigned cpus_Size;
2841   IdentifierInfo * *cpus_;
2842 
2843 public:
2844   enum Spelling {
2845     GNU_cpu_dispatch = 0,
2846     CXX11_clang_cpu_dispatch = 1,
2847     C23_clang_cpu_dispatch = 2,
2848     Declspec_cpu_dispatch = 3,
2849   SpellingNotCalculated = 15
2850 
2851   };
2852 
2853   // Factory methods
2854   static CPUDispatchAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * *Cpus, unsigned CpusSize, const AttributeCommonInfo &CommonInfo);
2855   static CPUDispatchAttr *Create(ASTContext &Ctx, IdentifierInfo * *Cpus, unsigned CpusSize, const AttributeCommonInfo &CommonInfo);
2856   static CPUDispatchAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * *Cpus, unsigned CpusSize, SourceRange Range = {}, Spelling S = GNU_cpu_dispatch);
2857   static CPUDispatchAttr *Create(ASTContext &Ctx, IdentifierInfo * *Cpus, unsigned CpusSize, SourceRange Range = {}, Spelling S = GNU_cpu_dispatch);
2858 
2859   // Constructors
2860   CPUDispatchAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
2861               , IdentifierInfo * *Cpus, unsigned CpusSize
2862              );
2863   CPUDispatchAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
2864              );
2865 
2866   CPUDispatchAttr *clone(ASTContext &C) const;
2867   void printPretty(raw_ostream &OS,
2868                    const PrintingPolicy &Policy) const;
2869   const char *getSpelling() const;
2870   typedef IdentifierInfo ** cpus_iterator;
2871   cpus_iterator cpus_begin() const { return cpus_; }
2872   cpus_iterator cpus_end() const { return cpus_ + cpus_Size; }
2873   unsigned cpus_size() const { return cpus_Size; }
2874   llvm::iterator_range<cpus_iterator> cpus() const { return llvm::make_range(cpus_begin(), cpus_end()); }
2875 
2876 
2877 
2878 
2879   static bool classof(const Attr *A) { return A->getKind() == attr::CPUDispatch; }
2880 };
2881 
2882 class CLANG_ABI CPUSpecificAttr : public InheritableAttr {
2883   unsigned cpus_Size;
2884   IdentifierInfo * *cpus_;
2885 
2886 public:
2887   enum Spelling {
2888     GNU_cpu_specific = 0,
2889     CXX11_clang_cpu_specific = 1,
2890     C23_clang_cpu_specific = 2,
2891     Declspec_cpu_specific = 3,
2892   SpellingNotCalculated = 15
2893 
2894   };
2895 
2896   // Factory methods
2897   static CPUSpecificAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * *Cpus, unsigned CpusSize, const AttributeCommonInfo &CommonInfo);
2898   static CPUSpecificAttr *Create(ASTContext &Ctx, IdentifierInfo * *Cpus, unsigned CpusSize, const AttributeCommonInfo &CommonInfo);
2899   static CPUSpecificAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * *Cpus, unsigned CpusSize, SourceRange Range = {}, Spelling S = GNU_cpu_specific);
2900   static CPUSpecificAttr *Create(ASTContext &Ctx, IdentifierInfo * *Cpus, unsigned CpusSize, SourceRange Range = {}, Spelling S = GNU_cpu_specific);
2901 
2902   // Constructors
2903   CPUSpecificAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
2904               , IdentifierInfo * *Cpus, unsigned CpusSize
2905              );
2906   CPUSpecificAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
2907              );
2908 
2909   CPUSpecificAttr *clone(ASTContext &C) const;
2910   void printPretty(raw_ostream &OS,
2911                    const PrintingPolicy &Policy) const;
2912   const char *getSpelling() const;
2913   typedef IdentifierInfo ** cpus_iterator;
2914   cpus_iterator cpus_begin() const { return cpus_; }
2915   cpus_iterator cpus_end() const { return cpus_ + cpus_Size; }
2916   unsigned cpus_size() const { return cpus_Size; }
2917   llvm::iterator_range<cpus_iterator> cpus() const { return llvm::make_range(cpus_begin(), cpus_end()); }
2918 
2919 
2920 
2921     IdentifierInfo *getCPUName(unsigned Index) const {
2922       return *(cpus_begin() + Index);
2923     }
2924   
2925 
2926   static bool classof(const Attr *A) { return A->getKind() == attr::CPUSpecific; }
2927 };
2928 
2929 class CLANG_ABI CUDAConstantAttr : public InheritableAttr {
2930 public:
2931   enum Spelling {
2932     GNU_constant = 0,
2933     Declspec_constant = 1,
2934   SpellingNotCalculated = 15
2935 
2936   };
2937 
2938   // Factory methods
2939   static CUDAConstantAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
2940   static CUDAConstantAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
2941   static CUDAConstantAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_constant);
2942   static CUDAConstantAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_constant);
2943 
2944   // Constructors
2945   CUDAConstantAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
2946              );
2947 
2948   CUDAConstantAttr *clone(ASTContext &C) const;
2949   void printPretty(raw_ostream &OS,
2950                    const PrintingPolicy &Policy) const;
2951   const char *getSpelling() const;
2952 
2953 
2954   static bool classof(const Attr *A) { return A->getKind() == attr::CUDAConstant; }
2955 };
2956 
2957 class CLANG_ABI CUDADeviceAttr : public InheritableAttr {
2958 public:
2959   enum Spelling {
2960     GNU_device = 0,
2961     Declspec_device = 1,
2962   SpellingNotCalculated = 15
2963 
2964   };
2965 
2966   // Factory methods
2967   static CUDADeviceAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
2968   static CUDADeviceAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
2969   static CUDADeviceAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_device);
2970   static CUDADeviceAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_device);
2971 
2972   // Constructors
2973   CUDADeviceAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
2974              );
2975 
2976   CUDADeviceAttr *clone(ASTContext &C) const;
2977   void printPretty(raw_ostream &OS,
2978                    const PrintingPolicy &Policy) const;
2979   const char *getSpelling() const;
2980 
2981 
2982   static bool classof(const Attr *A) { return A->getKind() == attr::CUDADevice; }
2983 };
2984 
2985 class CLANG_ABI CUDADeviceBuiltinSurfaceTypeAttr : public InheritableAttr {
2986 public:
2987   enum Spelling {
2988     GNU_device_builtin_surface_type = 0,
2989     Declspec_device_builtin_surface_type = 1,
2990   SpellingNotCalculated = 15
2991 
2992   };
2993 
2994   // Factory methods
2995   static CUDADeviceBuiltinSurfaceTypeAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
2996   static CUDADeviceBuiltinSurfaceTypeAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
2997   static CUDADeviceBuiltinSurfaceTypeAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_device_builtin_surface_type);
2998   static CUDADeviceBuiltinSurfaceTypeAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_device_builtin_surface_type);
2999 
3000   // Constructors
3001   CUDADeviceBuiltinSurfaceTypeAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
3002              );
3003 
3004   CUDADeviceBuiltinSurfaceTypeAttr *clone(ASTContext &C) const;
3005   void printPretty(raw_ostream &OS,
3006                    const PrintingPolicy &Policy) const;
3007   const char *getSpelling() const;
3008 
3009 
3010   static bool classof(const Attr *A) { return A->getKind() == attr::CUDADeviceBuiltinSurfaceType; }
3011 };
3012 
3013 class CLANG_ABI CUDADeviceBuiltinTextureTypeAttr : public InheritableAttr {
3014 public:
3015   enum Spelling {
3016     GNU_device_builtin_texture_type = 0,
3017     Declspec_device_builtin_texture_type = 1,
3018   SpellingNotCalculated = 15
3019 
3020   };
3021 
3022   // Factory methods
3023   static CUDADeviceBuiltinTextureTypeAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
3024   static CUDADeviceBuiltinTextureTypeAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
3025   static CUDADeviceBuiltinTextureTypeAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_device_builtin_texture_type);
3026   static CUDADeviceBuiltinTextureTypeAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_device_builtin_texture_type);
3027 
3028   // Constructors
3029   CUDADeviceBuiltinTextureTypeAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
3030              );
3031 
3032   CUDADeviceBuiltinTextureTypeAttr *clone(ASTContext &C) const;
3033   void printPretty(raw_ostream &OS,
3034                    const PrintingPolicy &Policy) const;
3035   const char *getSpelling() const;
3036 
3037 
3038   static bool classof(const Attr *A) { return A->getKind() == attr::CUDADeviceBuiltinTextureType; }
3039 };
3040 
3041 class CLANG_ABI CUDAGlobalAttr : public InheritableAttr {
3042 public:
3043   enum Spelling {
3044     GNU_global = 0,
3045     Declspec_global = 1,
3046   SpellingNotCalculated = 15
3047 
3048   };
3049 
3050   // Factory methods
3051   static CUDAGlobalAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
3052   static CUDAGlobalAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
3053   static CUDAGlobalAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_global);
3054   static CUDAGlobalAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_global);
3055 
3056   // Constructors
3057   CUDAGlobalAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
3058              );
3059 
3060   CUDAGlobalAttr *clone(ASTContext &C) const;
3061   void printPretty(raw_ostream &OS,
3062                    const PrintingPolicy &Policy) const;
3063   const char *getSpelling() const;
3064 
3065 
3066   static bool classof(const Attr *A) { return A->getKind() == attr::CUDAGlobal; }
3067 };
3068 
3069 class CLANG_ABI CUDAGridConstantAttr : public InheritableAttr {
3070 public:
3071   enum Spelling {
3072     GNU_grid_constant = 0,
3073     Declspec_grid_constant = 1,
3074   SpellingNotCalculated = 15
3075 
3076   };
3077 
3078   // Factory methods
3079   static CUDAGridConstantAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
3080   static CUDAGridConstantAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
3081   static CUDAGridConstantAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_grid_constant);
3082   static CUDAGridConstantAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_grid_constant);
3083 
3084   // Constructors
3085   CUDAGridConstantAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
3086              );
3087 
3088   CUDAGridConstantAttr *clone(ASTContext &C) const;
3089   void printPretty(raw_ostream &OS,
3090                    const PrintingPolicy &Policy) const;
3091   const char *getSpelling() const;
3092 
3093 
3094   static bool classof(const Attr *A) { return A->getKind() == attr::CUDAGridConstant; }
3095 };
3096 
3097 class CLANG_ABI CUDAHostAttr : public InheritableAttr {
3098 public:
3099   enum Spelling {
3100     GNU_host = 0,
3101     Declspec_host = 1,
3102   SpellingNotCalculated = 15
3103 
3104   };
3105 
3106   // Factory methods
3107   static CUDAHostAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
3108   static CUDAHostAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
3109   static CUDAHostAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_host);
3110   static CUDAHostAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_host);
3111 
3112   // Constructors
3113   CUDAHostAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
3114              );
3115 
3116   CUDAHostAttr *clone(ASTContext &C) const;
3117   void printPretty(raw_ostream &OS,
3118                    const PrintingPolicy &Policy) const;
3119   const char *getSpelling() const;
3120 
3121 
3122   static bool classof(const Attr *A) { return A->getKind() == attr::CUDAHost; }
3123 };
3124 
3125 class CLANG_ABI CUDAInvalidTargetAttr : public InheritableAttr {
3126 public:
3127   // Factory methods
3128   static CUDAInvalidTargetAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
3129   static CUDAInvalidTargetAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
3130   static CUDAInvalidTargetAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {});
3131   static CUDAInvalidTargetAttr *Create(ASTContext &Ctx, SourceRange Range = {});
3132 
3133   // Constructors
3134   CUDAInvalidTargetAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
3135              );
3136 
3137   CUDAInvalidTargetAttr *clone(ASTContext &C) const;
3138   void printPretty(raw_ostream &OS,
3139                    const PrintingPolicy &Policy) const;
3140   const char *getSpelling() const;
3141 
3142 
3143   static bool classof(const Attr *A) { return A->getKind() == attr::CUDAInvalidTarget; }
3144 };
3145 
3146 class CLANG_ABI CUDALaunchBoundsAttr : public InheritableAttr {
3147 Expr * maxThreads;
3148 
3149 Expr * minBlocks;
3150 
3151 Expr * maxBlocks;
3152 
3153 public:
3154   enum Spelling {
3155     GNU_launch_bounds = 0,
3156     Declspec_launch_bounds = 1,
3157   SpellingNotCalculated = 15
3158 
3159   };
3160 
3161   // Factory methods
3162   static CUDALaunchBoundsAttr *CreateImplicit(ASTContext &Ctx, Expr * MaxThreads, Expr * MinBlocks, Expr * MaxBlocks, const AttributeCommonInfo &CommonInfo);
3163   static CUDALaunchBoundsAttr *Create(ASTContext &Ctx, Expr * MaxThreads, Expr * MinBlocks, Expr * MaxBlocks, const AttributeCommonInfo &CommonInfo);
3164   static CUDALaunchBoundsAttr *CreateImplicit(ASTContext &Ctx, Expr * MaxThreads, Expr * MinBlocks, Expr * MaxBlocks, SourceRange Range = {}, Spelling S = GNU_launch_bounds);
3165   static CUDALaunchBoundsAttr *Create(ASTContext &Ctx, Expr * MaxThreads, Expr * MinBlocks, Expr * MaxBlocks, SourceRange Range = {}, Spelling S = GNU_launch_bounds);
3166 
3167   // Constructors
3168   CUDALaunchBoundsAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
3169               , Expr * MaxThreads
3170               , Expr * MinBlocks
3171               , Expr * MaxBlocks
3172              );
3173   CUDALaunchBoundsAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
3174               , Expr * MaxThreads
3175              );
3176 
3177   CUDALaunchBoundsAttr *clone(ASTContext &C) const;
3178   void printPretty(raw_ostream &OS,
3179                    const PrintingPolicy &Policy) const;
3180   const char *getSpelling() const;
3181   Expr * getMaxThreads() const {
3182     return maxThreads;
3183   }
3184 
3185   Expr * getMinBlocks() const {
3186     return minBlocks;
3187   }
3188 
3189   Expr * getMaxBlocks() const {
3190     return maxBlocks;
3191   }
3192 
3193 
3194 
3195   static bool classof(const Attr *A) { return A->getKind() == attr::CUDALaunchBounds; }
3196 };
3197 
3198 class CLANG_ABI CUDASharedAttr : public InheritableAttr {
3199 public:
3200   enum Spelling {
3201     GNU_shared = 0,
3202     Declspec_shared = 1,
3203   SpellingNotCalculated = 15
3204 
3205   };
3206 
3207   // Factory methods
3208   static CUDASharedAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
3209   static CUDASharedAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
3210   static CUDASharedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_shared);
3211   static CUDASharedAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_shared);
3212 
3213   // Constructors
3214   CUDASharedAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
3215              );
3216 
3217   CUDASharedAttr *clone(ASTContext &C) const;
3218   void printPretty(raw_ostream &OS,
3219                    const PrintingPolicy &Policy) const;
3220   const char *getSpelling() const;
3221 
3222 
3223   static bool classof(const Attr *A) { return A->getKind() == attr::CUDAShared; }
3224 };
3225 
3226 class CLANG_ABI CXX11NoReturnAttr : public InheritableAttr {
3227 public:
3228   enum Spelling {
3229     CXX11_noreturn = 0,
3230     C23_noreturn = 1,
3231     C23_Noreturn = 2,
3232   SpellingNotCalculated = 15
3233 
3234   };
3235 
3236   // Factory methods
3237   static CXX11NoReturnAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
3238   static CXX11NoReturnAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
3239   static CXX11NoReturnAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = CXX11_noreturn);
3240   static CXX11NoReturnAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = CXX11_noreturn);
3241 
3242   // Constructors
3243   CXX11NoReturnAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
3244              );
3245 
3246   CXX11NoReturnAttr *clone(ASTContext &C) const;
3247   void printPretty(raw_ostream &OS,
3248                    const PrintingPolicy &Policy) const;
3249   const char *getSpelling() const;
3250   Spelling getSemanticSpelling() const;
3251 
3252 
3253   static bool classof(const Attr *A) { return A->getKind() == attr::CXX11NoReturn; }
3254 };
3255 
3256 class CLANG_ABI CXXAssumeAttr : public StmtAttr {
3257 Expr * assumption;
3258 
3259 public:
3260   enum Spelling {
3261     CXX11_assume = 0,
3262     GNU_assume = 1,
3263     CXX11_clang_assume = 2,
3264     C23_clang_assume = 3,
3265   SpellingNotCalculated = 15
3266 
3267   };
3268 
3269   // Factory methods
3270   static CXXAssumeAttr *CreateImplicit(ASTContext &Ctx, Expr * Assumption, const AttributeCommonInfo &CommonInfo);
3271   static CXXAssumeAttr *Create(ASTContext &Ctx, Expr * Assumption, const AttributeCommonInfo &CommonInfo);
3272   static CXXAssumeAttr *CreateImplicit(ASTContext &Ctx, Expr * Assumption, SourceRange Range = {}, Spelling S = CXX11_assume);
3273   static CXXAssumeAttr *Create(ASTContext &Ctx, Expr * Assumption, SourceRange Range = {}, Spelling S = CXX11_assume);
3274 
3275   // Constructors
3276   CXXAssumeAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
3277               , Expr * Assumption
3278              );
3279 
3280   CXXAssumeAttr *clone(ASTContext &C) const;
3281   void printPretty(raw_ostream &OS,
3282                    const PrintingPolicy &Policy) const;
3283   const char *getSpelling() const;
3284   Expr * getAssumption() const {
3285     return assumption;
3286   }
3287 
3288 
3289 
3290   static bool classof(const Attr *A) { return A->getKind() == attr::CXXAssume; }
3291 };
3292 
3293 class CLANG_ABI CallableWhenAttr : public InheritableAttr {
3294 public:
3295   enum ConsumedState {
3296     Unknown,
3297     Consumed,
3298     Unconsumed
3299   };
3300 private:
3301   unsigned callableStates_Size;
3302   ConsumedState *callableStates_;
3303 
3304 public:
3305   enum Spelling {
3306     GNU_callable_when = 0,
3307     CXX11_clang_callable_when = 1,
3308   SpellingNotCalculated = 15
3309 
3310   };
3311 
3312   // Factory methods
3313   static CallableWhenAttr *CreateImplicit(ASTContext &Ctx, ConsumedState *CallableStates, unsigned CallableStatesSize, const AttributeCommonInfo &CommonInfo);
3314   static CallableWhenAttr *Create(ASTContext &Ctx, ConsumedState *CallableStates, unsigned CallableStatesSize, const AttributeCommonInfo &CommonInfo);
3315   static CallableWhenAttr *CreateImplicit(ASTContext &Ctx, ConsumedState *CallableStates, unsigned CallableStatesSize, SourceRange Range = {}, Spelling S = GNU_callable_when);
3316   static CallableWhenAttr *Create(ASTContext &Ctx, ConsumedState *CallableStates, unsigned CallableStatesSize, SourceRange Range = {}, Spelling S = GNU_callable_when);
3317 
3318   // Constructors
3319   CallableWhenAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
3320               , ConsumedState *CallableStates, unsigned CallableStatesSize
3321              );
3322   CallableWhenAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
3323              );
3324 
3325   CallableWhenAttr *clone(ASTContext &C) const;
3326   void printPretty(raw_ostream &OS,
3327                    const PrintingPolicy &Policy) const;
3328   const char *getSpelling() const;
3329   typedef ConsumedState* callableStates_iterator;
3330   callableStates_iterator callableStates_begin() const { return callableStates_; }
3331   callableStates_iterator callableStates_end() const { return callableStates_ + callableStates_Size; }
3332   unsigned callableStates_size() const { return callableStates_Size; }
3333   llvm::iterator_range<callableStates_iterator> callableStates() const { return llvm::make_range(callableStates_begin(), callableStates_end()); }
3334 
3335 
3336   static bool ConvertStrToConsumedState(StringRef Val, CallableWhenAttr::ConsumedState &Out);
3337   static const char *ConvertConsumedStateToStr(CallableWhenAttr::ConsumedState Val);
3338 
3339 
3340   static bool classof(const Attr *A) { return A->getKind() == attr::CallableWhen; }
3341 };
3342 
3343 class CLANG_ABI CallbackAttr : public InheritableAttr {
3344   unsigned encoding_Size;
3345   int *encoding_;
3346 
3347 public:
3348   enum Spelling {
3349     GNU_callback = 0,
3350     CXX11_clang_callback = 1,
3351     C23_clang_callback = 2,
3352   SpellingNotCalculated = 15
3353 
3354   };
3355 
3356   // Factory methods
3357   static CallbackAttr *CreateImplicit(ASTContext &Ctx, int *Encoding, unsigned EncodingSize, const AttributeCommonInfo &CommonInfo);
3358   static CallbackAttr *Create(ASTContext &Ctx, int *Encoding, unsigned EncodingSize, const AttributeCommonInfo &CommonInfo);
3359   static CallbackAttr *CreateImplicit(ASTContext &Ctx, int *Encoding, unsigned EncodingSize, SourceRange Range = {}, Spelling S = GNU_callback);
3360   static CallbackAttr *Create(ASTContext &Ctx, int *Encoding, unsigned EncodingSize, SourceRange Range = {}, Spelling S = GNU_callback);
3361 
3362   // Constructors
3363   CallbackAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
3364               , int *Encoding, unsigned EncodingSize
3365              );
3366   CallbackAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
3367              );
3368 
3369   CallbackAttr *clone(ASTContext &C) const;
3370   void printPretty(raw_ostream &OS,
3371                    const PrintingPolicy &Policy) const;
3372   const char *getSpelling() const;
3373   typedef int* encoding_iterator;
3374   encoding_iterator encoding_begin() const { return encoding_; }
3375   encoding_iterator encoding_end() const { return encoding_ + encoding_Size; }
3376   unsigned encoding_size() const { return encoding_Size; }
3377   llvm::iterator_range<encoding_iterator> encoding() const { return llvm::make_range(encoding_begin(), encoding_end()); }
3378 
3379 
3380 
3381 
3382   static bool classof(const Attr *A) { return A->getKind() == attr::Callback; }
3383 };
3384 
3385 class CLANG_ABI CalledOnceAttr : public Attr {
3386 public:
3387   enum Spelling {
3388     GNU_called_once = 0,
3389     CXX11_clang_called_once = 1,
3390     C23_clang_called_once = 2,
3391   SpellingNotCalculated = 15
3392 
3393   };
3394 
3395   // Factory methods
3396   static CalledOnceAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
3397   static CalledOnceAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
3398   static CalledOnceAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_called_once);
3399   static CalledOnceAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_called_once);
3400 
3401   // Constructors
3402   CalledOnceAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
3403              );
3404 
3405   CalledOnceAttr *clone(ASTContext &C) const;
3406   void printPretty(raw_ostream &OS,
3407                    const PrintingPolicy &Policy) const;
3408   const char *getSpelling() const;
3409 
3410 
3411   static bool classof(const Attr *A) { return A->getKind() == attr::CalledOnce; }
3412 };
3413 
3414 class CLANG_ABI CapabilityAttr : public InheritableAttr {
3415 unsigned nameLength;
3416 char *name;
3417 
3418 public:
3419   enum Spelling {
3420     GNU_capability = 0,
3421     CXX11_clang_capability = 1,
3422     GNU_shared_capability = 2,
3423     CXX11_clang_shared_capability = 3,
3424   SpellingNotCalculated = 15
3425 
3426   };
3427 
3428   // Factory methods
3429   static CapabilityAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Name, const AttributeCommonInfo &CommonInfo);
3430   static CapabilityAttr *Create(ASTContext &Ctx, llvm::StringRef Name, const AttributeCommonInfo &CommonInfo);
3431   static CapabilityAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Name, SourceRange Range = {}, Spelling S = GNU_capability);
3432   static CapabilityAttr *Create(ASTContext &Ctx, llvm::StringRef Name, SourceRange Range = {}, Spelling S = GNU_capability);
3433 
3434   // Constructors
3435   CapabilityAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
3436               , llvm::StringRef Name
3437              );
3438 
3439   CapabilityAttr *clone(ASTContext &C) const;
3440   void printPretty(raw_ostream &OS,
3441                    const PrintingPolicy &Policy) const;
3442   const char *getSpelling() const;
3443   Spelling getSemanticSpelling() const;
3444   bool isShared() const { return getAttributeSpellingListIndex() == 2 ||
3445     getAttributeSpellingListIndex() == 3; }
3446   llvm::StringRef getName() const {
3447     return llvm::StringRef(name, nameLength);
3448   }
3449   unsigned getNameLength() const {
3450     return nameLength;
3451   }
3452   void setName(ASTContext &C, llvm::StringRef S) {
3453     nameLength = S.size();
3454     this->name = new (C, 1) char [nameLength];
3455     if (!S.empty())
3456       std::memcpy(this->name, S.data(), nameLength);
3457   }
3458 
3459 
3460 
3461   static bool classof(const Attr *A) { return A->getKind() == attr::Capability; }
3462 };
3463 
3464 class CLANG_ABI CapturedRecordAttr : public InheritableAttr {
3465 public:
3466   // Factory methods
3467   static CapturedRecordAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
3468   static CapturedRecordAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
3469   static CapturedRecordAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {});
3470   static CapturedRecordAttr *Create(ASTContext &Ctx, SourceRange Range = {});
3471 
3472   // Constructors
3473   CapturedRecordAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
3474              );
3475 
3476   CapturedRecordAttr *clone(ASTContext &C) const;
3477   void printPretty(raw_ostream &OS,
3478                    const PrintingPolicy &Policy) const;
3479   const char *getSpelling() const;
3480 
3481 
3482   static bool classof(const Attr *A) { return A->getKind() == attr::CapturedRecord; }
3483 };
3484 
3485 class CLANG_ABI CarriesDependencyAttr : public InheritableParamAttr {
3486 public:
3487   enum Spelling {
3488     GNU_carries_dependency = 0,
3489     CXX11_carries_dependency = 1,
3490   SpellingNotCalculated = 15
3491 
3492   };
3493 
3494   // Factory methods
3495   static CarriesDependencyAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
3496   static CarriesDependencyAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
3497   static CarriesDependencyAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_carries_dependency);
3498   static CarriesDependencyAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_carries_dependency);
3499 
3500   // Constructors
3501   CarriesDependencyAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
3502              );
3503 
3504   CarriesDependencyAttr *clone(ASTContext &C) const;
3505   void printPretty(raw_ostream &OS,
3506                    const PrintingPolicy &Policy) const;
3507   const char *getSpelling() const;
3508 
3509 
3510   static bool classof(const Attr *A) { return A->getKind() == attr::CarriesDependency; }
3511 };
3512 
3513 class CLANG_ABI CleanupAttr : public InheritableAttr {
3514 FunctionDecl * functionDecl;
3515 
3516 public:
3517   enum Spelling {
3518     GNU_cleanup = 0,
3519     CXX11_gnu_cleanup = 1,
3520     C23_gnu_cleanup = 2,
3521   SpellingNotCalculated = 15
3522 
3523   };
3524 
3525   // Factory methods
3526   static CleanupAttr *CreateImplicit(ASTContext &Ctx, FunctionDecl * FunctionDecl, const AttributeCommonInfo &CommonInfo);
3527   static CleanupAttr *Create(ASTContext &Ctx, FunctionDecl * FunctionDecl, const AttributeCommonInfo &CommonInfo);
3528   static CleanupAttr *CreateImplicit(ASTContext &Ctx, FunctionDecl * FunctionDecl, SourceRange Range = {}, Spelling S = GNU_cleanup);
3529   static CleanupAttr *Create(ASTContext &Ctx, FunctionDecl * FunctionDecl, SourceRange Range = {}, Spelling S = GNU_cleanup);
3530 
3531   // Constructors
3532   CleanupAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
3533               , FunctionDecl * FunctionDecl
3534              );
3535 
3536   CleanupAttr *clone(ASTContext &C) const;
3537   void printPretty(raw_ostream &OS,
3538                    const PrintingPolicy &Policy) const;
3539   const char *getSpelling() const;
3540   FunctionDecl * getFunctionDecl() const {
3541     return functionDecl;
3542   }
3543 
3544 
3545 
3546   static bool classof(const Attr *A) { return A->getKind() == attr::Cleanup; }
3547 };
3548 
3549 class CLANG_ABI ClspvLibclcBuiltinAttr : public InheritableAttr {
3550 public:
3551   enum Spelling {
3552     GNU_clspv_libclc_builtin = 0,
3553     CXX11_clang_clspv_libclc_builtin = 1,
3554     C23_clang_clspv_libclc_builtin = 2,
3555   SpellingNotCalculated = 15
3556 
3557   };
3558 
3559   // Factory methods
3560   static ClspvLibclcBuiltinAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
3561   static ClspvLibclcBuiltinAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
3562   static ClspvLibclcBuiltinAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_clspv_libclc_builtin);
3563   static ClspvLibclcBuiltinAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_clspv_libclc_builtin);
3564 
3565   // Constructors
3566   ClspvLibclcBuiltinAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
3567              );
3568 
3569   ClspvLibclcBuiltinAttr *clone(ASTContext &C) const;
3570   void printPretty(raw_ostream &OS,
3571                    const PrintingPolicy &Policy) const;
3572   const char *getSpelling() const;
3573 
3574 
3575   static bool classof(const Attr *A) { return A->getKind() == attr::ClspvLibclcBuiltin; }
3576 };
3577 
3578 class CLANG_ABI CmseNSCallAttr : public TypeAttr {
3579 public:
3580   // Factory methods
3581   static CmseNSCallAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
3582   static CmseNSCallAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
3583   static CmseNSCallAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {});
3584   static CmseNSCallAttr *Create(ASTContext &Ctx, SourceRange Range = {});
3585 
3586   // Constructors
3587   CmseNSCallAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
3588              );
3589 
3590   CmseNSCallAttr *clone(ASTContext &C) const;
3591   void printPretty(raw_ostream &OS,
3592                    const PrintingPolicy &Policy) const;
3593   const char *getSpelling() const;
3594 
3595 
3596   static bool classof(const Attr *A) { return A->getKind() == attr::CmseNSCall; }
3597 };
3598 
3599 class CLANG_ABI CmseNSEntryAttr : public InheritableAttr {
3600 public:
3601   // Factory methods
3602   static CmseNSEntryAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
3603   static CmseNSEntryAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
3604   static CmseNSEntryAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {});
3605   static CmseNSEntryAttr *Create(ASTContext &Ctx, SourceRange Range = {});
3606 
3607   // Constructors
3608   CmseNSEntryAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
3609              );
3610 
3611   CmseNSEntryAttr *clone(ASTContext &C) const;
3612   void printPretty(raw_ostream &OS,
3613                    const PrintingPolicy &Policy) const;
3614   const char *getSpelling() const;
3615 
3616 
3617   static bool classof(const Attr *A) { return A->getKind() == attr::CmseNSEntry; }
3618 };
3619 
3620 class CLANG_ABI CodeAlignAttr : public StmtAttr {
3621 Expr * alignment;
3622 
3623 public:
3624   enum Spelling {
3625     GNU_code_align = 0,
3626     CXX11_clang_code_align = 1,
3627     C23_clang_code_align = 2,
3628   SpellingNotCalculated = 15
3629 
3630   };
3631 
3632   // Factory methods
3633   static CodeAlignAttr *CreateImplicit(ASTContext &Ctx, Expr * Alignment, const AttributeCommonInfo &CommonInfo);
3634   static CodeAlignAttr *Create(ASTContext &Ctx, Expr * Alignment, const AttributeCommonInfo &CommonInfo);
3635   static CodeAlignAttr *CreateImplicit(ASTContext &Ctx, Expr * Alignment, SourceRange Range = {}, Spelling S = GNU_code_align);
3636   static CodeAlignAttr *Create(ASTContext &Ctx, Expr * Alignment, SourceRange Range = {}, Spelling S = GNU_code_align);
3637 
3638   // Constructors
3639   CodeAlignAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
3640               , Expr * Alignment
3641              );
3642 
3643   CodeAlignAttr *clone(ASTContext &C) const;
3644   void printPretty(raw_ostream &OS,
3645                    const PrintingPolicy &Policy) const;
3646   const char *getSpelling() const;
3647   Expr * getAlignment() const {
3648     return alignment;
3649   }
3650 
3651 
3652     static constexpr int MinimumAlignment = 1;
3653     static constexpr int MaximumAlignment = 4096;
3654   
3655 
3656   static bool classof(const Attr *A) { return A->getKind() == attr::CodeAlign; }
3657 };
3658 
3659 class CLANG_ABI CodeModelAttr : public InheritableAttr {
3660 private:
3661   llvm::CodeModel::Model model;
3662 
3663 public:
3664   enum Spelling {
3665     GNU_model = 0,
3666     CXX11_gnu_model = 1,
3667     C23_gnu_model = 2,
3668   SpellingNotCalculated = 15
3669 
3670   };
3671 
3672   // Factory methods
3673   static CodeModelAttr *CreateImplicit(ASTContext &Ctx, llvm::CodeModel::Model Model, const AttributeCommonInfo &CommonInfo);
3674   static CodeModelAttr *Create(ASTContext &Ctx, llvm::CodeModel::Model Model, const AttributeCommonInfo &CommonInfo);
3675   static CodeModelAttr *CreateImplicit(ASTContext &Ctx, llvm::CodeModel::Model Model, SourceRange Range = {}, Spelling S = GNU_model);
3676   static CodeModelAttr *Create(ASTContext &Ctx, llvm::CodeModel::Model Model, SourceRange Range = {}, Spelling S = GNU_model);
3677 
3678   // Constructors
3679   CodeModelAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
3680               , llvm::CodeModel::Model Model
3681              );
3682 
3683   CodeModelAttr *clone(ASTContext &C) const;
3684   void printPretty(raw_ostream &OS,
3685                    const PrintingPolicy &Policy) const;
3686   const char *getSpelling() const;
3687   llvm::CodeModel::Model getModel() const {
3688     return model;
3689   }
3690 
3691   static bool ConvertStrToModel(StringRef Val, llvm::CodeModel::Model &Out);
3692   static const char *ConvertModelToStr(llvm::CodeModel::Model Val);
3693 
3694 
3695   static bool classof(const Attr *A) { return A->getKind() == attr::CodeModel; }
3696 };
3697 
3698 class CLANG_ABI CodeSegAttr : public InheritableAttr {
3699 unsigned nameLength;
3700 char *name;
3701 
3702 public:
3703   // Factory methods
3704   static CodeSegAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Name, const AttributeCommonInfo &CommonInfo);
3705   static CodeSegAttr *Create(ASTContext &Ctx, llvm::StringRef Name, const AttributeCommonInfo &CommonInfo);
3706   static CodeSegAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Name, SourceRange Range = {});
3707   static CodeSegAttr *Create(ASTContext &Ctx, llvm::StringRef Name, SourceRange Range = {});
3708 
3709   // Constructors
3710   CodeSegAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
3711               , llvm::StringRef Name
3712              );
3713 
3714   CodeSegAttr *clone(ASTContext &C) const;
3715   void printPretty(raw_ostream &OS,
3716                    const PrintingPolicy &Policy) const;
3717   const char *getSpelling() const;
3718   llvm::StringRef getName() const {
3719     return llvm::StringRef(name, nameLength);
3720   }
3721   unsigned getNameLength() const {
3722     return nameLength;
3723   }
3724   void setName(ASTContext &C, llvm::StringRef S) {
3725     nameLength = S.size();
3726     this->name = new (C, 1) char [nameLength];
3727     if (!S.empty())
3728       std::memcpy(this->name, S.data(), nameLength);
3729   }
3730 
3731 
3732 
3733   static bool classof(const Attr *A) { return A->getKind() == attr::CodeSeg; }
3734 };
3735 
3736 class CLANG_ABI ColdAttr : public InheritableAttr {
3737 public:
3738   enum Spelling {
3739     GNU_cold = 0,
3740     CXX11_gnu_cold = 1,
3741     C23_gnu_cold = 2,
3742   SpellingNotCalculated = 15
3743 
3744   };
3745 
3746   // Factory methods
3747   static ColdAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
3748   static ColdAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
3749   static ColdAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_cold);
3750   static ColdAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_cold);
3751 
3752   // Constructors
3753   ColdAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
3754              );
3755 
3756   ColdAttr *clone(ASTContext &C) const;
3757   void printPretty(raw_ostream &OS,
3758                    const PrintingPolicy &Policy) const;
3759   const char *getSpelling() const;
3760 
3761 
3762   static bool classof(const Attr *A) { return A->getKind() == attr::Cold; }
3763 };
3764 
3765 class CLANG_ABI CommonAttr : public InheritableAttr {
3766 public:
3767   enum Spelling {
3768     GNU_common = 0,
3769     CXX11_gnu_common = 1,
3770     C23_gnu_common = 2,
3771   SpellingNotCalculated = 15
3772 
3773   };
3774 
3775   // Factory methods
3776   static CommonAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
3777   static CommonAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
3778   static CommonAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_common);
3779   static CommonAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_common);
3780 
3781   // Constructors
3782   CommonAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
3783              );
3784 
3785   CommonAttr *clone(ASTContext &C) const;
3786   void printPretty(raw_ostream &OS,
3787                    const PrintingPolicy &Policy) const;
3788   const char *getSpelling() const;
3789 
3790 
3791   static bool classof(const Attr *A) { return A->getKind() == attr::Common; }
3792 };
3793 
3794 class CLANG_ABI ConstAttr : public InheritableAttr {
3795 public:
3796   enum Spelling {
3797     GNU_const = 0,
3798     CXX11_gnu_const = 1,
3799     C23_gnu_const = 2,
3800   SpellingNotCalculated = 15
3801 
3802   };
3803 
3804   // Factory methods
3805   static ConstAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
3806   static ConstAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
3807   static ConstAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_const);
3808   static ConstAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_const);
3809 
3810   // Constructors
3811   ConstAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
3812              );
3813 
3814   ConstAttr *clone(ASTContext &C) const;
3815   void printPretty(raw_ostream &OS,
3816                    const PrintingPolicy &Policy) const;
3817   const char *getSpelling() const;
3818 
3819 
3820   static bool classof(const Attr *A) { return A->getKind() == attr::Const; }
3821 };
3822 
3823 class CLANG_ABI ConstInitAttr : public InheritableAttr {
3824 public:
3825   enum Spelling {
3826     Keyword_constinit = 0,
3827     GNU_require_constant_initialization = 1,
3828     CXX11_clang_require_constant_initialization = 2,
3829   SpellingNotCalculated = 15
3830 
3831   };
3832 
3833   // Factory methods
3834   static ConstInitAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
3835   static ConstInitAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
3836   static ConstInitAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = Keyword_constinit);
3837   static ConstInitAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = Keyword_constinit);
3838 
3839   // Constructors
3840   ConstInitAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
3841              );
3842 
3843   ConstInitAttr *clone(ASTContext &C) const;
3844   void printPretty(raw_ostream &OS,
3845                    const PrintingPolicy &Policy) const;
3846   const char *getSpelling() const;
3847   Spelling getSemanticSpelling() const;
3848   bool isConstinit() const { return getAttributeSpellingListIndex() == 0; }
3849 
3850 
3851   static bool classof(const Attr *A) { return A->getKind() == attr::ConstInit; }
3852 };
3853 
3854 class CLANG_ABI ConstructorAttr : public InheritableAttr {
3855 int priority;
3856 
3857 public:
3858   enum Spelling {
3859     GNU_constructor = 0,
3860     CXX11_gnu_constructor = 1,
3861     C23_gnu_constructor = 2,
3862   SpellingNotCalculated = 15
3863 
3864   };
3865 
3866   // Factory methods
3867   static ConstructorAttr *CreateImplicit(ASTContext &Ctx, int Priority, const AttributeCommonInfo &CommonInfo);
3868   static ConstructorAttr *Create(ASTContext &Ctx, int Priority, const AttributeCommonInfo &CommonInfo);
3869   static ConstructorAttr *CreateImplicit(ASTContext &Ctx, int Priority, SourceRange Range = {}, Spelling S = GNU_constructor);
3870   static ConstructorAttr *Create(ASTContext &Ctx, int Priority, SourceRange Range = {}, Spelling S = GNU_constructor);
3871 
3872   // Constructors
3873   ConstructorAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
3874               , int Priority
3875              );
3876   ConstructorAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
3877              );
3878 
3879   ConstructorAttr *clone(ASTContext &C) const;
3880   void printPretty(raw_ostream &OS,
3881                    const PrintingPolicy &Policy) const;
3882   const char *getSpelling() const;
3883   int getPriority() const {
3884     return priority;
3885   }
3886 
3887   static const int DefaultPriority = 65535;
3888 
3889 
3890 
3891   static bool classof(const Attr *A) { return A->getKind() == attr::Constructor; }
3892 };
3893 
3894 class CLANG_ABI ConsumableAttr : public InheritableAttr {
3895 public:
3896   enum ConsumedState {
3897     Unknown,
3898     Consumed,
3899     Unconsumed
3900   };
3901 private:
3902   ConsumableAttr::ConsumedState defaultState;
3903 
3904 public:
3905   enum Spelling {
3906     GNU_consumable = 0,
3907     CXX11_clang_consumable = 1,
3908   SpellingNotCalculated = 15
3909 
3910   };
3911 
3912   // Factory methods
3913   static ConsumableAttr *CreateImplicit(ASTContext &Ctx, ConsumableAttr::ConsumedState DefaultState, const AttributeCommonInfo &CommonInfo);
3914   static ConsumableAttr *Create(ASTContext &Ctx, ConsumableAttr::ConsumedState DefaultState, const AttributeCommonInfo &CommonInfo);
3915   static ConsumableAttr *CreateImplicit(ASTContext &Ctx, ConsumableAttr::ConsumedState DefaultState, SourceRange Range = {}, Spelling S = GNU_consumable);
3916   static ConsumableAttr *Create(ASTContext &Ctx, ConsumableAttr::ConsumedState DefaultState, SourceRange Range = {}, Spelling S = GNU_consumable);
3917 
3918   // Constructors
3919   ConsumableAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
3920               , ConsumableAttr::ConsumedState DefaultState
3921              );
3922 
3923   ConsumableAttr *clone(ASTContext &C) const;
3924   void printPretty(raw_ostream &OS,
3925                    const PrintingPolicy &Policy) const;
3926   const char *getSpelling() const;
3927   ConsumableAttr::ConsumedState getDefaultState() const {
3928     return defaultState;
3929   }
3930 
3931   static bool ConvertStrToConsumedState(StringRef Val, ConsumableAttr::ConsumedState &Out);
3932   static const char *ConvertConsumedStateToStr(ConsumableAttr::ConsumedState Val);
3933 
3934 
3935   static bool classof(const Attr *A) { return A->getKind() == attr::Consumable; }
3936 };
3937 
3938 class CLANG_ABI ConsumableAutoCastAttr : public InheritableAttr {
3939 public:
3940   enum Spelling {
3941     GNU_consumable_auto_cast_state = 0,
3942     CXX11_clang_consumable_auto_cast_state = 1,
3943   SpellingNotCalculated = 15
3944 
3945   };
3946 
3947   // Factory methods
3948   static ConsumableAutoCastAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
3949   static ConsumableAutoCastAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
3950   static ConsumableAutoCastAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_consumable_auto_cast_state);
3951   static ConsumableAutoCastAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_consumable_auto_cast_state);
3952 
3953   // Constructors
3954   ConsumableAutoCastAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
3955              );
3956 
3957   ConsumableAutoCastAttr *clone(ASTContext &C) const;
3958   void printPretty(raw_ostream &OS,
3959                    const PrintingPolicy &Policy) const;
3960   const char *getSpelling() const;
3961 
3962 
3963   static bool classof(const Attr *A) { return A->getKind() == attr::ConsumableAutoCast; }
3964 };
3965 
3966 class CLANG_ABI ConsumableSetOnReadAttr : public InheritableAttr {
3967 public:
3968   enum Spelling {
3969     GNU_consumable_set_state_on_read = 0,
3970     CXX11_clang_consumable_set_state_on_read = 1,
3971   SpellingNotCalculated = 15
3972 
3973   };
3974 
3975   // Factory methods
3976   static ConsumableSetOnReadAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
3977   static ConsumableSetOnReadAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
3978   static ConsumableSetOnReadAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_consumable_set_state_on_read);
3979   static ConsumableSetOnReadAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_consumable_set_state_on_read);
3980 
3981   // Constructors
3982   ConsumableSetOnReadAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
3983              );
3984 
3985   ConsumableSetOnReadAttr *clone(ASTContext &C) const;
3986   void printPretty(raw_ostream &OS,
3987                    const PrintingPolicy &Policy) const;
3988   const char *getSpelling() const;
3989 
3990 
3991   static bool classof(const Attr *A) { return A->getKind() == attr::ConsumableSetOnRead; }
3992 };
3993 
3994 class CLANG_ABI ConvergentAttr : public InheritableAttr {
3995 public:
3996   enum Spelling {
3997     GNU_convergent = 0,
3998     CXX11_clang_convergent = 1,
3999     C23_clang_convergent = 2,
4000   SpellingNotCalculated = 15
4001 
4002   };
4003 
4004   // Factory methods
4005   static ConvergentAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
4006   static ConvergentAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
4007   static ConvergentAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_convergent);
4008   static ConvergentAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_convergent);
4009 
4010   // Constructors
4011   ConvergentAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
4012              );
4013 
4014   ConvergentAttr *clone(ASTContext &C) const;
4015   void printPretty(raw_ostream &OS,
4016                    const PrintingPolicy &Policy) const;
4017   const char *getSpelling() const;
4018 
4019 
4020   static bool classof(const Attr *A) { return A->getKind() == attr::Convergent; }
4021 };
4022 
4023 class CLANG_ABI CoroAwaitElidableAttr : public InheritableAttr {
4024 public:
4025   enum Spelling {
4026     GNU_coro_await_elidable = 0,
4027     CXX11_clang_coro_await_elidable = 1,
4028     C23_clang_coro_await_elidable = 2,
4029   SpellingNotCalculated = 15
4030 
4031   };
4032 
4033   // Factory methods
4034   static CoroAwaitElidableAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
4035   static CoroAwaitElidableAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
4036   static CoroAwaitElidableAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_coro_await_elidable);
4037   static CoroAwaitElidableAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_coro_await_elidable);
4038 
4039   // Constructors
4040   CoroAwaitElidableAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
4041              );
4042 
4043   CoroAwaitElidableAttr *clone(ASTContext &C) const;
4044   void printPretty(raw_ostream &OS,
4045                    const PrintingPolicy &Policy) const;
4046   const char *getSpelling() const;
4047 
4048 
4049   static bool classof(const Attr *A) { return A->getKind() == attr::CoroAwaitElidable; }
4050 };
4051 
4052 class CLANG_ABI CoroAwaitElidableArgumentAttr : public InheritableAttr {
4053 public:
4054   enum Spelling {
4055     GNU_coro_await_elidable_argument = 0,
4056     CXX11_clang_coro_await_elidable_argument = 1,
4057     C23_clang_coro_await_elidable_argument = 2,
4058   SpellingNotCalculated = 15
4059 
4060   };
4061 
4062   // Factory methods
4063   static CoroAwaitElidableArgumentAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
4064   static CoroAwaitElidableArgumentAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
4065   static CoroAwaitElidableArgumentAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_coro_await_elidable_argument);
4066   static CoroAwaitElidableArgumentAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_coro_await_elidable_argument);
4067 
4068   // Constructors
4069   CoroAwaitElidableArgumentAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
4070              );
4071 
4072   CoroAwaitElidableArgumentAttr *clone(ASTContext &C) const;
4073   void printPretty(raw_ostream &OS,
4074                    const PrintingPolicy &Policy) const;
4075   const char *getSpelling() const;
4076 
4077 
4078   static bool classof(const Attr *A) { return A->getKind() == attr::CoroAwaitElidableArgument; }
4079 };
4080 
4081 class CLANG_ABI CoroDisableLifetimeBoundAttr : public InheritableAttr {
4082 public:
4083   enum Spelling {
4084     GNU_coro_disable_lifetimebound = 0,
4085     CXX11_clang_coro_disable_lifetimebound = 1,
4086     C23_clang_coro_disable_lifetimebound = 2,
4087   SpellingNotCalculated = 15
4088 
4089   };
4090 
4091   // Factory methods
4092   static CoroDisableLifetimeBoundAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
4093   static CoroDisableLifetimeBoundAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
4094   static CoroDisableLifetimeBoundAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_coro_disable_lifetimebound);
4095   static CoroDisableLifetimeBoundAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_coro_disable_lifetimebound);
4096 
4097   // Constructors
4098   CoroDisableLifetimeBoundAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
4099              );
4100 
4101   CoroDisableLifetimeBoundAttr *clone(ASTContext &C) const;
4102   void printPretty(raw_ostream &OS,
4103                    const PrintingPolicy &Policy) const;
4104   const char *getSpelling() const;
4105 
4106 
4107   static bool classof(const Attr *A) { return A->getKind() == attr::CoroDisableLifetimeBound; }
4108 };
4109 
4110 class CLANG_ABI CoroLifetimeBoundAttr : public InheritableAttr {
4111 public:
4112   enum Spelling {
4113     GNU_coro_lifetimebound = 0,
4114     CXX11_clang_coro_lifetimebound = 1,
4115     C23_clang_coro_lifetimebound = 2,
4116   SpellingNotCalculated = 15
4117 
4118   };
4119 
4120   // Factory methods
4121   static CoroLifetimeBoundAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
4122   static CoroLifetimeBoundAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
4123   static CoroLifetimeBoundAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_coro_lifetimebound);
4124   static CoroLifetimeBoundAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_coro_lifetimebound);
4125 
4126   // Constructors
4127   CoroLifetimeBoundAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
4128              );
4129 
4130   CoroLifetimeBoundAttr *clone(ASTContext &C) const;
4131   void printPretty(raw_ostream &OS,
4132                    const PrintingPolicy &Policy) const;
4133   const char *getSpelling() const;
4134 
4135 
4136   static bool classof(const Attr *A) { return A->getKind() == attr::CoroLifetimeBound; }
4137 };
4138 
4139 class CLANG_ABI CoroOnlyDestroyWhenCompleteAttr : public InheritableAttr {
4140 public:
4141   enum Spelling {
4142     GNU_coro_only_destroy_when_complete = 0,
4143     CXX11_clang_coro_only_destroy_when_complete = 1,
4144     C23_clang_coro_only_destroy_when_complete = 2,
4145   SpellingNotCalculated = 15
4146 
4147   };
4148 
4149   // Factory methods
4150   static CoroOnlyDestroyWhenCompleteAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
4151   static CoroOnlyDestroyWhenCompleteAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
4152   static CoroOnlyDestroyWhenCompleteAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_coro_only_destroy_when_complete);
4153   static CoroOnlyDestroyWhenCompleteAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_coro_only_destroy_when_complete);
4154 
4155   // Constructors
4156   CoroOnlyDestroyWhenCompleteAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
4157              );
4158 
4159   CoroOnlyDestroyWhenCompleteAttr *clone(ASTContext &C) const;
4160   void printPretty(raw_ostream &OS,
4161                    const PrintingPolicy &Policy) const;
4162   const char *getSpelling() const;
4163 
4164 
4165   static bool classof(const Attr *A) { return A->getKind() == attr::CoroOnlyDestroyWhenComplete; }
4166 };
4167 
4168 class CLANG_ABI CoroReturnTypeAttr : public InheritableAttr {
4169 public:
4170   enum Spelling {
4171     GNU_coro_return_type = 0,
4172     CXX11_clang_coro_return_type = 1,
4173     C23_clang_coro_return_type = 2,
4174   SpellingNotCalculated = 15
4175 
4176   };
4177 
4178   // Factory methods
4179   static CoroReturnTypeAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
4180   static CoroReturnTypeAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
4181   static CoroReturnTypeAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_coro_return_type);
4182   static CoroReturnTypeAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_coro_return_type);
4183 
4184   // Constructors
4185   CoroReturnTypeAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
4186              );
4187 
4188   CoroReturnTypeAttr *clone(ASTContext &C) const;
4189   void printPretty(raw_ostream &OS,
4190                    const PrintingPolicy &Policy) const;
4191   const char *getSpelling() const;
4192 
4193 
4194   static bool classof(const Attr *A) { return A->getKind() == attr::CoroReturnType; }
4195 };
4196 
4197 class CLANG_ABI CoroWrapperAttr : public InheritableAttr {
4198 public:
4199   enum Spelling {
4200     GNU_coro_wrapper = 0,
4201     CXX11_clang_coro_wrapper = 1,
4202     C23_clang_coro_wrapper = 2,
4203   SpellingNotCalculated = 15
4204 
4205   };
4206 
4207   // Factory methods
4208   static CoroWrapperAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
4209   static CoroWrapperAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
4210   static CoroWrapperAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_coro_wrapper);
4211   static CoroWrapperAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_coro_wrapper);
4212 
4213   // Constructors
4214   CoroWrapperAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
4215              );
4216 
4217   CoroWrapperAttr *clone(ASTContext &C) const;
4218   void printPretty(raw_ostream &OS,
4219                    const PrintingPolicy &Policy) const;
4220   const char *getSpelling() const;
4221 
4222 
4223   static bool classof(const Attr *A) { return A->getKind() == attr::CoroWrapper; }
4224 };
4225 
4226 class CLANG_ABI CountedByAttr : public InheritableAttr {
4227 Expr * count;
4228 
4229 int nestedLevel;
4230 
4231 public:
4232   enum Spelling {
4233     GNU_counted_by = 0,
4234     CXX11_clang_counted_by = 1,
4235     C23_clang_counted_by = 2,
4236   SpellingNotCalculated = 15
4237 
4238   };
4239 
4240   // Factory methods
4241   static CountedByAttr *CreateImplicit(ASTContext &Ctx, Expr * Count, int NestedLevel, const AttributeCommonInfo &CommonInfo);
4242   static CountedByAttr *Create(ASTContext &Ctx, Expr * Count, int NestedLevel, const AttributeCommonInfo &CommonInfo);
4243   static CountedByAttr *CreateImplicit(ASTContext &Ctx, Expr * Count, int NestedLevel, SourceRange Range = {}, Spelling S = GNU_counted_by);
4244   static CountedByAttr *Create(ASTContext &Ctx, Expr * Count, int NestedLevel, SourceRange Range = {}, Spelling S = GNU_counted_by);
4245 
4246   // Constructors
4247   CountedByAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
4248               , Expr * Count
4249               , int NestedLevel
4250              );
4251   CountedByAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
4252               , Expr * Count
4253              );
4254 
4255   CountedByAttr *clone(ASTContext &C) const;
4256   void printPretty(raw_ostream &OS,
4257                    const PrintingPolicy &Policy) const;
4258   const char *getSpelling() const;
4259   Expr * getCount() const {
4260     return count;
4261   }
4262 
4263   int getNestedLevel() const {
4264     return nestedLevel;
4265   }
4266 
4267 
4268 
4269   static bool classof(const Attr *A) { return A->getKind() == attr::CountedBy; }
4270 };
4271 
4272 class CLANG_ABI CountedByOrNullAttr : public InheritableAttr {
4273 Expr * count;
4274 
4275 int nestedLevel;
4276 
4277 public:
4278   enum Spelling {
4279     GNU_counted_by_or_null = 0,
4280     CXX11_clang_counted_by_or_null = 1,
4281     C23_clang_counted_by_or_null = 2,
4282   SpellingNotCalculated = 15
4283 
4284   };
4285 
4286   // Factory methods
4287   static CountedByOrNullAttr *CreateImplicit(ASTContext &Ctx, Expr * Count, int NestedLevel, const AttributeCommonInfo &CommonInfo);
4288   static CountedByOrNullAttr *Create(ASTContext &Ctx, Expr * Count, int NestedLevel, const AttributeCommonInfo &CommonInfo);
4289   static CountedByOrNullAttr *CreateImplicit(ASTContext &Ctx, Expr * Count, int NestedLevel, SourceRange Range = {}, Spelling S = GNU_counted_by_or_null);
4290   static CountedByOrNullAttr *Create(ASTContext &Ctx, Expr * Count, int NestedLevel, SourceRange Range = {}, Spelling S = GNU_counted_by_or_null);
4291 
4292   // Constructors
4293   CountedByOrNullAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
4294               , Expr * Count
4295               , int NestedLevel
4296              );
4297   CountedByOrNullAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
4298               , Expr * Count
4299              );
4300 
4301   CountedByOrNullAttr *clone(ASTContext &C) const;
4302   void printPretty(raw_ostream &OS,
4303                    const PrintingPolicy &Policy) const;
4304   const char *getSpelling() const;
4305   Expr * getCount() const {
4306     return count;
4307   }
4308 
4309   int getNestedLevel() const {
4310     return nestedLevel;
4311   }
4312 
4313 
4314 
4315   static bool classof(const Attr *A) { return A->getKind() == attr::CountedByOrNull; }
4316 };
4317 
4318 class CLANG_ABI DLLExportAttr : public InheritableAttr {
4319 public:
4320   enum Spelling {
4321     Declspec_dllexport = 0,
4322     GNU_dllexport = 1,
4323     CXX11_gnu_dllexport = 2,
4324     C23_gnu_dllexport = 3,
4325   SpellingNotCalculated = 15
4326 
4327   };
4328 
4329   // Factory methods
4330   static DLLExportAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
4331   static DLLExportAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
4332   static DLLExportAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = Declspec_dllexport);
4333   static DLLExportAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = Declspec_dllexport);
4334 
4335   // Constructors
4336   DLLExportAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
4337              );
4338 
4339   DLLExportAttr *clone(ASTContext &C) const;
4340   void printPretty(raw_ostream &OS,
4341                    const PrintingPolicy &Policy) const;
4342   const char *getSpelling() const;
4343 
4344 
4345   static bool classof(const Attr *A) { return A->getKind() == attr::DLLExport; }
4346 };
4347 
4348 class CLANG_ABI DLLExportStaticLocalAttr : public InheritableAttr {
4349 public:
4350   // Factory methods
4351   static DLLExportStaticLocalAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
4352   static DLLExportStaticLocalAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
4353   static DLLExportStaticLocalAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {});
4354   static DLLExportStaticLocalAttr *Create(ASTContext &Ctx, SourceRange Range = {});
4355 
4356   // Constructors
4357   DLLExportStaticLocalAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
4358              );
4359 
4360   DLLExportStaticLocalAttr *clone(ASTContext &C) const;
4361   void printPretty(raw_ostream &OS,
4362                    const PrintingPolicy &Policy) const;
4363   const char *getSpelling() const;
4364 
4365 
4366   static bool classof(const Attr *A) { return A->getKind() == attr::DLLExportStaticLocal; }
4367 };
4368 
4369 class CLANG_ABI DLLImportAttr : public InheritableAttr {
4370 public:
4371   enum Spelling {
4372     Declspec_dllimport = 0,
4373     GNU_dllimport = 1,
4374     CXX11_gnu_dllimport = 2,
4375     C23_gnu_dllimport = 3,
4376   SpellingNotCalculated = 15
4377 
4378   };
4379 
4380   // Factory methods
4381   static DLLImportAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
4382   static DLLImportAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
4383   static DLLImportAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = Declspec_dllimport);
4384   static DLLImportAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = Declspec_dllimport);
4385 
4386   // Constructors
4387   DLLImportAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
4388              );
4389 
4390   DLLImportAttr *clone(ASTContext &C) const;
4391   void printPretty(raw_ostream &OS,
4392                    const PrintingPolicy &Policy) const;
4393   const char *getSpelling() const;
4394 
4395 private:
4396   bool PropagatedToBaseTemplate = false;
4397 
4398 public:
4399   void setPropagatedToBaseTemplate() { PropagatedToBaseTemplate = true; }
4400   bool wasPropagatedToBaseTemplate() { return PropagatedToBaseTemplate; }
4401   
4402 
4403   static bool classof(const Attr *A) { return A->getKind() == attr::DLLImport; }
4404 };
4405 
4406 class CLANG_ABI DLLImportStaticLocalAttr : public InheritableAttr {
4407 public:
4408   // Factory methods
4409   static DLLImportStaticLocalAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
4410   static DLLImportStaticLocalAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
4411   static DLLImportStaticLocalAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {});
4412   static DLLImportStaticLocalAttr *Create(ASTContext &Ctx, SourceRange Range = {});
4413 
4414   // Constructors
4415   DLLImportStaticLocalAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
4416              );
4417 
4418   DLLImportStaticLocalAttr *clone(ASTContext &C) const;
4419   void printPretty(raw_ostream &OS,
4420                    const PrintingPolicy &Policy) const;
4421   const char *getSpelling() const;
4422 
4423 
4424   static bool classof(const Attr *A) { return A->getKind() == attr::DLLImportStaticLocal; }
4425 };
4426 
4427 class CLANG_ABI DeprecatedAttr : public InheritableAttr {
4428 unsigned messageLength;
4429 char *message;
4430 
4431 unsigned replacementLength;
4432 char *replacement;
4433 
4434 public:
4435   enum Spelling {
4436     GNU_deprecated = 0,
4437     CXX11_gnu_deprecated = 1,
4438     C23_gnu_deprecated = 2,
4439     Declspec_deprecated = 3,
4440     CXX11_deprecated = 4,
4441     C23_deprecated = 5,
4442   SpellingNotCalculated = 15
4443 
4444   };
4445 
4446   // Factory methods
4447   static DeprecatedAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Message, llvm::StringRef Replacement, const AttributeCommonInfo &CommonInfo);
4448   static DeprecatedAttr *Create(ASTContext &Ctx, llvm::StringRef Message, llvm::StringRef Replacement, const AttributeCommonInfo &CommonInfo);
4449   static DeprecatedAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Message, llvm::StringRef Replacement, SourceRange Range = {}, Spelling S = GNU_deprecated);
4450   static DeprecatedAttr *Create(ASTContext &Ctx, llvm::StringRef Message, llvm::StringRef Replacement, SourceRange Range = {}, Spelling S = GNU_deprecated);
4451 
4452   // Constructors
4453   DeprecatedAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
4454               , llvm::StringRef Message
4455               , llvm::StringRef Replacement
4456              );
4457   DeprecatedAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
4458              );
4459 
4460   DeprecatedAttr *clone(ASTContext &C) const;
4461   void printPretty(raw_ostream &OS,
4462                    const PrintingPolicy &Policy) const;
4463   const char *getSpelling() const;
4464   llvm::StringRef getMessage() const {
4465     return llvm::StringRef(message, messageLength);
4466   }
4467   unsigned getMessageLength() const {
4468     return messageLength;
4469   }
4470   void setMessage(ASTContext &C, llvm::StringRef S) {
4471     messageLength = S.size();
4472     this->message = new (C, 1) char [messageLength];
4473     if (!S.empty())
4474       std::memcpy(this->message, S.data(), messageLength);
4475   }
4476 
4477   llvm::StringRef getReplacement() const {
4478     return llvm::StringRef(replacement, replacementLength);
4479   }
4480   unsigned getReplacementLength() const {
4481     return replacementLength;
4482   }
4483   void setReplacement(ASTContext &C, llvm::StringRef S) {
4484     replacementLength = S.size();
4485     this->replacement = new (C, 1) char [replacementLength];
4486     if (!S.empty())
4487       std::memcpy(this->replacement, S.data(), replacementLength);
4488   }
4489 
4490 
4491 
4492   static bool classof(const Attr *A) { return A->getKind() == attr::Deprecated; }
4493 };
4494 
4495 class CLANG_ABI DestructorAttr : public InheritableAttr {
4496 int priority;
4497 
4498 public:
4499   enum Spelling {
4500     GNU_destructor = 0,
4501     CXX11_gnu_destructor = 1,
4502     C23_gnu_destructor = 2,
4503   SpellingNotCalculated = 15
4504 
4505   };
4506 
4507   // Factory methods
4508   static DestructorAttr *CreateImplicit(ASTContext &Ctx, int Priority, const AttributeCommonInfo &CommonInfo);
4509   static DestructorAttr *Create(ASTContext &Ctx, int Priority, const AttributeCommonInfo &CommonInfo);
4510   static DestructorAttr *CreateImplicit(ASTContext &Ctx, int Priority, SourceRange Range = {}, Spelling S = GNU_destructor);
4511   static DestructorAttr *Create(ASTContext &Ctx, int Priority, SourceRange Range = {}, Spelling S = GNU_destructor);
4512 
4513   // Constructors
4514   DestructorAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
4515               , int Priority
4516              );
4517   DestructorAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
4518              );
4519 
4520   DestructorAttr *clone(ASTContext &C) const;
4521   void printPretty(raw_ostream &OS,
4522                    const PrintingPolicy &Policy) const;
4523   const char *getSpelling() const;
4524   int getPriority() const {
4525     return priority;
4526   }
4527 
4528   static const int DefaultPriority = 65535;
4529 
4530 
4531 
4532   static bool classof(const Attr *A) { return A->getKind() == attr::Destructor; }
4533 };
4534 
4535 class CLANG_ABI DiagnoseAsBuiltinAttr : public InheritableAttr {
4536 FunctionDecl * function;
4537 
4538   unsigned argIndices_Size;
4539   unsigned *argIndices_;
4540 
4541 public:
4542   enum Spelling {
4543     GNU_diagnose_as_builtin = 0,
4544     CXX11_clang_diagnose_as_builtin = 1,
4545     C23_clang_diagnose_as_builtin = 2,
4546   SpellingNotCalculated = 15
4547 
4548   };
4549 
4550   // Factory methods
4551   static DiagnoseAsBuiltinAttr *CreateImplicit(ASTContext &Ctx, FunctionDecl * Function, unsigned *ArgIndices, unsigned ArgIndicesSize, const AttributeCommonInfo &CommonInfo);
4552   static DiagnoseAsBuiltinAttr *Create(ASTContext &Ctx, FunctionDecl * Function, unsigned *ArgIndices, unsigned ArgIndicesSize, const AttributeCommonInfo &CommonInfo);
4553   static DiagnoseAsBuiltinAttr *CreateImplicit(ASTContext &Ctx, FunctionDecl * Function, unsigned *ArgIndices, unsigned ArgIndicesSize, SourceRange Range = {}, Spelling S = GNU_diagnose_as_builtin);
4554   static DiagnoseAsBuiltinAttr *Create(ASTContext &Ctx, FunctionDecl * Function, unsigned *ArgIndices, unsigned ArgIndicesSize, SourceRange Range = {}, Spelling S = GNU_diagnose_as_builtin);
4555 
4556   // Constructors
4557   DiagnoseAsBuiltinAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
4558               , FunctionDecl * Function
4559               , unsigned *ArgIndices, unsigned ArgIndicesSize
4560              );
4561   DiagnoseAsBuiltinAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
4562               , FunctionDecl * Function
4563              );
4564 
4565   DiagnoseAsBuiltinAttr *clone(ASTContext &C) const;
4566   void printPretty(raw_ostream &OS,
4567                    const PrintingPolicy &Policy) const;
4568   const char *getSpelling() const;
4569   FunctionDecl * getFunction() const {
4570     return function;
4571   }
4572 
4573   typedef unsigned* argIndices_iterator;
4574   argIndices_iterator argIndices_begin() const { return argIndices_; }
4575   argIndices_iterator argIndices_end() const { return argIndices_ + argIndices_Size; }
4576   unsigned argIndices_size() const { return argIndices_Size; }
4577   llvm::iterator_range<argIndices_iterator> argIndices() const { return llvm::make_range(argIndices_begin(), argIndices_end()); }
4578 
4579 
4580 
4581 
4582   static bool classof(const Attr *A) { return A->getKind() == attr::DiagnoseAsBuiltin; }
4583 };
4584 
4585 class CLANG_ABI DiagnoseIfAttr : public InheritableAttr {
4586 Expr * cond;
4587 
4588 unsigned messageLength;
4589 char *message;
4590 
4591 public:
4592   enum DefaultSeverity {
4593     DS_error,
4594     DS_warning
4595   };
4596 private:
4597   DiagnoseIfAttr::DefaultSeverity defaultSeverity;
4598 
4599 unsigned warningGroupLength;
4600 char *warningGroup;
4601 
4602 bool argDependent;
4603 
4604 NamedDecl * parent;
4605 
4606 public:
4607   // Factory methods
4608   static DiagnoseIfAttr *CreateImplicit(ASTContext &Ctx, Expr * Cond, llvm::StringRef Message, DiagnoseIfAttr::DefaultSeverity DefaultSeverity, llvm::StringRef WarningGroup, bool ArgDependent, NamedDecl * Parent, const AttributeCommonInfo &CommonInfo);
4609   static DiagnoseIfAttr *Create(ASTContext &Ctx, Expr * Cond, llvm::StringRef Message, DiagnoseIfAttr::DefaultSeverity DefaultSeverity, llvm::StringRef WarningGroup, bool ArgDependent, NamedDecl * Parent, const AttributeCommonInfo &CommonInfo);
4610   static DiagnoseIfAttr *CreateImplicit(ASTContext &Ctx, Expr * Cond, llvm::StringRef Message, DiagnoseIfAttr::DefaultSeverity DefaultSeverity, llvm::StringRef WarningGroup, bool ArgDependent, NamedDecl * Parent, SourceRange Range = {});
4611   static DiagnoseIfAttr *Create(ASTContext &Ctx, Expr * Cond, llvm::StringRef Message, DiagnoseIfAttr::DefaultSeverity DefaultSeverity, llvm::StringRef WarningGroup, bool ArgDependent, NamedDecl * Parent, SourceRange Range = {});
4612   static DiagnoseIfAttr *CreateImplicit(ASTContext &Ctx, Expr * Cond, llvm::StringRef Message, DiagnoseIfAttr::DefaultSeverity DefaultSeverity, llvm::StringRef WarningGroup, const AttributeCommonInfo &CommonInfo);
4613   static DiagnoseIfAttr *Create(ASTContext &Ctx, Expr * Cond, llvm::StringRef Message, DiagnoseIfAttr::DefaultSeverity DefaultSeverity, llvm::StringRef WarningGroup, const AttributeCommonInfo &CommonInfo);
4614   static DiagnoseIfAttr *CreateImplicit(ASTContext &Ctx, Expr * Cond, llvm::StringRef Message, DiagnoseIfAttr::DefaultSeverity DefaultSeverity, llvm::StringRef WarningGroup, SourceRange Range = {});
4615   static DiagnoseIfAttr *Create(ASTContext &Ctx, Expr * Cond, llvm::StringRef Message, DiagnoseIfAttr::DefaultSeverity DefaultSeverity, llvm::StringRef WarningGroup, SourceRange Range = {});
4616 
4617   // Constructors
4618   DiagnoseIfAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
4619               , Expr * Cond
4620               , llvm::StringRef Message
4621               , DiagnoseIfAttr::DefaultSeverity DefaultSeverity
4622               , llvm::StringRef WarningGroup
4623               , bool ArgDependent
4624               , NamedDecl * Parent
4625              );
4626   DiagnoseIfAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
4627               , Expr * Cond
4628               , llvm::StringRef Message
4629               , DiagnoseIfAttr::DefaultSeverity DefaultSeverity
4630               , llvm::StringRef WarningGroup
4631              );
4632   DiagnoseIfAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
4633               , Expr * Cond
4634               , llvm::StringRef Message
4635               , DiagnoseIfAttr::DefaultSeverity DefaultSeverity
4636              );
4637 
4638   DiagnoseIfAttr *clone(ASTContext &C) const;
4639   void printPretty(raw_ostream &OS,
4640                    const PrintingPolicy &Policy) const;
4641   const char *getSpelling() const;
4642   Expr * getCond() const {
4643     return cond;
4644   }
4645 
4646   llvm::StringRef getMessage() const {
4647     return llvm::StringRef(message, messageLength);
4648   }
4649   unsigned getMessageLength() const {
4650     return messageLength;
4651   }
4652   void setMessage(ASTContext &C, llvm::StringRef S) {
4653     messageLength = S.size();
4654     this->message = new (C, 1) char [messageLength];
4655     if (!S.empty())
4656       std::memcpy(this->message, S.data(), messageLength);
4657   }
4658 
4659   DiagnoseIfAttr::DefaultSeverity getDefaultSeverity() const {
4660     return defaultSeverity;
4661   }
4662 
4663   static bool ConvertStrToDefaultSeverity(StringRef Val, DiagnoseIfAttr::DefaultSeverity &Out);
4664   static const char *ConvertDefaultSeverityToStr(DiagnoseIfAttr::DefaultSeverity Val);
4665   llvm::StringRef getWarningGroup() const {
4666     return llvm::StringRef(warningGroup, warningGroupLength);
4667   }
4668   unsigned getWarningGroupLength() const {
4669     return warningGroupLength;
4670   }
4671   void setWarningGroup(ASTContext &C, llvm::StringRef S) {
4672     warningGroupLength = S.size();
4673     this->warningGroup = new (C, 1) char [warningGroupLength];
4674     if (!S.empty())
4675       std::memcpy(this->warningGroup, S.data(), warningGroupLength);
4676   }
4677 
4678   bool getArgDependent() const {
4679     return argDependent;
4680   }
4681 
4682   NamedDecl * getParent() const {
4683     return parent;
4684   }
4685 
4686 
4687 
4688   static bool classof(const Attr *A) { return A->getKind() == attr::DiagnoseIf; }
4689 };
4690 
4691 class CLANG_ABI DisableSanitizerInstrumentationAttr : public InheritableAttr {
4692 public:
4693   enum Spelling {
4694     GNU_disable_sanitizer_instrumentation = 0,
4695     CXX11_clang_disable_sanitizer_instrumentation = 1,
4696     C23_clang_disable_sanitizer_instrumentation = 2,
4697   SpellingNotCalculated = 15
4698 
4699   };
4700 
4701   // Factory methods
4702   static DisableSanitizerInstrumentationAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
4703   static DisableSanitizerInstrumentationAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
4704   static DisableSanitizerInstrumentationAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_disable_sanitizer_instrumentation);
4705   static DisableSanitizerInstrumentationAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_disable_sanitizer_instrumentation);
4706 
4707   // Constructors
4708   DisableSanitizerInstrumentationAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
4709              );
4710 
4711   DisableSanitizerInstrumentationAttr *clone(ASTContext &C) const;
4712   void printPretty(raw_ostream &OS,
4713                    const PrintingPolicy &Policy) const;
4714   const char *getSpelling() const;
4715 
4716 
4717   static bool classof(const Attr *A) { return A->getKind() == attr::DisableSanitizerInstrumentation; }
4718 };
4719 
4720 class CLANG_ABI DisableTailCallsAttr : public InheritableAttr {
4721 public:
4722   enum Spelling {
4723     GNU_disable_tail_calls = 0,
4724     CXX11_clang_disable_tail_calls = 1,
4725     C23_clang_disable_tail_calls = 2,
4726   SpellingNotCalculated = 15
4727 
4728   };
4729 
4730   // Factory methods
4731   static DisableTailCallsAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
4732   static DisableTailCallsAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
4733   static DisableTailCallsAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_disable_tail_calls);
4734   static DisableTailCallsAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_disable_tail_calls);
4735 
4736   // Constructors
4737   DisableTailCallsAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
4738              );
4739 
4740   DisableTailCallsAttr *clone(ASTContext &C) const;
4741   void printPretty(raw_ostream &OS,
4742                    const PrintingPolicy &Policy) const;
4743   const char *getSpelling() const;
4744 
4745 
4746   static bool classof(const Attr *A) { return A->getKind() == attr::DisableTailCalls; }
4747 };
4748 
4749 class CLANG_ABI EmptyBasesAttr : public InheritableAttr {
4750 public:
4751   // Factory methods
4752   static EmptyBasesAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
4753   static EmptyBasesAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
4754   static EmptyBasesAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {});
4755   static EmptyBasesAttr *Create(ASTContext &Ctx, SourceRange Range = {});
4756 
4757   // Constructors
4758   EmptyBasesAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
4759              );
4760 
4761   EmptyBasesAttr *clone(ASTContext &C) const;
4762   void printPretty(raw_ostream &OS,
4763                    const PrintingPolicy &Policy) const;
4764   const char *getSpelling() const;
4765 
4766 
4767   static bool classof(const Attr *A) { return A->getKind() == attr::EmptyBases; }
4768 };
4769 
4770 class CLANG_ABI EnableIfAttr : public InheritableAttr {
4771 Expr * cond;
4772 
4773 unsigned messageLength;
4774 char *message;
4775 
4776 public:
4777   // Factory methods
4778   static EnableIfAttr *CreateImplicit(ASTContext &Ctx, Expr * Cond, llvm::StringRef Message, const AttributeCommonInfo &CommonInfo);
4779   static EnableIfAttr *Create(ASTContext &Ctx, Expr * Cond, llvm::StringRef Message, const AttributeCommonInfo &CommonInfo);
4780   static EnableIfAttr *CreateImplicit(ASTContext &Ctx, Expr * Cond, llvm::StringRef Message, SourceRange Range = {});
4781   static EnableIfAttr *Create(ASTContext &Ctx, Expr * Cond, llvm::StringRef Message, SourceRange Range = {});
4782 
4783   // Constructors
4784   EnableIfAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
4785               , Expr * Cond
4786               , llvm::StringRef Message
4787              );
4788 
4789   EnableIfAttr *clone(ASTContext &C) const;
4790   void printPretty(raw_ostream &OS,
4791                    const PrintingPolicy &Policy) const;
4792   const char *getSpelling() const;
4793   Expr * getCond() const {
4794     return cond;
4795   }
4796 
4797   llvm::StringRef getMessage() const {
4798     return llvm::StringRef(message, messageLength);
4799   }
4800   unsigned getMessageLength() const {
4801     return messageLength;
4802   }
4803   void setMessage(ASTContext &C, llvm::StringRef S) {
4804     messageLength = S.size();
4805     this->message = new (C, 1) char [messageLength];
4806     if (!S.empty())
4807       std::memcpy(this->message, S.data(), messageLength);
4808   }
4809 
4810 
4811 
4812   static bool classof(const Attr *A) { return A->getKind() == attr::EnableIf; }
4813 };
4814 
4815 class CLANG_ABI EnforceTCBAttr : public InheritableAttr {
4816 unsigned tCBNameLength;
4817 char *tCBName;
4818 
4819 public:
4820   enum Spelling {
4821     GNU_enforce_tcb = 0,
4822     CXX11_clang_enforce_tcb = 1,
4823     C23_clang_enforce_tcb = 2,
4824   SpellingNotCalculated = 15
4825 
4826   };
4827 
4828   // Factory methods
4829   static EnforceTCBAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef TCBName, const AttributeCommonInfo &CommonInfo);
4830   static EnforceTCBAttr *Create(ASTContext &Ctx, llvm::StringRef TCBName, const AttributeCommonInfo &CommonInfo);
4831   static EnforceTCBAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef TCBName, SourceRange Range = {}, Spelling S = GNU_enforce_tcb);
4832   static EnforceTCBAttr *Create(ASTContext &Ctx, llvm::StringRef TCBName, SourceRange Range = {}, Spelling S = GNU_enforce_tcb);
4833 
4834   // Constructors
4835   EnforceTCBAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
4836               , llvm::StringRef TCBName
4837              );
4838 
4839   EnforceTCBAttr *clone(ASTContext &C) const;
4840   void printPretty(raw_ostream &OS,
4841                    const PrintingPolicy &Policy) const;
4842   const char *getSpelling() const;
4843   llvm::StringRef getTCBName() const {
4844     return llvm::StringRef(tCBName, tCBNameLength);
4845   }
4846   unsigned getTCBNameLength() const {
4847     return tCBNameLength;
4848   }
4849   void setTCBName(ASTContext &C, llvm::StringRef S) {
4850     tCBNameLength = S.size();
4851     this->tCBName = new (C, 1) char [tCBNameLength];
4852     if (!S.empty())
4853       std::memcpy(this->tCBName, S.data(), tCBNameLength);
4854   }
4855 
4856 
4857 
4858   static bool classof(const Attr *A) { return A->getKind() == attr::EnforceTCB; }
4859 };
4860 
4861 class CLANG_ABI EnforceTCBLeafAttr : public InheritableAttr {
4862 unsigned tCBNameLength;
4863 char *tCBName;
4864 
4865 public:
4866   enum Spelling {
4867     GNU_enforce_tcb_leaf = 0,
4868     CXX11_clang_enforce_tcb_leaf = 1,
4869     C23_clang_enforce_tcb_leaf = 2,
4870   SpellingNotCalculated = 15
4871 
4872   };
4873 
4874   // Factory methods
4875   static EnforceTCBLeafAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef TCBName, const AttributeCommonInfo &CommonInfo);
4876   static EnforceTCBLeafAttr *Create(ASTContext &Ctx, llvm::StringRef TCBName, const AttributeCommonInfo &CommonInfo);
4877   static EnforceTCBLeafAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef TCBName, SourceRange Range = {}, Spelling S = GNU_enforce_tcb_leaf);
4878   static EnforceTCBLeafAttr *Create(ASTContext &Ctx, llvm::StringRef TCBName, SourceRange Range = {}, Spelling S = GNU_enforce_tcb_leaf);
4879 
4880   // Constructors
4881   EnforceTCBLeafAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
4882               , llvm::StringRef TCBName
4883              );
4884 
4885   EnforceTCBLeafAttr *clone(ASTContext &C) const;
4886   void printPretty(raw_ostream &OS,
4887                    const PrintingPolicy &Policy) const;
4888   const char *getSpelling() const;
4889   llvm::StringRef getTCBName() const {
4890     return llvm::StringRef(tCBName, tCBNameLength);
4891   }
4892   unsigned getTCBNameLength() const {
4893     return tCBNameLength;
4894   }
4895   void setTCBName(ASTContext &C, llvm::StringRef S) {
4896     tCBNameLength = S.size();
4897     this->tCBName = new (C, 1) char [tCBNameLength];
4898     if (!S.empty())
4899       std::memcpy(this->tCBName, S.data(), tCBNameLength);
4900   }
4901 
4902 
4903 
4904   static bool classof(const Attr *A) { return A->getKind() == attr::EnforceTCBLeaf; }
4905 };
4906 
4907 class CLANG_ABI EnumExtensibilityAttr : public InheritableAttr {
4908 public:
4909   enum Kind {
4910     Closed,
4911     Open
4912   };
4913 private:
4914   EnumExtensibilityAttr::Kind extensibility;
4915 
4916 public:
4917   enum Spelling {
4918     GNU_enum_extensibility = 0,
4919     CXX11_clang_enum_extensibility = 1,
4920     C23_clang_enum_extensibility = 2,
4921   SpellingNotCalculated = 15
4922 
4923   };
4924 
4925   // Factory methods
4926   static EnumExtensibilityAttr *CreateImplicit(ASTContext &Ctx, EnumExtensibilityAttr::Kind Extensibility, const AttributeCommonInfo &CommonInfo);
4927   static EnumExtensibilityAttr *Create(ASTContext &Ctx, EnumExtensibilityAttr::Kind Extensibility, const AttributeCommonInfo &CommonInfo);
4928   static EnumExtensibilityAttr *CreateImplicit(ASTContext &Ctx, EnumExtensibilityAttr::Kind Extensibility, SourceRange Range = {}, Spelling S = GNU_enum_extensibility);
4929   static EnumExtensibilityAttr *Create(ASTContext &Ctx, EnumExtensibilityAttr::Kind Extensibility, SourceRange Range = {}, Spelling S = GNU_enum_extensibility);
4930 
4931   // Constructors
4932   EnumExtensibilityAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
4933               , EnumExtensibilityAttr::Kind Extensibility
4934              );
4935 
4936   EnumExtensibilityAttr *clone(ASTContext &C) const;
4937   void printPretty(raw_ostream &OS,
4938                    const PrintingPolicy &Policy) const;
4939   const char *getSpelling() const;
4940   EnumExtensibilityAttr::Kind getExtensibility() const {
4941     return extensibility;
4942   }
4943 
4944   static bool ConvertStrToKind(StringRef Val, EnumExtensibilityAttr::Kind &Out);
4945   static const char *ConvertKindToStr(EnumExtensibilityAttr::Kind Val);
4946 
4947 
4948   static bool classof(const Attr *A) { return A->getKind() == attr::EnumExtensibility; }
4949 };
4950 
4951 class CLANG_ABI ErrorAttr : public InheritableAttr {
4952 unsigned userDiagnosticLength;
4953 char *userDiagnostic;
4954 
4955 public:
4956   enum Spelling {
4957     GNU_error = 0,
4958     CXX11_gnu_error = 1,
4959     C23_gnu_error = 2,
4960     GNU_warning = 3,
4961     CXX11_gnu_warning = 4,
4962     C23_gnu_warning = 5,
4963   SpellingNotCalculated = 15
4964 
4965   };
4966 
4967   // Factory methods
4968   static ErrorAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef UserDiagnostic, const AttributeCommonInfo &CommonInfo);
4969   static ErrorAttr *Create(ASTContext &Ctx, llvm::StringRef UserDiagnostic, const AttributeCommonInfo &CommonInfo);
4970   static ErrorAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef UserDiagnostic, SourceRange Range = {}, Spelling S = GNU_error);
4971   static ErrorAttr *Create(ASTContext &Ctx, llvm::StringRef UserDiagnostic, SourceRange Range = {}, Spelling S = GNU_error);
4972 
4973   // Constructors
4974   ErrorAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
4975               , llvm::StringRef UserDiagnostic
4976              );
4977 
4978   ErrorAttr *clone(ASTContext &C) const;
4979   void printPretty(raw_ostream &OS,
4980                    const PrintingPolicy &Policy) const;
4981   const char *getSpelling() const;
4982   Spelling getSemanticSpelling() const;
4983   bool isError() const { return getAttributeSpellingListIndex() == 0 ||
4984     getAttributeSpellingListIndex() == 1 ||
4985     getAttributeSpellingListIndex() == 2; }
4986   bool isWarning() const { return getAttributeSpellingListIndex() == 3 ||
4987     getAttributeSpellingListIndex() == 4 ||
4988     getAttributeSpellingListIndex() == 5; }
4989   llvm::StringRef getUserDiagnostic() const {
4990     return llvm::StringRef(userDiagnostic, userDiagnosticLength);
4991   }
4992   unsigned getUserDiagnosticLength() const {
4993     return userDiagnosticLength;
4994   }
4995   void setUserDiagnostic(ASTContext &C, llvm::StringRef S) {
4996     userDiagnosticLength = S.size();
4997     this->userDiagnostic = new (C, 1) char [userDiagnosticLength];
4998     if (!S.empty())
4999       std::memcpy(this->userDiagnostic, S.data(), userDiagnosticLength);
5000   }
5001 
5002 
5003 
5004   static bool classof(const Attr *A) { return A->getKind() == attr::Error; }
5005 };
5006 
5007 class CLANG_ABI ExcludeFromExplicitInstantiationAttr : public InheritableAttr {
5008 public:
5009   enum Spelling {
5010     GNU_exclude_from_explicit_instantiation = 0,
5011     CXX11_clang_exclude_from_explicit_instantiation = 1,
5012     C23_clang_exclude_from_explicit_instantiation = 2,
5013   SpellingNotCalculated = 15
5014 
5015   };
5016 
5017   // Factory methods
5018   static ExcludeFromExplicitInstantiationAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
5019   static ExcludeFromExplicitInstantiationAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
5020   static ExcludeFromExplicitInstantiationAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_exclude_from_explicit_instantiation);
5021   static ExcludeFromExplicitInstantiationAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_exclude_from_explicit_instantiation);
5022 
5023   // Constructors
5024   ExcludeFromExplicitInstantiationAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
5025              );
5026 
5027   ExcludeFromExplicitInstantiationAttr *clone(ASTContext &C) const;
5028   void printPretty(raw_ostream &OS,
5029                    const PrintingPolicy &Policy) const;
5030   const char *getSpelling() const;
5031 
5032 
5033   static bool classof(const Attr *A) { return A->getKind() == attr::ExcludeFromExplicitInstantiation; }
5034 };
5035 
5036 class CLANG_ABI ExclusiveTrylockFunctionAttr : public InheritableAttr {
5037 Expr * successValue;
5038 
5039   unsigned args_Size;
5040   Expr * *args_;
5041 
5042 public:
5043   // Factory methods
5044   static ExclusiveTrylockFunctionAttr *CreateImplicit(ASTContext &Ctx, Expr * SuccessValue, Expr * *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo);
5045   static ExclusiveTrylockFunctionAttr *Create(ASTContext &Ctx, Expr * SuccessValue, Expr * *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo);
5046   static ExclusiveTrylockFunctionAttr *CreateImplicit(ASTContext &Ctx, Expr * SuccessValue, Expr * *Args, unsigned ArgsSize, SourceRange Range = {});
5047   static ExclusiveTrylockFunctionAttr *Create(ASTContext &Ctx, Expr * SuccessValue, Expr * *Args, unsigned ArgsSize, SourceRange Range = {});
5048 
5049   // Constructors
5050   ExclusiveTrylockFunctionAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
5051               , Expr * SuccessValue
5052               , Expr * *Args, unsigned ArgsSize
5053              );
5054   ExclusiveTrylockFunctionAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
5055               , Expr * SuccessValue
5056              );
5057 
5058   ExclusiveTrylockFunctionAttr *clone(ASTContext &C) const;
5059   void printPretty(raw_ostream &OS,
5060                    const PrintingPolicy &Policy) const;
5061   const char *getSpelling() const;
5062   Expr * getSuccessValue() const {
5063     return successValue;
5064   }
5065 
5066   typedef Expr ** args_iterator;
5067   args_iterator args_begin() const { return args_; }
5068   args_iterator args_end() const { return args_ + args_Size; }
5069   unsigned args_size() const { return args_Size; }
5070   llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }
5071 
5072 
5073 
5074 
5075   static bool classof(const Attr *A) { return A->getKind() == attr::ExclusiveTrylockFunction; }
5076 };
5077 
5078 class CLANG_ABI ExplicitInitAttr : public InheritableAttr {
5079 public:
5080   enum Spelling {
5081     GNU_require_explicit_initialization = 0,
5082     CXX11_clang_require_explicit_initialization = 1,
5083     C23_clang_require_explicit_initialization = 2,
5084   SpellingNotCalculated = 15
5085 
5086   };
5087 
5088   // Factory methods
5089   static ExplicitInitAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
5090   static ExplicitInitAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
5091   static ExplicitInitAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_require_explicit_initialization);
5092   static ExplicitInitAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_require_explicit_initialization);
5093 
5094   // Constructors
5095   ExplicitInitAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
5096              );
5097 
5098   ExplicitInitAttr *clone(ASTContext &C) const;
5099   void printPretty(raw_ostream &OS,
5100                    const PrintingPolicy &Policy) const;
5101   const char *getSpelling() const;
5102 
5103 
5104   static bool classof(const Attr *A) { return A->getKind() == attr::ExplicitInit; }
5105 };
5106 
5107 class CLANG_ABI ExternalSourceSymbolAttr : public InheritableAttr {
5108 unsigned languageLength;
5109 char *language;
5110 
5111 unsigned definedInLength;
5112 char *definedIn;
5113 
5114 bool generatedDeclaration;
5115 
5116 unsigned uSRLength;
5117 char *uSR;
5118 
5119 public:
5120   enum Spelling {
5121     GNU_external_source_symbol = 0,
5122     CXX11_clang_external_source_symbol = 1,
5123     C23_clang_external_source_symbol = 2,
5124   SpellingNotCalculated = 15
5125 
5126   };
5127 
5128   // Factory methods
5129   static ExternalSourceSymbolAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Language, llvm::StringRef DefinedIn, bool GeneratedDeclaration, llvm::StringRef USR, const AttributeCommonInfo &CommonInfo);
5130   static ExternalSourceSymbolAttr *Create(ASTContext &Ctx, llvm::StringRef Language, llvm::StringRef DefinedIn, bool GeneratedDeclaration, llvm::StringRef USR, const AttributeCommonInfo &CommonInfo);
5131   static ExternalSourceSymbolAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Language, llvm::StringRef DefinedIn, bool GeneratedDeclaration, llvm::StringRef USR, SourceRange Range = {}, Spelling S = GNU_external_source_symbol);
5132   static ExternalSourceSymbolAttr *Create(ASTContext &Ctx, llvm::StringRef Language, llvm::StringRef DefinedIn, bool GeneratedDeclaration, llvm::StringRef USR, SourceRange Range = {}, Spelling S = GNU_external_source_symbol);
5133 
5134   // Constructors
5135   ExternalSourceSymbolAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
5136               , llvm::StringRef Language
5137               , llvm::StringRef DefinedIn
5138               , bool GeneratedDeclaration
5139               , llvm::StringRef USR
5140              );
5141   ExternalSourceSymbolAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
5142              );
5143 
5144   ExternalSourceSymbolAttr *clone(ASTContext &C) const;
5145   void printPretty(raw_ostream &OS,
5146                    const PrintingPolicy &Policy) const;
5147   const char *getSpelling() const;
5148   llvm::StringRef getLanguage() const {
5149     return llvm::StringRef(language, languageLength);
5150   }
5151   unsigned getLanguageLength() const {
5152     return languageLength;
5153   }
5154   void setLanguage(ASTContext &C, llvm::StringRef S) {
5155     languageLength = S.size();
5156     this->language = new (C, 1) char [languageLength];
5157     if (!S.empty())
5158       std::memcpy(this->language, S.data(), languageLength);
5159   }
5160 
5161   llvm::StringRef getDefinedIn() const {
5162     return llvm::StringRef(definedIn, definedInLength);
5163   }
5164   unsigned getDefinedInLength() const {
5165     return definedInLength;
5166   }
5167   void setDefinedIn(ASTContext &C, llvm::StringRef S) {
5168     definedInLength = S.size();
5169     this->definedIn = new (C, 1) char [definedInLength];
5170     if (!S.empty())
5171       std::memcpy(this->definedIn, S.data(), definedInLength);
5172   }
5173 
5174   bool getGeneratedDeclaration() const {
5175     return generatedDeclaration;
5176   }
5177 
5178   llvm::StringRef getUSR() const {
5179     return llvm::StringRef(uSR, uSRLength);
5180   }
5181   unsigned getUSRLength() const {
5182     return uSRLength;
5183   }
5184   void setUSR(ASTContext &C, llvm::StringRef S) {
5185     uSRLength = S.size();
5186     this->uSR = new (C, 1) char [uSRLength];
5187     if (!S.empty())
5188       std::memcpy(this->uSR, S.data(), uSRLength);
5189   }
5190 
5191 
5192 
5193   static bool classof(const Attr *A) { return A->getKind() == attr::ExternalSourceSymbol; }
5194 };
5195 
5196 class CLANG_ABI FallThroughAttr : public StmtAttr {
5197 public:
5198   enum Spelling {
5199     CXX11_fallthrough = 0,
5200     C23_fallthrough = 1,
5201     CXX11_clang_fallthrough = 2,
5202     GNU_fallthrough = 3,
5203     CXX11_gnu_fallthrough = 4,
5204     C23_gnu_fallthrough = 5,
5205   SpellingNotCalculated = 15
5206 
5207   };
5208 
5209   // Factory methods
5210   static FallThroughAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
5211   static FallThroughAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
5212   static FallThroughAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = CXX11_fallthrough);
5213   static FallThroughAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = CXX11_fallthrough);
5214 
5215   // Constructors
5216   FallThroughAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
5217              );
5218 
5219   FallThroughAttr *clone(ASTContext &C) const;
5220   void printPretty(raw_ostream &OS,
5221                    const PrintingPolicy &Policy) const;
5222   const char *getSpelling() const;
5223 
5224 
5225   static bool classof(const Attr *A) { return A->getKind() == attr::FallThrough; }
5226 };
5227 
5228 class CLANG_ABI FastCallAttr : public InheritableAttr {
5229 public:
5230   enum Spelling {
5231     GNU_fastcall = 0,
5232     CXX11_gnu_fastcall = 1,
5233     C23_gnu_fastcall = 2,
5234     Keyword_fastcall = 3,
5235   SpellingNotCalculated = 15
5236 
5237   };
5238 
5239   // Factory methods
5240   static FastCallAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
5241   static FastCallAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
5242   static FastCallAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_fastcall);
5243   static FastCallAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_fastcall);
5244 
5245   // Constructors
5246   FastCallAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
5247              );
5248 
5249   FastCallAttr *clone(ASTContext &C) const;
5250   void printPretty(raw_ostream &OS,
5251                    const PrintingPolicy &Policy) const;
5252   const char *getSpelling() const;
5253 
5254 
5255   static bool classof(const Attr *A) { return A->getKind() == attr::FastCall; }
5256 };
5257 
5258 class CLANG_ABI FinalAttr : public InheritableAttr {
5259 public:
5260   enum Spelling {
5261     Keyword_final = 0,
5262     Keyword_sealed = 1,
5263   SpellingNotCalculated = 15
5264 
5265   };
5266 
5267   // Factory methods
5268   static FinalAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
5269   static FinalAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
5270   static FinalAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = Keyword_final);
5271   static FinalAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = Keyword_final);
5272 
5273   // Constructors
5274   FinalAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
5275              );
5276 
5277   FinalAttr *clone(ASTContext &C) const;
5278   void printPretty(raw_ostream &OS,
5279                    const PrintingPolicy &Policy) const;
5280   const char *getSpelling() const;
5281   Spelling getSemanticSpelling() const;
5282   bool isSpelledAsSealed() const { return getAttributeSpellingListIndex() == 1; }
5283 
5284 
5285   static bool classof(const Attr *A) { return A->getKind() == attr::Final; }
5286 };
5287 
5288 class CLANG_ABI FlagEnumAttr : public InheritableAttr {
5289 public:
5290   enum Spelling {
5291     GNU_flag_enum = 0,
5292     CXX11_clang_flag_enum = 1,
5293     C23_clang_flag_enum = 2,
5294   SpellingNotCalculated = 15
5295 
5296   };
5297 
5298   // Factory methods
5299   static FlagEnumAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
5300   static FlagEnumAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
5301   static FlagEnumAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_flag_enum);
5302   static FlagEnumAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_flag_enum);
5303 
5304   // Constructors
5305   FlagEnumAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
5306              );
5307 
5308   FlagEnumAttr *clone(ASTContext &C) const;
5309   void printPretty(raw_ostream &OS,
5310                    const PrintingPolicy &Policy) const;
5311   const char *getSpelling() const;
5312 
5313 
5314   static bool classof(const Attr *A) { return A->getKind() == attr::FlagEnum; }
5315 };
5316 
5317 class CLANG_ABI FlattenAttr : public InheritableAttr {
5318 public:
5319   enum Spelling {
5320     GNU_flatten = 0,
5321     CXX11_gnu_flatten = 1,
5322     C23_gnu_flatten = 2,
5323   SpellingNotCalculated = 15
5324 
5325   };
5326 
5327   // Factory methods
5328   static FlattenAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
5329   static FlattenAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
5330   static FlattenAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_flatten);
5331   static FlattenAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_flatten);
5332 
5333   // Constructors
5334   FlattenAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
5335              );
5336 
5337   FlattenAttr *clone(ASTContext &C) const;
5338   void printPretty(raw_ostream &OS,
5339                    const PrintingPolicy &Policy) const;
5340   const char *getSpelling() const;
5341 
5342 
5343   static bool classof(const Attr *A) { return A->getKind() == attr::Flatten; }
5344 };
5345 
5346 class CLANG_ABI FormatAttr : public InheritableAttr {
5347 IdentifierInfo * type;
5348 
5349 int formatIdx;
5350 
5351 int firstArg;
5352 
5353 public:
5354   enum Spelling {
5355     GNU_format = 0,
5356     CXX11_gnu_format = 1,
5357     C23_gnu_format = 2,
5358   SpellingNotCalculated = 15
5359 
5360   };
5361 
5362   // Factory methods
5363   static FormatAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * Type, int FormatIdx, int FirstArg, const AttributeCommonInfo &CommonInfo);
5364   static FormatAttr *Create(ASTContext &Ctx, IdentifierInfo * Type, int FormatIdx, int FirstArg, const AttributeCommonInfo &CommonInfo);
5365   static FormatAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * Type, int FormatIdx, int FirstArg, SourceRange Range = {}, Spelling S = GNU_format);
5366   static FormatAttr *Create(ASTContext &Ctx, IdentifierInfo * Type, int FormatIdx, int FirstArg, SourceRange Range = {}, Spelling S = GNU_format);
5367 
5368   // Constructors
5369   FormatAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
5370               , IdentifierInfo * Type
5371               , int FormatIdx
5372               , int FirstArg
5373              );
5374 
5375   FormatAttr *clone(ASTContext &C) const;
5376   void printPretty(raw_ostream &OS,
5377                    const PrintingPolicy &Policy) const;
5378   const char *getSpelling() const;
5379   IdentifierInfo * getType() const {
5380     return type;
5381   }
5382 
5383   int getFormatIdx() const {
5384     return formatIdx;
5385   }
5386 
5387   int getFirstArg() const {
5388     return firstArg;
5389   }
5390 
5391 
5392 
5393   static bool classof(const Attr *A) { return A->getKind() == attr::Format; }
5394 };
5395 
5396 class CLANG_ABI FormatArgAttr : public InheritableAttr {
5397 ParamIdx formatIdx;
5398 
5399 public:
5400   enum Spelling {
5401     GNU_format_arg = 0,
5402     CXX11_gnu_format_arg = 1,
5403     C23_gnu_format_arg = 2,
5404   SpellingNotCalculated = 15
5405 
5406   };
5407 
5408   // Factory methods
5409   static FormatArgAttr *CreateImplicit(ASTContext &Ctx, ParamIdx FormatIdx, const AttributeCommonInfo &CommonInfo);
5410   static FormatArgAttr *Create(ASTContext &Ctx, ParamIdx FormatIdx, const AttributeCommonInfo &CommonInfo);
5411   static FormatArgAttr *CreateImplicit(ASTContext &Ctx, ParamIdx FormatIdx, SourceRange Range = {}, Spelling S = GNU_format_arg);
5412   static FormatArgAttr *Create(ASTContext &Ctx, ParamIdx FormatIdx, SourceRange Range = {}, Spelling S = GNU_format_arg);
5413 
5414   // Constructors
5415   FormatArgAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
5416               , ParamIdx FormatIdx
5417              );
5418 
5419   FormatArgAttr *clone(ASTContext &C) const;
5420   void printPretty(raw_ostream &OS,
5421                    const PrintingPolicy &Policy) const;
5422   const char *getSpelling() const;
5423   ParamIdx getFormatIdx() const {
5424     return formatIdx;
5425   }
5426 
5427 
5428 
5429   static bool classof(const Attr *A) { return A->getKind() == attr::FormatArg; }
5430 };
5431 
5432 class CLANG_ABI FunctionReturnThunksAttr : public InheritableAttr {
5433 public:
5434   enum Kind {
5435     Keep,
5436     Extern
5437   };
5438 private:
5439   FunctionReturnThunksAttr::Kind thunkType;
5440 
5441 public:
5442   enum Spelling {
5443     GNU_function_return = 0,
5444     CXX11_gnu_function_return = 1,
5445     C23_gnu_function_return = 2,
5446   SpellingNotCalculated = 15
5447 
5448   };
5449 
5450   // Factory methods
5451   static FunctionReturnThunksAttr *CreateImplicit(ASTContext &Ctx, FunctionReturnThunksAttr::Kind ThunkType, const AttributeCommonInfo &CommonInfo);
5452   static FunctionReturnThunksAttr *Create(ASTContext &Ctx, FunctionReturnThunksAttr::Kind ThunkType, const AttributeCommonInfo &CommonInfo);
5453   static FunctionReturnThunksAttr *CreateImplicit(ASTContext &Ctx, FunctionReturnThunksAttr::Kind ThunkType, SourceRange Range = {}, Spelling S = GNU_function_return);
5454   static FunctionReturnThunksAttr *Create(ASTContext &Ctx, FunctionReturnThunksAttr::Kind ThunkType, SourceRange Range = {}, Spelling S = GNU_function_return);
5455 
5456   // Constructors
5457   FunctionReturnThunksAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
5458               , FunctionReturnThunksAttr::Kind ThunkType
5459              );
5460 
5461   FunctionReturnThunksAttr *clone(ASTContext &C) const;
5462   void printPretty(raw_ostream &OS,
5463                    const PrintingPolicy &Policy) const;
5464   const char *getSpelling() const;
5465   FunctionReturnThunksAttr::Kind getThunkType() const {
5466     return thunkType;
5467   }
5468 
5469   static bool ConvertStrToKind(StringRef Val, FunctionReturnThunksAttr::Kind &Out);
5470   static const char *ConvertKindToStr(FunctionReturnThunksAttr::Kind Val);
5471 
5472 
5473   static bool classof(const Attr *A) { return A->getKind() == attr::FunctionReturnThunks; }
5474 };
5475 
5476 class CLANG_ABI GNUInlineAttr : public InheritableAttr {
5477 public:
5478   enum Spelling {
5479     GNU_gnu_inline = 0,
5480     CXX11_gnu_gnu_inline = 1,
5481     C23_gnu_gnu_inline = 2,
5482   SpellingNotCalculated = 15
5483 
5484   };
5485 
5486   // Factory methods
5487   static GNUInlineAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
5488   static GNUInlineAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
5489   static GNUInlineAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_gnu_inline);
5490   static GNUInlineAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_gnu_inline);
5491 
5492   // Constructors
5493   GNUInlineAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
5494              );
5495 
5496   GNUInlineAttr *clone(ASTContext &C) const;
5497   void printPretty(raw_ostream &OS,
5498                    const PrintingPolicy &Policy) const;
5499   const char *getSpelling() const;
5500 
5501 
5502   static bool classof(const Attr *A) { return A->getKind() == attr::GNUInline; }
5503 };
5504 
5505 class CLANG_ABI GuardedByAttr : public InheritableAttr {
5506 Expr * arg;
5507 
5508 public:
5509   // Factory methods
5510   static GuardedByAttr *CreateImplicit(ASTContext &Ctx, Expr * Arg, const AttributeCommonInfo &CommonInfo);
5511   static GuardedByAttr *Create(ASTContext &Ctx, Expr * Arg, const AttributeCommonInfo &CommonInfo);
5512   static GuardedByAttr *CreateImplicit(ASTContext &Ctx, Expr * Arg, SourceRange Range = {});
5513   static GuardedByAttr *Create(ASTContext &Ctx, Expr * Arg, SourceRange Range = {});
5514 
5515   // Constructors
5516   GuardedByAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
5517               , Expr * Arg
5518              );
5519 
5520   GuardedByAttr *clone(ASTContext &C) const;
5521   void printPretty(raw_ostream &OS,
5522                    const PrintingPolicy &Policy) const;
5523   const char *getSpelling() const;
5524   Expr * getArg() const {
5525     return arg;
5526   }
5527 
5528 
5529 
5530   static bool classof(const Attr *A) { return A->getKind() == attr::GuardedBy; }
5531 };
5532 
5533 class CLANG_ABI GuardedVarAttr : public InheritableAttr {
5534 public:
5535   enum Spelling {
5536     GNU_guarded_var = 0,
5537     CXX11_clang_guarded_var = 1,
5538   SpellingNotCalculated = 15
5539 
5540   };
5541 
5542   // Factory methods
5543   static GuardedVarAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
5544   static GuardedVarAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
5545   static GuardedVarAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_guarded_var);
5546   static GuardedVarAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_guarded_var);
5547 
5548   // Constructors
5549   GuardedVarAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
5550              );
5551 
5552   GuardedVarAttr *clone(ASTContext &C) const;
5553   void printPretty(raw_ostream &OS,
5554                    const PrintingPolicy &Policy) const;
5555   const char *getSpelling() const;
5556 
5557 
5558   static bool classof(const Attr *A) { return A->getKind() == attr::GuardedVar; }
5559 };
5560 
5561 class CLANG_ABI HIPManagedAttr : public InheritableAttr {
5562 public:
5563   enum Spelling {
5564     GNU_managed = 0,
5565     Declspec_managed = 1,
5566   SpellingNotCalculated = 15
5567 
5568   };
5569 
5570   // Factory methods
5571   static HIPManagedAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
5572   static HIPManagedAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
5573   static HIPManagedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_managed);
5574   static HIPManagedAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_managed);
5575 
5576   // Constructors
5577   HIPManagedAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
5578              );
5579 
5580   HIPManagedAttr *clone(ASTContext &C) const;
5581   void printPretty(raw_ostream &OS,
5582                    const PrintingPolicy &Policy) const;
5583   const char *getSpelling() const;
5584 
5585 
5586   static bool classof(const Attr *A) { return A->getKind() == attr::HIPManaged; }
5587 };
5588 
5589 class CLANG_ABI HLSLContainedTypeAttr : public TypeAttr {
5590 TypeSourceInfo * type;
5591 
5592 public:
5593   // Factory methods
5594   static HLSLContainedTypeAttr *CreateImplicit(ASTContext &Ctx, TypeSourceInfo * Type, const AttributeCommonInfo &CommonInfo);
5595   static HLSLContainedTypeAttr *Create(ASTContext &Ctx, TypeSourceInfo * Type, const AttributeCommonInfo &CommonInfo);
5596   static HLSLContainedTypeAttr *CreateImplicit(ASTContext &Ctx, TypeSourceInfo * Type, SourceRange Range = {});
5597   static HLSLContainedTypeAttr *Create(ASTContext &Ctx, TypeSourceInfo * Type, SourceRange Range = {});
5598 
5599   // Constructors
5600   HLSLContainedTypeAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
5601               , TypeSourceInfo * Type
5602              );
5603 
5604   HLSLContainedTypeAttr *clone(ASTContext &C) const;
5605   void printPretty(raw_ostream &OS,
5606                    const PrintingPolicy &Policy) const;
5607   const char *getSpelling() const;
5608   QualType getType() const {
5609     return type->getType();
5610   }  TypeSourceInfo * getTypeLoc() const {
5611     return type;
5612   }
5613 
5614 
5615 
5616   static bool classof(const Attr *A) { return A->getKind() == attr::HLSLContainedType; }
5617 };
5618 
5619 class CLANG_ABI HLSLControlFlowHintAttr : public StmtAttr {
5620 public:
5621   enum Spelling {
5622     Microsoft_branch = 0,
5623     Microsoft_flatten = 1,
5624   SpellingNotCalculated = 15
5625 
5626   };
5627 
5628   // Factory methods
5629   static HLSLControlFlowHintAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
5630   static HLSLControlFlowHintAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
5631   static HLSLControlFlowHintAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = Microsoft_branch);
5632   static HLSLControlFlowHintAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = Microsoft_branch);
5633 
5634   // Constructors
5635   HLSLControlFlowHintAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
5636              );
5637 
5638   HLSLControlFlowHintAttr *clone(ASTContext &C) const;
5639   void printPretty(raw_ostream &OS,
5640                    const PrintingPolicy &Policy) const;
5641   const char *getSpelling() const;
5642   Spelling getSemanticSpelling() const;
5643 
5644 
5645   static bool classof(const Attr *A) { return A->getKind() == attr::HLSLControlFlowHint; }
5646 };
5647 
5648 class CLANG_ABI HLSLGroupSharedAddressSpaceAttr : public TypeAttr {
5649 public:
5650   // Factory methods
5651   static HLSLGroupSharedAddressSpaceAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
5652   static HLSLGroupSharedAddressSpaceAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
5653   static HLSLGroupSharedAddressSpaceAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {});
5654   static HLSLGroupSharedAddressSpaceAttr *Create(ASTContext &Ctx, SourceRange Range = {});
5655 
5656   // Constructors
5657   HLSLGroupSharedAddressSpaceAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
5658              );
5659 
5660   HLSLGroupSharedAddressSpaceAttr *clone(ASTContext &C) const;
5661   void printPretty(raw_ostream &OS,
5662                    const PrintingPolicy &Policy) const;
5663   const char *getSpelling() const;
5664 
5665 
5666   static bool classof(const Attr *A) { return A->getKind() == attr::HLSLGroupSharedAddressSpace; }
5667 };
5668 
5669 class CLANG_ABI HLSLLoopHintAttr : public StmtAttr {
5670 unsigned directive;
5671 
5672 public:
5673   enum Spelling {
5674     Microsoft_unroll = 0,
5675     Microsoft_loop = 1,
5676   SpellingNotCalculated = 15
5677 
5678   };
5679 
5680   // Factory methods
5681   static HLSLLoopHintAttr *CreateImplicit(ASTContext &Ctx, unsigned Directive, const AttributeCommonInfo &CommonInfo);
5682   static HLSLLoopHintAttr *Create(ASTContext &Ctx, unsigned Directive, const AttributeCommonInfo &CommonInfo);
5683   static HLSLLoopHintAttr *CreateImplicit(ASTContext &Ctx, unsigned Directive, SourceRange Range = {}, Spelling S = Microsoft_unroll);
5684   static HLSLLoopHintAttr *Create(ASTContext &Ctx, unsigned Directive, SourceRange Range = {}, Spelling S = Microsoft_unroll);
5685 
5686   // Constructors
5687   HLSLLoopHintAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
5688               , unsigned Directive
5689              );
5690   HLSLLoopHintAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
5691              );
5692 
5693   HLSLLoopHintAttr *clone(ASTContext &C) const;
5694   void printPretty(raw_ostream &OS,
5695                    const PrintingPolicy &Policy) const;
5696   const char *getSpelling() const;
5697   Spelling getSemanticSpelling() const;
5698   unsigned getDirective() const {
5699     return directive;
5700   }
5701 
5702 
5703 
5704   static bool classof(const Attr *A) { return A->getKind() == attr::HLSLLoopHint; }
5705 };
5706 
5707 class CLANG_ABI HLSLNumThreadsAttr : public InheritableAttr {
5708 int x;
5709 
5710 int y;
5711 
5712 int z;
5713 
5714 public:
5715   // Factory methods
5716   static HLSLNumThreadsAttr *CreateImplicit(ASTContext &Ctx, int X, int Y, int Z, const AttributeCommonInfo &CommonInfo);
5717   static HLSLNumThreadsAttr *Create(ASTContext &Ctx, int X, int Y, int Z, const AttributeCommonInfo &CommonInfo);
5718   static HLSLNumThreadsAttr *CreateImplicit(ASTContext &Ctx, int X, int Y, int Z, SourceRange Range = {});
5719   static HLSLNumThreadsAttr *Create(ASTContext &Ctx, int X, int Y, int Z, SourceRange Range = {});
5720 
5721   // Constructors
5722   HLSLNumThreadsAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
5723               , int X
5724               , int Y
5725               , int Z
5726              );
5727 
5728   HLSLNumThreadsAttr *clone(ASTContext &C) const;
5729   void printPretty(raw_ostream &OS,
5730                    const PrintingPolicy &Policy) const;
5731   const char *getSpelling() const;
5732   int getX() const {
5733     return x;
5734   }
5735 
5736   int getY() const {
5737     return y;
5738   }
5739 
5740   int getZ() const {
5741     return z;
5742   }
5743 
5744 
5745 
5746   static bool classof(const Attr *A) { return A->getKind() == attr::HLSLNumThreads; }
5747 };
5748 
5749 class CLANG_ABI HLSLPackOffsetAttr : public HLSLAnnotationAttr {
5750 int subcomponent;
5751 
5752 int component;
5753 
5754 public:
5755   // Factory methods
5756   static HLSLPackOffsetAttr *CreateImplicit(ASTContext &Ctx, int Subcomponent, int Component, const AttributeCommonInfo &CommonInfo);
5757   static HLSLPackOffsetAttr *Create(ASTContext &Ctx, int Subcomponent, int Component, const AttributeCommonInfo &CommonInfo);
5758   static HLSLPackOffsetAttr *CreateImplicit(ASTContext &Ctx, int Subcomponent, int Component, SourceRange Range = {});
5759   static HLSLPackOffsetAttr *Create(ASTContext &Ctx, int Subcomponent, int Component, SourceRange Range = {});
5760 
5761   // Constructors
5762   HLSLPackOffsetAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
5763               , int Subcomponent
5764               , int Component
5765              );
5766 
5767   HLSLPackOffsetAttr *clone(ASTContext &C) const;
5768   void printPretty(raw_ostream &OS,
5769                    const PrintingPolicy &Policy) const;
5770   const char *getSpelling() const;
5771   int getSubcomponent() const {
5772     return subcomponent;
5773   }
5774 
5775   int getComponent() const {
5776     return component;
5777   }
5778 
5779 
5780   unsigned getOffsetInBytes() {
5781     return subcomponent * 16 + component * 4;
5782   }
5783   
5784 
5785   static bool classof(const Attr *A) { return A->getKind() == attr::HLSLPackOffset; }
5786 };
5787 
5788 class CLANG_ABI HLSLParamModifierAttr : public ParameterABIAttr {
5789 bool mergedSpelling;
5790 
5791 public:
5792   enum Spelling {
5793     Keyword_in = 0,
5794     Keyword_inout = 1,
5795     Keyword_out = 2,
5796   SpellingNotCalculated = 15
5797 
5798   };
5799 
5800   // Factory methods
5801   static HLSLParamModifierAttr *CreateImplicit(ASTContext &Ctx, bool MergedSpelling, const AttributeCommonInfo &CommonInfo);
5802   static HLSLParamModifierAttr *Create(ASTContext &Ctx, bool MergedSpelling, const AttributeCommonInfo &CommonInfo);
5803   static HLSLParamModifierAttr *CreateImplicit(ASTContext &Ctx, bool MergedSpelling, SourceRange Range = {}, Spelling S = Keyword_in);
5804   static HLSLParamModifierAttr *Create(ASTContext &Ctx, bool MergedSpelling, SourceRange Range = {}, Spelling S = Keyword_in);
5805   static HLSLParamModifierAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
5806   static HLSLParamModifierAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
5807   static HLSLParamModifierAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = Keyword_in);
5808   static HLSLParamModifierAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = Keyword_in);
5809 
5810   // Constructors
5811   HLSLParamModifierAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
5812               , bool MergedSpelling
5813              );
5814   HLSLParamModifierAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
5815              );
5816 
5817   HLSLParamModifierAttr *clone(ASTContext &C) const;
5818   void printPretty(raw_ostream &OS,
5819                    const PrintingPolicy &Policy) const;
5820   const char *getSpelling() const;
5821   Spelling getSemanticSpelling() const;
5822   bool isIn() const { return getAttributeSpellingListIndex() == 0; }
5823   bool isInOut() const { return getAttributeSpellingListIndex() == 1; }
5824   bool isOut() const { return getAttributeSpellingListIndex() == 2; }
5825   bool isAnyOut() const { return getAttributeSpellingListIndex() == 2 ||
5826     getAttributeSpellingListIndex() == 1; }
5827   bool isAnyIn() const { return getAttributeSpellingListIndex() == 0 ||
5828     getAttributeSpellingListIndex() == 1; }
5829   bool getMergedSpelling() const {
5830     return mergedSpelling;
5831   }
5832 
5833   static const bool DefaultMergedSpelling = false;
5834 
5835 
5836 
5837   static bool classof(const Attr *A) { return A->getKind() == attr::HLSLParamModifier; }
5838 };
5839 
5840 class CLANG_ABI HLSLROVAttr : public TypeAttr {
5841 public:
5842   // Factory methods
5843   static HLSLROVAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
5844   static HLSLROVAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
5845   static HLSLROVAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {});
5846   static HLSLROVAttr *Create(ASTContext &Ctx, SourceRange Range = {});
5847 
5848   // Constructors
5849   HLSLROVAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
5850              );
5851 
5852   HLSLROVAttr *clone(ASTContext &C) const;
5853   void printPretty(raw_ostream &OS,
5854                    const PrintingPolicy &Policy) const;
5855   const char *getSpelling() const;
5856 
5857 
5858   static bool classof(const Attr *A) { return A->getKind() == attr::HLSLROV; }
5859 };
5860 
5861 class CLANG_ABI HLSLRawBufferAttr : public TypeAttr {
5862 public:
5863   // Factory methods
5864   static HLSLRawBufferAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
5865   static HLSLRawBufferAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
5866   static HLSLRawBufferAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {});
5867   static HLSLRawBufferAttr *Create(ASTContext &Ctx, SourceRange Range = {});
5868 
5869   // Constructors
5870   HLSLRawBufferAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
5871              );
5872 
5873   HLSLRawBufferAttr *clone(ASTContext &C) const;
5874   void printPretty(raw_ostream &OS,
5875                    const PrintingPolicy &Policy) const;
5876   const char *getSpelling() const;
5877 
5878 
5879   static bool classof(const Attr *A) { return A->getKind() == attr::HLSLRawBuffer; }
5880 };
5881 
5882 class CLANG_ABI HLSLResourceAttr : public InheritableAttr {
5883 private:
5884   llvm::hlsl::ResourceKind resourceKind;
5885 
5886 public:
5887   // Factory methods
5888   static HLSLResourceAttr *CreateImplicit(ASTContext &Ctx, llvm::hlsl::ResourceKind ResourceKind, const AttributeCommonInfo &CommonInfo);
5889   static HLSLResourceAttr *Create(ASTContext &Ctx, llvm::hlsl::ResourceKind ResourceKind, const AttributeCommonInfo &CommonInfo);
5890   static HLSLResourceAttr *CreateImplicit(ASTContext &Ctx, llvm::hlsl::ResourceKind ResourceKind, SourceRange Range = {});
5891   static HLSLResourceAttr *Create(ASTContext &Ctx, llvm::hlsl::ResourceKind ResourceKind, SourceRange Range = {});
5892 
5893   // Constructors
5894   HLSLResourceAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
5895               , llvm::hlsl::ResourceKind ResourceKind
5896              );
5897 
5898   HLSLResourceAttr *clone(ASTContext &C) const;
5899   void printPretty(raw_ostream &OS,
5900                    const PrintingPolicy &Policy) const;
5901   const char *getSpelling() const;
5902   llvm::hlsl::ResourceKind getResourceKind() const {
5903     return resourceKind;
5904   }
5905 
5906   static bool ConvertStrToResourceKind(StringRef Val, llvm::hlsl::ResourceKind &Out);
5907   static const char *ConvertResourceKindToStr(llvm::hlsl::ResourceKind Val);
5908 
5909 
5910   static bool classof(const Attr *A) { return A->getKind() == attr::HLSLResource; }
5911 };
5912 
5913 class CLANG_ABI HLSLResourceBindingAttr : public InheritableAttr {
5914 unsigned slotLength;
5915 char *slot;
5916 
5917 unsigned spaceLength;
5918 char *space;
5919 
5920 public:
5921   // Factory methods
5922   static HLSLResourceBindingAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Slot, llvm::StringRef Space, const AttributeCommonInfo &CommonInfo);
5923   static HLSLResourceBindingAttr *Create(ASTContext &Ctx, llvm::StringRef Slot, llvm::StringRef Space, const AttributeCommonInfo &CommonInfo);
5924   static HLSLResourceBindingAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Slot, llvm::StringRef Space, SourceRange Range = {});
5925   static HLSLResourceBindingAttr *Create(ASTContext &Ctx, llvm::StringRef Slot, llvm::StringRef Space, SourceRange Range = {});
5926 
5927   // Constructors
5928   HLSLResourceBindingAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
5929               , llvm::StringRef Slot
5930               , llvm::StringRef Space
5931              );
5932   HLSLResourceBindingAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
5933               , llvm::StringRef Slot
5934              );
5935 
5936   HLSLResourceBindingAttr *clone(ASTContext &C) const;
5937   void printPretty(raw_ostream &OS,
5938                    const PrintingPolicy &Policy) const;
5939   const char *getSpelling() const;
5940   llvm::StringRef getSlot() const {
5941     return llvm::StringRef(slot, slotLength);
5942   }
5943   unsigned getSlotLength() const {
5944     return slotLength;
5945   }
5946   void setSlot(ASTContext &C, llvm::StringRef S) {
5947     slotLength = S.size();
5948     this->slot = new (C, 1) char [slotLength];
5949     if (!S.empty())
5950       std::memcpy(this->slot, S.data(), slotLength);
5951   }
5952 
5953   llvm::StringRef getSpace() const {
5954     return llvm::StringRef(space, spaceLength);
5955   }
5956   unsigned getSpaceLength() const {
5957     return spaceLength;
5958   }
5959   void setSpace(ASTContext &C, llvm::StringRef S) {
5960     spaceLength = S.size();
5961     this->space = new (C, 1) char [spaceLength];
5962     if (!S.empty())
5963       std::memcpy(this->space, S.data(), spaceLength);
5964   }
5965 
5966 
5967   public:
5968       enum class RegisterType : unsigned { SRV, UAV, CBuffer, Sampler, C, I };
5969 
5970   private:
5971       RegisterType RegType;
5972       unsigned SlotNumber;
5973       unsigned SpaceNumber;
5974 
5975   public:
5976       void setBinding(RegisterType RT, unsigned SlotNum, unsigned SpaceNum) {
5977         RegType = RT;
5978         SlotNumber = SlotNum;
5979         SpaceNumber = SpaceNum;
5980       }
5981       RegisterType getRegisterType() const {
5982         return RegType;
5983       }
5984       unsigned getSlotNumber() const {
5985         return SlotNumber;
5986       }
5987       unsigned getSpaceNumber() const {
5988         return SpaceNumber;
5989       }
5990   
5991 
5992   static bool classof(const Attr *A) { return A->getKind() == attr::HLSLResourceBinding; }
5993 };
5994 
5995 class CLANG_ABI HLSLResourceClassAttr : public TypeAttr {
5996 private:
5997   llvm::hlsl::ResourceClass resourceClass;
5998 
5999 public:
6000   // Factory methods
6001   static HLSLResourceClassAttr *CreateImplicit(ASTContext &Ctx, llvm::hlsl::ResourceClass ResourceClass, const AttributeCommonInfo &CommonInfo);
6002   static HLSLResourceClassAttr *Create(ASTContext &Ctx, llvm::hlsl::ResourceClass ResourceClass, const AttributeCommonInfo &CommonInfo);
6003   static HLSLResourceClassAttr *CreateImplicit(ASTContext &Ctx, llvm::hlsl::ResourceClass ResourceClass, SourceRange Range = {});
6004   static HLSLResourceClassAttr *Create(ASTContext &Ctx, llvm::hlsl::ResourceClass ResourceClass, SourceRange Range = {});
6005 
6006   // Constructors
6007   HLSLResourceClassAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
6008               , llvm::hlsl::ResourceClass ResourceClass
6009              );
6010 
6011   HLSLResourceClassAttr *clone(ASTContext &C) const;
6012   void printPretty(raw_ostream &OS,
6013                    const PrintingPolicy &Policy) const;
6014   const char *getSpelling() const;
6015   llvm::hlsl::ResourceClass getResourceClass() const {
6016     return resourceClass;
6017   }
6018 
6019   static bool ConvertStrToResourceClass(StringRef Val, llvm::hlsl::ResourceClass &Out);
6020   static const char *ConvertResourceClassToStr(llvm::hlsl::ResourceClass Val);
6021 
6022 
6023   static bool classof(const Attr *A) { return A->getKind() == attr::HLSLResourceClass; }
6024 };
6025 
6026 class CLANG_ABI HLSLSV_DispatchThreadIDAttr : public HLSLAnnotationAttr {
6027 public:
6028   // Factory methods
6029   static HLSLSV_DispatchThreadIDAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
6030   static HLSLSV_DispatchThreadIDAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
6031   static HLSLSV_DispatchThreadIDAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {});
6032   static HLSLSV_DispatchThreadIDAttr *Create(ASTContext &Ctx, SourceRange Range = {});
6033 
6034   // Constructors
6035   HLSLSV_DispatchThreadIDAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
6036              );
6037 
6038   HLSLSV_DispatchThreadIDAttr *clone(ASTContext &C) const;
6039   void printPretty(raw_ostream &OS,
6040                    const PrintingPolicy &Policy) const;
6041   const char *getSpelling() const;
6042 
6043 
6044   static bool classof(const Attr *A) { return A->getKind() == attr::HLSLSV_DispatchThreadID; }
6045 };
6046 
6047 class CLANG_ABI HLSLSV_GroupIDAttr : public HLSLAnnotationAttr {
6048 public:
6049   // Factory methods
6050   static HLSLSV_GroupIDAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
6051   static HLSLSV_GroupIDAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
6052   static HLSLSV_GroupIDAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {});
6053   static HLSLSV_GroupIDAttr *Create(ASTContext &Ctx, SourceRange Range = {});
6054 
6055   // Constructors
6056   HLSLSV_GroupIDAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
6057              );
6058 
6059   HLSLSV_GroupIDAttr *clone(ASTContext &C) const;
6060   void printPretty(raw_ostream &OS,
6061                    const PrintingPolicy &Policy) const;
6062   const char *getSpelling() const;
6063 
6064 
6065   static bool classof(const Attr *A) { return A->getKind() == attr::HLSLSV_GroupID; }
6066 };
6067 
6068 class CLANG_ABI HLSLSV_GroupIndexAttr : public HLSLAnnotationAttr {
6069 public:
6070   // Factory methods
6071   static HLSLSV_GroupIndexAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
6072   static HLSLSV_GroupIndexAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
6073   static HLSLSV_GroupIndexAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {});
6074   static HLSLSV_GroupIndexAttr *Create(ASTContext &Ctx, SourceRange Range = {});
6075 
6076   // Constructors
6077   HLSLSV_GroupIndexAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
6078              );
6079 
6080   HLSLSV_GroupIndexAttr *clone(ASTContext &C) const;
6081   void printPretty(raw_ostream &OS,
6082                    const PrintingPolicy &Policy) const;
6083   const char *getSpelling() const;
6084 
6085 
6086   static bool classof(const Attr *A) { return A->getKind() == attr::HLSLSV_GroupIndex; }
6087 };
6088 
6089 class CLANG_ABI HLSLSV_GroupThreadIDAttr : public HLSLAnnotationAttr {
6090 public:
6091   // Factory methods
6092   static HLSLSV_GroupThreadIDAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
6093   static HLSLSV_GroupThreadIDAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
6094   static HLSLSV_GroupThreadIDAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {});
6095   static HLSLSV_GroupThreadIDAttr *Create(ASTContext &Ctx, SourceRange Range = {});
6096 
6097   // Constructors
6098   HLSLSV_GroupThreadIDAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
6099              );
6100 
6101   HLSLSV_GroupThreadIDAttr *clone(ASTContext &C) const;
6102   void printPretty(raw_ostream &OS,
6103                    const PrintingPolicy &Policy) const;
6104   const char *getSpelling() const;
6105 
6106 
6107   static bool classof(const Attr *A) { return A->getKind() == attr::HLSLSV_GroupThreadID; }
6108 };
6109 
6110 class CLANG_ABI HLSLShaderAttr : public InheritableAttr {
6111 private:
6112   llvm::Triple::EnvironmentType type;
6113 
6114 public:
6115   // Factory methods
6116   static HLSLShaderAttr *CreateImplicit(ASTContext &Ctx, llvm::Triple::EnvironmentType Type, const AttributeCommonInfo &CommonInfo);
6117   static HLSLShaderAttr *Create(ASTContext &Ctx, llvm::Triple::EnvironmentType Type, const AttributeCommonInfo &CommonInfo);
6118   static HLSLShaderAttr *CreateImplicit(ASTContext &Ctx, llvm::Triple::EnvironmentType Type, SourceRange Range = {});
6119   static HLSLShaderAttr *Create(ASTContext &Ctx, llvm::Triple::EnvironmentType Type, SourceRange Range = {});
6120 
6121   // Constructors
6122   HLSLShaderAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
6123               , llvm::Triple::EnvironmentType Type
6124              );
6125 
6126   HLSLShaderAttr *clone(ASTContext &C) const;
6127   void printPretty(raw_ostream &OS,
6128                    const PrintingPolicy &Policy) const;
6129   const char *getSpelling() const;
6130   llvm::Triple::EnvironmentType getType() const {
6131     return type;
6132   }
6133 
6134   static bool ConvertStrToEnvironmentType(StringRef Val, llvm::Triple::EnvironmentType &Out);
6135   static const char *ConvertEnvironmentTypeToStr(llvm::Triple::EnvironmentType Val);
6136 
6137   static bool isValidShaderType(llvm::Triple::EnvironmentType ShaderType) {
6138     return ShaderType >= llvm::Triple::Pixel && ShaderType <= llvm::Triple::Amplification;
6139   }
6140 
6141 
6142   static bool classof(const Attr *A) { return A->getKind() == attr::HLSLShader; }
6143 };
6144 
6145 class CLANG_ABI HLSLWaveSizeAttr : public InheritableAttr {
6146 int min;
6147 
6148 int max;
6149 
6150 int preferred;
6151 
6152 public:
6153   // Factory methods
6154   static HLSLWaveSizeAttr *CreateImplicit(ASTContext &Ctx, int Min, int Max, int Preferred, const AttributeCommonInfo &CommonInfo);
6155   static HLSLWaveSizeAttr *Create(ASTContext &Ctx, int Min, int Max, int Preferred, const AttributeCommonInfo &CommonInfo);
6156   static HLSLWaveSizeAttr *CreateImplicit(ASTContext &Ctx, int Min, int Max, int Preferred, SourceRange Range = {});
6157   static HLSLWaveSizeAttr *Create(ASTContext &Ctx, int Min, int Max, int Preferred, SourceRange Range = {});
6158 
6159   // Constructors
6160   HLSLWaveSizeAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
6161               , int Min
6162               , int Max
6163               , int Preferred
6164              );
6165   HLSLWaveSizeAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
6166               , int Min
6167              );
6168 
6169   HLSLWaveSizeAttr *clone(ASTContext &C) const;
6170   void printPretty(raw_ostream &OS,
6171                    const PrintingPolicy &Policy) const;
6172   const char *getSpelling() const;
6173   int getMin() const {
6174     return min;
6175   }
6176 
6177   int getMax() const {
6178     return max;
6179   }
6180 
6181   static const int DefaultMax = 0;
6182 
6183   int getPreferred() const {
6184     return preferred;
6185   }
6186 
6187   static const int DefaultPreferred = 0;
6188 
6189 
6190     private:
6191       int SpelledArgsCount = 0;
6192 
6193     public:
6194       void setSpelledArgsCount(int C) { SpelledArgsCount = C; }
6195       int getSpelledArgsCount() const { return SpelledArgsCount; }
6196   
6197 
6198   static bool classof(const Attr *A) { return A->getKind() == attr::HLSLWaveSize; }
6199 };
6200 
6201 class CLANG_ABI HotAttr : public InheritableAttr {
6202 public:
6203   enum Spelling {
6204     GNU_hot = 0,
6205     CXX11_gnu_hot = 1,
6206     C23_gnu_hot = 2,
6207   SpellingNotCalculated = 15
6208 
6209   };
6210 
6211   // Factory methods
6212   static HotAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
6213   static HotAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
6214   static HotAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_hot);
6215   static HotAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_hot);
6216 
6217   // Constructors
6218   HotAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
6219              );
6220 
6221   HotAttr *clone(ASTContext &C) const;
6222   void printPretty(raw_ostream &OS,
6223                    const PrintingPolicy &Policy) const;
6224   const char *getSpelling() const;
6225 
6226 
6227   static bool classof(const Attr *A) { return A->getKind() == attr::Hot; }
6228 };
6229 
6230 class CLANG_ABI HybridPatchableAttr : public InheritableAttr {
6231 public:
6232   enum Spelling {
6233     Declspec_hybrid_patchable = 0,
6234     GNU_hybrid_patchable = 1,
6235     CXX11_clang_hybrid_patchable = 2,
6236     C23_clang_hybrid_patchable = 3,
6237   SpellingNotCalculated = 15
6238 
6239   };
6240 
6241   // Factory methods
6242   static HybridPatchableAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
6243   static HybridPatchableAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
6244   static HybridPatchableAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = Declspec_hybrid_patchable);
6245   static HybridPatchableAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = Declspec_hybrid_patchable);
6246 
6247   // Constructors
6248   HybridPatchableAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
6249              );
6250 
6251   HybridPatchableAttr *clone(ASTContext &C) const;
6252   void printPretty(raw_ostream &OS,
6253                    const PrintingPolicy &Policy) const;
6254   const char *getSpelling() const;
6255 
6256 
6257   static bool classof(const Attr *A) { return A->getKind() == attr::HybridPatchable; }
6258 };
6259 
6260 class CLANG_ABI IBActionAttr : public InheritableAttr {
6261 public:
6262   enum Spelling {
6263     GNU_ibaction = 0,
6264     CXX11_clang_ibaction = 1,
6265     C23_clang_ibaction = 2,
6266   SpellingNotCalculated = 15
6267 
6268   };
6269 
6270   // Factory methods
6271   static IBActionAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
6272   static IBActionAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
6273   static IBActionAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_ibaction);
6274   static IBActionAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_ibaction);
6275 
6276   // Constructors
6277   IBActionAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
6278              );
6279 
6280   IBActionAttr *clone(ASTContext &C) const;
6281   void printPretty(raw_ostream &OS,
6282                    const PrintingPolicy &Policy) const;
6283   const char *getSpelling() const;
6284 
6285 
6286   static bool classof(const Attr *A) { return A->getKind() == attr::IBAction; }
6287 };
6288 
6289 class CLANG_ABI IBOutletAttr : public InheritableAttr {
6290 public:
6291   enum Spelling {
6292     GNU_iboutlet = 0,
6293     CXX11_clang_iboutlet = 1,
6294     C23_clang_iboutlet = 2,
6295   SpellingNotCalculated = 15
6296 
6297   };
6298 
6299   // Factory methods
6300   static IBOutletAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
6301   static IBOutletAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
6302   static IBOutletAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_iboutlet);
6303   static IBOutletAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_iboutlet);
6304 
6305   // Constructors
6306   IBOutletAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
6307              );
6308 
6309   IBOutletAttr *clone(ASTContext &C) const;
6310   void printPretty(raw_ostream &OS,
6311                    const PrintingPolicy &Policy) const;
6312   const char *getSpelling() const;
6313 
6314 
6315   static bool classof(const Attr *A) { return A->getKind() == attr::IBOutlet; }
6316 };
6317 
6318 class CLANG_ABI IBOutletCollectionAttr : public InheritableAttr {
6319 TypeSourceInfo * interface_;
6320 
6321 public:
6322   enum Spelling {
6323     GNU_iboutletcollection = 0,
6324     CXX11_clang_iboutletcollection = 1,
6325     C23_clang_iboutletcollection = 2,
6326   SpellingNotCalculated = 15
6327 
6328   };
6329 
6330   // Factory methods
6331   static IBOutletCollectionAttr *CreateImplicit(ASTContext &Ctx, TypeSourceInfo * Interface, const AttributeCommonInfo &CommonInfo);
6332   static IBOutletCollectionAttr *Create(ASTContext &Ctx, TypeSourceInfo * Interface, const AttributeCommonInfo &CommonInfo);
6333   static IBOutletCollectionAttr *CreateImplicit(ASTContext &Ctx, TypeSourceInfo * Interface, SourceRange Range = {}, Spelling S = GNU_iboutletcollection);
6334   static IBOutletCollectionAttr *Create(ASTContext &Ctx, TypeSourceInfo * Interface, SourceRange Range = {}, Spelling S = GNU_iboutletcollection);
6335 
6336   // Constructors
6337   IBOutletCollectionAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
6338               , TypeSourceInfo * Interface
6339              );
6340   IBOutletCollectionAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
6341              );
6342 
6343   IBOutletCollectionAttr *clone(ASTContext &C) const;
6344   void printPretty(raw_ostream &OS,
6345                    const PrintingPolicy &Policy) const;
6346   const char *getSpelling() const;
6347   QualType getInterface() const {
6348     return interface_->getType();
6349   }  TypeSourceInfo * getInterfaceLoc() const {
6350     return interface_;
6351   }
6352 
6353 
6354 
6355   static bool classof(const Attr *A) { return A->getKind() == attr::IBOutletCollection; }
6356 };
6357 
6358 class CLANG_ABI IFuncAttr : public Attr {
6359 unsigned resolverLength;
6360 char *resolver;
6361 
6362 public:
6363   enum Spelling {
6364     GNU_ifunc = 0,
6365     CXX11_gnu_ifunc = 1,
6366     C23_gnu_ifunc = 2,
6367   SpellingNotCalculated = 15
6368 
6369   };
6370 
6371   // Factory methods
6372   static IFuncAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Resolver, const AttributeCommonInfo &CommonInfo);
6373   static IFuncAttr *Create(ASTContext &Ctx, llvm::StringRef Resolver, const AttributeCommonInfo &CommonInfo);
6374   static IFuncAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Resolver, SourceRange Range = {}, Spelling S = GNU_ifunc);
6375   static IFuncAttr *Create(ASTContext &Ctx, llvm::StringRef Resolver, SourceRange Range = {}, Spelling S = GNU_ifunc);
6376 
6377   // Constructors
6378   IFuncAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
6379               , llvm::StringRef Resolver
6380              );
6381 
6382   IFuncAttr *clone(ASTContext &C) const;
6383   void printPretty(raw_ostream &OS,
6384                    const PrintingPolicy &Policy) const;
6385   const char *getSpelling() const;
6386   llvm::StringRef getResolver() const {
6387     return llvm::StringRef(resolver, resolverLength);
6388   }
6389   unsigned getResolverLength() const {
6390     return resolverLength;
6391   }
6392   void setResolver(ASTContext &C, llvm::StringRef S) {
6393     resolverLength = S.size();
6394     this->resolver = new (C, 1) char [resolverLength];
6395     if (!S.empty())
6396       std::memcpy(this->resolver, S.data(), resolverLength);
6397   }
6398 
6399 
6400 
6401   static bool classof(const Attr *A) { return A->getKind() == attr::IFunc; }
6402 };
6403 
6404 class CLANG_ABI InitPriorityAttr : public InheritableAttr {
6405 unsigned priority;
6406 
6407 public:
6408   enum Spelling {
6409     GNU_init_priority = 0,
6410     CXX11_gnu_init_priority = 1,
6411   SpellingNotCalculated = 15
6412 
6413   };
6414 
6415   // Factory methods
6416   static InitPriorityAttr *CreateImplicit(ASTContext &Ctx, unsigned Priority, const AttributeCommonInfo &CommonInfo);
6417   static InitPriorityAttr *Create(ASTContext &Ctx, unsigned Priority, const AttributeCommonInfo &CommonInfo);
6418   static InitPriorityAttr *CreateImplicit(ASTContext &Ctx, unsigned Priority, SourceRange Range = {}, Spelling S = GNU_init_priority);
6419   static InitPriorityAttr *Create(ASTContext &Ctx, unsigned Priority, SourceRange Range = {}, Spelling S = GNU_init_priority);
6420 
6421   // Constructors
6422   InitPriorityAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
6423               , unsigned Priority
6424              );
6425 
6426   InitPriorityAttr *clone(ASTContext &C) const;
6427   void printPretty(raw_ostream &OS,
6428                    const PrintingPolicy &Policy) const;
6429   const char *getSpelling() const;
6430   unsigned getPriority() const {
6431     return priority;
6432   }
6433 
6434 
6435 
6436   static bool classof(const Attr *A) { return A->getKind() == attr::InitPriority; }
6437 };
6438 
6439 class CLANG_ABI InitSegAttr : public Attr {
6440 unsigned sectionLength;
6441 char *section;
6442 
6443 public:
6444   // Factory methods
6445   static InitSegAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Section, const AttributeCommonInfo &CommonInfo);
6446   static InitSegAttr *Create(ASTContext &Ctx, llvm::StringRef Section, const AttributeCommonInfo &CommonInfo);
6447   static InitSegAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Section, SourceRange Range = {});
6448   static InitSegAttr *Create(ASTContext &Ctx, llvm::StringRef Section, SourceRange Range = {});
6449 
6450   // Constructors
6451   InitSegAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
6452               , llvm::StringRef Section
6453              );
6454 
6455   InitSegAttr *clone(ASTContext &C) const;
6456   void printPretty(raw_ostream &OS,
6457                    const PrintingPolicy &Policy) const;
6458   const char *getSpelling() const;
6459   llvm::StringRef getSection() const {
6460     return llvm::StringRef(section, sectionLength);
6461   }
6462   unsigned getSectionLength() const {
6463     return sectionLength;
6464   }
6465   void setSection(ASTContext &C, llvm::StringRef S) {
6466     sectionLength = S.size();
6467     this->section = new (C, 1) char [sectionLength];
6468     if (!S.empty())
6469       std::memcpy(this->section, S.data(), sectionLength);
6470   }
6471 
6472 
6473   void printPrettyPragma(raw_ostream &OS, const PrintingPolicy &Policy) const {
6474     OS << " (" << getSection() << ')';
6475   }
6476   
6477 
6478   static bool classof(const Attr *A) { return A->getKind() == attr::InitSeg; }
6479 };
6480 
6481 class CLANG_ABI IntelOclBiccAttr : public InheritableAttr {
6482 public:
6483   enum Spelling {
6484     GNU_intel_ocl_bicc = 0,
6485     CXX11_clang_intel_ocl_bicc = 1,
6486   SpellingNotCalculated = 15
6487 
6488   };
6489 
6490   // Factory methods
6491   static IntelOclBiccAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
6492   static IntelOclBiccAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
6493   static IntelOclBiccAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_intel_ocl_bicc);
6494   static IntelOclBiccAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_intel_ocl_bicc);
6495 
6496   // Constructors
6497   IntelOclBiccAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
6498              );
6499 
6500   IntelOclBiccAttr *clone(ASTContext &C) const;
6501   void printPretty(raw_ostream &OS,
6502                    const PrintingPolicy &Policy) const;
6503   const char *getSpelling() const;
6504 
6505 
6506   static bool classof(const Attr *A) { return A->getKind() == attr::IntelOclBicc; }
6507 };
6508 
6509 class CLANG_ABI InternalLinkageAttr : public InheritableAttr {
6510 public:
6511   enum Spelling {
6512     GNU_internal_linkage = 0,
6513     CXX11_clang_internal_linkage = 1,
6514     C23_clang_internal_linkage = 2,
6515   SpellingNotCalculated = 15
6516 
6517   };
6518 
6519   // Factory methods
6520   static InternalLinkageAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
6521   static InternalLinkageAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
6522   static InternalLinkageAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_internal_linkage);
6523   static InternalLinkageAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_internal_linkage);
6524 
6525   // Constructors
6526   InternalLinkageAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
6527              );
6528 
6529   InternalLinkageAttr *clone(ASTContext &C) const;
6530   void printPretty(raw_ostream &OS,
6531                    const PrintingPolicy &Policy) const;
6532   const char *getSpelling() const;
6533 
6534 
6535   static bool classof(const Attr *A) { return A->getKind() == attr::InternalLinkage; }
6536 };
6537 
6538 class CLANG_ABI LTOVisibilityPublicAttr : public InheritableAttr {
6539 public:
6540   enum Spelling {
6541     GNU_lto_visibility_public = 0,
6542     CXX11_clang_lto_visibility_public = 1,
6543     C23_clang_lto_visibility_public = 2,
6544   SpellingNotCalculated = 15
6545 
6546   };
6547 
6548   // Factory methods
6549   static LTOVisibilityPublicAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
6550   static LTOVisibilityPublicAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
6551   static LTOVisibilityPublicAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_lto_visibility_public);
6552   static LTOVisibilityPublicAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_lto_visibility_public);
6553 
6554   // Constructors
6555   LTOVisibilityPublicAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
6556              );
6557 
6558   LTOVisibilityPublicAttr *clone(ASTContext &C) const;
6559   void printPretty(raw_ostream &OS,
6560                    const PrintingPolicy &Policy) const;
6561   const char *getSpelling() const;
6562 
6563 
6564   static bool classof(const Attr *A) { return A->getKind() == attr::LTOVisibilityPublic; }
6565 };
6566 
6567 class CLANG_ABI LayoutVersionAttr : public InheritableAttr {
6568 unsigned version;
6569 
6570 public:
6571   // Factory methods
6572   static LayoutVersionAttr *CreateImplicit(ASTContext &Ctx, unsigned Version, const AttributeCommonInfo &CommonInfo);
6573   static LayoutVersionAttr *Create(ASTContext &Ctx, unsigned Version, const AttributeCommonInfo &CommonInfo);
6574   static LayoutVersionAttr *CreateImplicit(ASTContext &Ctx, unsigned Version, SourceRange Range = {});
6575   static LayoutVersionAttr *Create(ASTContext &Ctx, unsigned Version, SourceRange Range = {});
6576 
6577   // Constructors
6578   LayoutVersionAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
6579               , unsigned Version
6580              );
6581 
6582   LayoutVersionAttr *clone(ASTContext &C) const;
6583   void printPretty(raw_ostream &OS,
6584                    const PrintingPolicy &Policy) const;
6585   const char *getSpelling() const;
6586   unsigned getVersion() const {
6587     return version;
6588   }
6589 
6590 
6591 
6592   static bool classof(const Attr *A) { return A->getKind() == attr::LayoutVersion; }
6593 };
6594 
6595 class CLANG_ABI LeafAttr : public InheritableAttr {
6596 public:
6597   enum Spelling {
6598     GNU_leaf = 0,
6599     CXX11_gnu_leaf = 1,
6600     C23_gnu_leaf = 2,
6601   SpellingNotCalculated = 15
6602 
6603   };
6604 
6605   // Factory methods
6606   static LeafAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
6607   static LeafAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
6608   static LeafAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_leaf);
6609   static LeafAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_leaf);
6610 
6611   // Constructors
6612   LeafAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
6613              );
6614 
6615   LeafAttr *clone(ASTContext &C) const;
6616   void printPretty(raw_ostream &OS,
6617                    const PrintingPolicy &Policy) const;
6618   const char *getSpelling() const;
6619 
6620 
6621   static bool classof(const Attr *A) { return A->getKind() == attr::Leaf; }
6622 };
6623 
6624 class CLANG_ABI LifetimeBoundAttr : public InheritableAttr {
6625 public:
6626   enum Spelling {
6627     GNU_lifetimebound = 0,
6628     CXX11_clang_lifetimebound = 1,
6629   SpellingNotCalculated = 15
6630 
6631   };
6632 
6633   // Factory methods
6634   static LifetimeBoundAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
6635   static LifetimeBoundAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
6636   static LifetimeBoundAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_lifetimebound);
6637   static LifetimeBoundAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_lifetimebound);
6638 
6639   // Constructors
6640   LifetimeBoundAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
6641              );
6642 
6643   LifetimeBoundAttr *clone(ASTContext &C) const;
6644   void printPretty(raw_ostream &OS,
6645                    const PrintingPolicy &Policy) const;
6646   const char *getSpelling() const;
6647 
6648 
6649   static bool classof(const Attr *A) { return A->getKind() == attr::LifetimeBound; }
6650 };
6651 
6652 class CLANG_ABI LifetimeCaptureByAttr : public InheritableAttr {
6653   unsigned params_Size;
6654   int *params_;
6655 
6656 public:
6657   enum Spelling {
6658     GNU_lifetime_capture_by = 0,
6659     CXX11_clang_lifetime_capture_by = 1,
6660   SpellingNotCalculated = 15
6661 
6662   };
6663 
6664   // Factory methods
6665   static LifetimeCaptureByAttr *CreateImplicit(ASTContext &Ctx, int *Params, unsigned ParamsSize, const AttributeCommonInfo &CommonInfo);
6666   static LifetimeCaptureByAttr *Create(ASTContext &Ctx, int *Params, unsigned ParamsSize, const AttributeCommonInfo &CommonInfo);
6667   static LifetimeCaptureByAttr *CreateImplicit(ASTContext &Ctx, int *Params, unsigned ParamsSize, SourceRange Range = {}, Spelling S = GNU_lifetime_capture_by);
6668   static LifetimeCaptureByAttr *Create(ASTContext &Ctx, int *Params, unsigned ParamsSize, SourceRange Range = {}, Spelling S = GNU_lifetime_capture_by);
6669 
6670   // Constructors
6671   LifetimeCaptureByAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
6672               , int *Params, unsigned ParamsSize
6673              );
6674   LifetimeCaptureByAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
6675              );
6676 
6677   LifetimeCaptureByAttr *clone(ASTContext &C) const;
6678   void printPretty(raw_ostream &OS,
6679                    const PrintingPolicy &Policy) const;
6680   const char *getSpelling() const;
6681   typedef int* params_iterator;
6682   params_iterator params_begin() const { return params_; }
6683   params_iterator params_end() const { return params_ + params_Size; }
6684   unsigned params_size() const { return params_Size; }
6685   llvm::iterator_range<params_iterator> params() const { return llvm::make_range(params_begin(), params_end()); }
6686 
6687 
6688 
6689 private:
6690   ArrayRef<IdentifierInfo*> ArgIdents;
6691   ArrayRef<SourceLocation> ArgLocs;
6692 
6693 public:
6694   static constexpr int THIS = 0;
6695   static constexpr int INVALID = -1;
6696   static constexpr int UNKNOWN = -2;
6697   static constexpr int GLOBAL = -3;
6698 
6699   void setArgs(ArrayRef<IdentifierInfo*> Idents, ArrayRef<SourceLocation> Locs) {
6700     assert(Idents.size() == params_Size);
6701     assert(Locs.size() == params_Size);
6702     ArgIdents = Idents;
6703     ArgLocs = Locs;
6704   }
6705   auto getArgIdents() const { return ArgIdents; }
6706   auto getArgLocs() const { return ArgLocs; }
6707   void setParamIdx(size_t Idx, int Val) {
6708     assert(Idx < params_Size);
6709     params_[Idx] = Val;
6710   }
6711 
6712 
6713   static bool classof(const Attr *A) { return A->getKind() == attr::LifetimeCaptureBy; }
6714 };
6715 
6716 class CLANG_ABI LikelyAttr : public StmtAttr {
6717 public:
6718   enum Spelling {
6719     CXX11_likely = 0,
6720     C23_clang_likely = 1,
6721   SpellingNotCalculated = 15
6722 
6723   };
6724 
6725   // Factory methods
6726   static LikelyAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
6727   static LikelyAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
6728   static LikelyAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = CXX11_likely);
6729   static LikelyAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = CXX11_likely);
6730 
6731   // Constructors
6732   LikelyAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
6733              );
6734 
6735   LikelyAttr *clone(ASTContext &C) const;
6736   void printPretty(raw_ostream &OS,
6737                    const PrintingPolicy &Policy) const;
6738   const char *getSpelling() const;
6739 
6740 
6741   static bool classof(const Attr *A) { return A->getKind() == attr::Likely; }
6742 };
6743 
6744 class CLANG_ABI LoaderUninitializedAttr : public Attr {
6745 public:
6746   enum Spelling {
6747     GNU_loader_uninitialized = 0,
6748     CXX11_clang_loader_uninitialized = 1,
6749     C23_clang_loader_uninitialized = 2,
6750   SpellingNotCalculated = 15
6751 
6752   };
6753 
6754   // Factory methods
6755   static LoaderUninitializedAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
6756   static LoaderUninitializedAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
6757   static LoaderUninitializedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_loader_uninitialized);
6758   static LoaderUninitializedAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_loader_uninitialized);
6759 
6760   // Constructors
6761   LoaderUninitializedAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
6762              );
6763 
6764   LoaderUninitializedAttr *clone(ASTContext &C) const;
6765   void printPretty(raw_ostream &OS,
6766                    const PrintingPolicy &Policy) const;
6767   const char *getSpelling() const;
6768 
6769 
6770   static bool classof(const Attr *A) { return A->getKind() == attr::LoaderUninitialized; }
6771 };
6772 
6773 class CLANG_ABI LockReturnedAttr : public InheritableAttr {
6774 Expr * arg;
6775 
6776 public:
6777   // Factory methods
6778   static LockReturnedAttr *CreateImplicit(ASTContext &Ctx, Expr * Arg, const AttributeCommonInfo &CommonInfo);
6779   static LockReturnedAttr *Create(ASTContext &Ctx, Expr * Arg, const AttributeCommonInfo &CommonInfo);
6780   static LockReturnedAttr *CreateImplicit(ASTContext &Ctx, Expr * Arg, SourceRange Range = {});
6781   static LockReturnedAttr *Create(ASTContext &Ctx, Expr * Arg, SourceRange Range = {});
6782 
6783   // Constructors
6784   LockReturnedAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
6785               , Expr * Arg
6786              );
6787 
6788   LockReturnedAttr *clone(ASTContext &C) const;
6789   void printPretty(raw_ostream &OS,
6790                    const PrintingPolicy &Policy) const;
6791   const char *getSpelling() const;
6792   Expr * getArg() const {
6793     return arg;
6794   }
6795 
6796 
6797 
6798   static bool classof(const Attr *A) { return A->getKind() == attr::LockReturned; }
6799 };
6800 
6801 class CLANG_ABI LocksExcludedAttr : public InheritableAttr {
6802   unsigned args_Size;
6803   Expr * *args_;
6804 
6805 public:
6806   // Factory methods
6807   static LocksExcludedAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo);
6808   static LocksExcludedAttr *Create(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo);
6809   static LocksExcludedAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Range = {});
6810   static LocksExcludedAttr *Create(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Range = {});
6811 
6812   // Constructors
6813   LocksExcludedAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
6814               , Expr * *Args, unsigned ArgsSize
6815              );
6816   LocksExcludedAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
6817              );
6818 
6819   LocksExcludedAttr *clone(ASTContext &C) const;
6820   void printPretty(raw_ostream &OS,
6821                    const PrintingPolicy &Policy) const;
6822   const char *getSpelling() const;
6823   typedef Expr ** args_iterator;
6824   args_iterator args_begin() const { return args_; }
6825   args_iterator args_end() const { return args_ + args_Size; }
6826   unsigned args_size() const { return args_Size; }
6827   llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }
6828 
6829 
6830 
6831 
6832   static bool classof(const Attr *A) { return A->getKind() == attr::LocksExcluded; }
6833 };
6834 
6835 class CLANG_ABI LoopHintAttr : public Attr {
6836 public:
6837   enum OptionType {
6838     Vectorize,
6839     VectorizeWidth,
6840     Interleave,
6841     InterleaveCount,
6842     Unroll,
6843     UnrollCount,
6844     UnrollAndJam,
6845     UnrollAndJamCount,
6846     PipelineDisabled,
6847     PipelineInitiationInterval,
6848     Distribute,
6849     VectorizePredicate
6850   };
6851 private:
6852   LoopHintAttr::OptionType option;
6853 
6854 public:
6855   enum LoopHintState {
6856     Enable,
6857     Disable,
6858     Numeric,
6859     FixedWidth,
6860     ScalableWidth,
6861     AssumeSafety,
6862     Full
6863   };
6864 private:
6865   LoopHintAttr::LoopHintState state;
6866 
6867 Expr * value;
6868 
6869 public:
6870   enum Spelling {
6871     Pragma_clang_loop = 0,
6872     Pragma_unroll = 1,
6873     Pragma_nounroll = 2,
6874     Pragma_unroll_and_jam = 3,
6875     Pragma_nounroll_and_jam = 4,
6876   SpellingNotCalculated = 15
6877 
6878   };
6879 
6880   // Factory methods
6881   static LoopHintAttr *CreateImplicit(ASTContext &Ctx, LoopHintAttr::OptionType Option, LoopHintAttr::LoopHintState State, Expr * Value, const AttributeCommonInfo &CommonInfo);
6882   static LoopHintAttr *Create(ASTContext &Ctx, LoopHintAttr::OptionType Option, LoopHintAttr::LoopHintState State, Expr * Value, const AttributeCommonInfo &CommonInfo);
6883   static LoopHintAttr *CreateImplicit(ASTContext &Ctx, LoopHintAttr::OptionType Option, LoopHintAttr::LoopHintState State, Expr * Value, SourceRange Range = {}, Spelling S = Pragma_clang_loop);
6884   static LoopHintAttr *Create(ASTContext &Ctx, LoopHintAttr::OptionType Option, LoopHintAttr::LoopHintState State, Expr * Value, SourceRange Range = {}, Spelling S = Pragma_clang_loop);
6885 
6886   // Constructors
6887   LoopHintAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
6888               , LoopHintAttr::OptionType Option
6889               , LoopHintAttr::LoopHintState State
6890               , Expr * Value
6891              );
6892 
6893   LoopHintAttr *clone(ASTContext &C) const;
6894   void printPretty(raw_ostream &OS,
6895                    const PrintingPolicy &Policy) const;
6896   const char *getSpelling() const;
6897   Spelling getSemanticSpelling() const;
6898   LoopHintAttr::OptionType getOption() const {
6899     return option;
6900   }
6901 
6902   static bool ConvertStrToOptionType(StringRef Val, LoopHintAttr::OptionType &Out);
6903   static const char *ConvertOptionTypeToStr(LoopHintAttr::OptionType Val);
6904   LoopHintAttr::LoopHintState getState() const {
6905     return state;
6906   }
6907 
6908   static bool ConvertStrToLoopHintState(StringRef Val, LoopHintAttr::LoopHintState &Out);
6909   static const char *ConvertLoopHintStateToStr(LoopHintAttr::LoopHintState Val);
6910   Expr * getValue() const {
6911     return value;
6912   }
6913 
6914 
6915   static const char *getOptionName(int Option) {
6916     switch(Option) {
6917     case Vectorize: return "vectorize";
6918     case VectorizeWidth: return "vectorize_width";
6919     case Interleave: return "interleave";
6920     case InterleaveCount: return "interleave_count";
6921     case Unroll: return "unroll";
6922     case UnrollCount: return "unroll_count";
6923     case UnrollAndJam: return "unroll_and_jam";
6924     case UnrollAndJamCount: return "unroll_and_jam_count";
6925     case PipelineDisabled: return "pipeline";
6926     case PipelineInitiationInterval: return "pipeline_initiation_interval";
6927     case Distribute: return "distribute";
6928     case VectorizePredicate: return "vectorize_predicate";
6929     }
6930     llvm_unreachable("Unhandled LoopHint option.");
6931   }
6932 
6933   void printPrettyPragma(raw_ostream &OS, const PrintingPolicy &Policy) const;
6934 
6935   // Return a string containing the loop hint argument including the
6936   // enclosing parentheses.
6937   std::string getValueString(const PrintingPolicy &Policy) const;
6938 
6939   // Return a string suitable for identifying this attribute in diagnostics.
6940   std::string getDiagnosticName(const PrintingPolicy &Policy) const;
6941   
6942 
6943   static bool classof(const Attr *A) { return A->getKind() == attr::LoopHint; }
6944 };
6945 
6946 class CLANG_ABI M68kInterruptAttr : public InheritableAttr {
6947 unsigned number;
6948 
6949 public:
6950   // Factory methods
6951   static M68kInterruptAttr *CreateImplicit(ASTContext &Ctx, unsigned Number, const AttributeCommonInfo &CommonInfo);
6952   static M68kInterruptAttr *Create(ASTContext &Ctx, unsigned Number, const AttributeCommonInfo &CommonInfo);
6953   static M68kInterruptAttr *CreateImplicit(ASTContext &Ctx, unsigned Number, SourceRange Range = {});
6954   static M68kInterruptAttr *Create(ASTContext &Ctx, unsigned Number, SourceRange Range = {});
6955 
6956   // Constructors
6957   M68kInterruptAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
6958               , unsigned Number
6959              );
6960 
6961   M68kInterruptAttr *clone(ASTContext &C) const;
6962   void printPretty(raw_ostream &OS,
6963                    const PrintingPolicy &Policy) const;
6964   const char *getSpelling() const;
6965   unsigned getNumber() const {
6966     return number;
6967   }
6968 
6969 
6970 
6971   static bool classof(const Attr *A) { return A->getKind() == attr::M68kInterrupt; }
6972 };
6973 
6974 class CLANG_ABI M68kRTDAttr : public InheritableAttr {
6975 public:
6976   enum Spelling {
6977     GNU_m68k_rtd = 0,
6978     CXX11_clang_m68k_rtd = 1,
6979     C23_clang_m68k_rtd = 2,
6980   SpellingNotCalculated = 15
6981 
6982   };
6983 
6984   // Factory methods
6985   static M68kRTDAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
6986   static M68kRTDAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
6987   static M68kRTDAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_m68k_rtd);
6988   static M68kRTDAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_m68k_rtd);
6989 
6990   // Constructors
6991   M68kRTDAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
6992              );
6993 
6994   M68kRTDAttr *clone(ASTContext &C) const;
6995   void printPretty(raw_ostream &OS,
6996                    const PrintingPolicy &Policy) const;
6997   const char *getSpelling() const;
6998 
6999 
7000   static bool classof(const Attr *A) { return A->getKind() == attr::M68kRTD; }
7001 };
7002 
7003 class CLANG_ABI MIGServerRoutineAttr : public InheritableAttr {
7004 public:
7005   enum Spelling {
7006     GNU_mig_server_routine = 0,
7007     CXX11_clang_mig_server_routine = 1,
7008     C23_clang_mig_server_routine = 2,
7009   SpellingNotCalculated = 15
7010 
7011   };
7012 
7013   // Factory methods
7014   static MIGServerRoutineAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
7015   static MIGServerRoutineAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
7016   static MIGServerRoutineAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_mig_server_routine);
7017   static MIGServerRoutineAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_mig_server_routine);
7018 
7019   // Constructors
7020   MIGServerRoutineAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
7021              );
7022 
7023   MIGServerRoutineAttr *clone(ASTContext &C) const;
7024   void printPretty(raw_ostream &OS,
7025                    const PrintingPolicy &Policy) const;
7026   const char *getSpelling() const;
7027 
7028 
7029   static bool classof(const Attr *A) { return A->getKind() == attr::MIGServerRoutine; }
7030 };
7031 
7032 class CLANG_ABI MSABIAttr : public InheritableAttr {
7033 public:
7034   enum Spelling {
7035     GNU_ms_abi = 0,
7036     CXX11_gnu_ms_abi = 1,
7037     C23_gnu_ms_abi = 2,
7038   SpellingNotCalculated = 15
7039 
7040   };
7041 
7042   // Factory methods
7043   static MSABIAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
7044   static MSABIAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
7045   static MSABIAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_ms_abi);
7046   static MSABIAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_ms_abi);
7047 
7048   // Constructors
7049   MSABIAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
7050              );
7051 
7052   MSABIAttr *clone(ASTContext &C) const;
7053   void printPretty(raw_ostream &OS,
7054                    const PrintingPolicy &Policy) const;
7055   const char *getSpelling() const;
7056 
7057 
7058   static bool classof(const Attr *A) { return A->getKind() == attr::MSABI; }
7059 };
7060 
7061 class CLANG_ABI MSAllocatorAttr : public InheritableAttr {
7062 public:
7063   // Factory methods
7064   static MSAllocatorAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
7065   static MSAllocatorAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
7066   static MSAllocatorAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {});
7067   static MSAllocatorAttr *Create(ASTContext &Ctx, SourceRange Range = {});
7068 
7069   // Constructors
7070   MSAllocatorAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
7071              );
7072 
7073   MSAllocatorAttr *clone(ASTContext &C) const;
7074   void printPretty(raw_ostream &OS,
7075                    const PrintingPolicy &Policy) const;
7076   const char *getSpelling() const;
7077 
7078 
7079   static bool classof(const Attr *A) { return A->getKind() == attr::MSAllocator; }
7080 };
7081 
7082 class CLANG_ABI MSConstexprAttr : public InheritableAttr {
7083 public:
7084   // Factory methods
7085   static MSConstexprAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
7086   static MSConstexprAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
7087   static MSConstexprAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {});
7088   static MSConstexprAttr *Create(ASTContext &Ctx, SourceRange Range = {});
7089 
7090   // Constructors
7091   MSConstexprAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
7092              );
7093 
7094   MSConstexprAttr *clone(ASTContext &C) const;
7095   void printPretty(raw_ostream &OS,
7096                    const PrintingPolicy &Policy) const;
7097   const char *getSpelling() const;
7098 
7099 
7100   static bool classof(const Attr *A) { return A->getKind() == attr::MSConstexpr; }
7101 };
7102 
7103 class CLANG_ABI MSInheritanceAttr : public InheritableAttr {
7104 bool bestCase;
7105 
7106 public:
7107   enum Spelling {
7108     Keyword_single_inheritance = 0,
7109     Keyword_multiple_inheritance = 1,
7110     Keyword_virtual_inheritance = 2,
7111     Keyword_unspecified_inheritance = 3,
7112   SpellingNotCalculated = 15
7113 
7114   };
7115 
7116   // Factory methods
7117   static MSInheritanceAttr *CreateImplicit(ASTContext &Ctx, bool BestCase, const AttributeCommonInfo &CommonInfo);
7118   static MSInheritanceAttr *Create(ASTContext &Ctx, bool BestCase, const AttributeCommonInfo &CommonInfo);
7119   static MSInheritanceAttr *CreateImplicit(ASTContext &Ctx, bool BestCase, SourceRange Range = {}, Spelling S = Keyword_single_inheritance);
7120   static MSInheritanceAttr *Create(ASTContext &Ctx, bool BestCase, SourceRange Range = {}, Spelling S = Keyword_single_inheritance);
7121   static MSInheritanceAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
7122   static MSInheritanceAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
7123   static MSInheritanceAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = Keyword_single_inheritance);
7124   static MSInheritanceAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = Keyword_single_inheritance);
7125 
7126   // Constructors
7127   MSInheritanceAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
7128               , bool BestCase
7129              );
7130   MSInheritanceAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
7131              );
7132 
7133   MSInheritanceAttr *clone(ASTContext &C) const;
7134   void printPretty(raw_ostream &OS,
7135                    const PrintingPolicy &Policy) const;
7136   const char *getSpelling() const;
7137   Spelling getSemanticSpelling() const;
7138   bool getBestCase() const {
7139     return bestCase;
7140   }
7141 
7142   static const bool DefaultBestCase = true;
7143 
7144 
7145   MSInheritanceModel getInheritanceModel() const {
7146     // The spelling enum should agree with MSInheritanceModel.
7147     return MSInheritanceModel(getSemanticSpelling());
7148   }
7149   
7150 
7151   static bool classof(const Attr *A) { return A->getKind() == attr::MSInheritance; }
7152 };
7153 
7154 class CLANG_ABI MSNoVTableAttr : public InheritableAttr {
7155 public:
7156   // Factory methods
7157   static MSNoVTableAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
7158   static MSNoVTableAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
7159   static MSNoVTableAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {});
7160   static MSNoVTableAttr *Create(ASTContext &Ctx, SourceRange Range = {});
7161 
7162   // Constructors
7163   MSNoVTableAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
7164              );
7165 
7166   MSNoVTableAttr *clone(ASTContext &C) const;
7167   void printPretty(raw_ostream &OS,
7168                    const PrintingPolicy &Policy) const;
7169   const char *getSpelling() const;
7170 
7171 
7172   static bool classof(const Attr *A) { return A->getKind() == attr::MSNoVTable; }
7173 };
7174 
7175 class CLANG_ABI MSP430InterruptAttr : public InheritableAttr {
7176 unsigned number;
7177 
7178 public:
7179   enum Spelling {
7180     GNU_interrupt = 0,
7181     CXX11_gnu_interrupt = 1,
7182     C23_gnu_interrupt = 2,
7183   SpellingNotCalculated = 15
7184 
7185   };
7186 
7187   // Factory methods
7188   static MSP430InterruptAttr *CreateImplicit(ASTContext &Ctx, unsigned Number, const AttributeCommonInfo &CommonInfo);
7189   static MSP430InterruptAttr *Create(ASTContext &Ctx, unsigned Number, const AttributeCommonInfo &CommonInfo);
7190   static MSP430InterruptAttr *CreateImplicit(ASTContext &Ctx, unsigned Number, SourceRange Range = {}, Spelling S = GNU_interrupt);
7191   static MSP430InterruptAttr *Create(ASTContext &Ctx, unsigned Number, SourceRange Range = {}, Spelling S = GNU_interrupt);
7192 
7193   // Constructors
7194   MSP430InterruptAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
7195               , unsigned Number
7196              );
7197 
7198   MSP430InterruptAttr *clone(ASTContext &C) const;
7199   void printPretty(raw_ostream &OS,
7200                    const PrintingPolicy &Policy) const;
7201   const char *getSpelling() const;
7202   unsigned getNumber() const {
7203     return number;
7204   }
7205 
7206 
7207 
7208   static bool classof(const Attr *A) { return A->getKind() == attr::MSP430Interrupt; }
7209 };
7210 
7211 class CLANG_ABI MSStructAttr : public InheritableAttr {
7212 public:
7213   enum Spelling {
7214     GNU_ms_struct = 0,
7215     CXX11_gnu_ms_struct = 1,
7216     C23_gnu_ms_struct = 2,
7217   SpellingNotCalculated = 15
7218 
7219   };
7220 
7221   // Factory methods
7222   static MSStructAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
7223   static MSStructAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
7224   static MSStructAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_ms_struct);
7225   static MSStructAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_ms_struct);
7226 
7227   // Constructors
7228   MSStructAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
7229              );
7230 
7231   MSStructAttr *clone(ASTContext &C) const;
7232   void printPretty(raw_ostream &OS,
7233                    const PrintingPolicy &Policy) const;
7234   const char *getSpelling() const;
7235 
7236 
7237   static bool classof(const Attr *A) { return A->getKind() == attr::MSStruct; }
7238 };
7239 
7240 class CLANG_ABI MSVtorDispAttr : public InheritableAttr {
7241 unsigned vdm;
7242 
7243 public:
7244   // Factory methods
7245   static MSVtorDispAttr *CreateImplicit(ASTContext &Ctx, unsigned Vdm, const AttributeCommonInfo &CommonInfo);
7246   static MSVtorDispAttr *Create(ASTContext &Ctx, unsigned Vdm, const AttributeCommonInfo &CommonInfo);
7247   static MSVtorDispAttr *CreateImplicit(ASTContext &Ctx, unsigned Vdm, SourceRange Range = {});
7248   static MSVtorDispAttr *Create(ASTContext &Ctx, unsigned Vdm, SourceRange Range = {});
7249 
7250   // Constructors
7251   MSVtorDispAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
7252               , unsigned Vdm
7253              );
7254 
7255   MSVtorDispAttr *clone(ASTContext &C) const;
7256   void printPretty(raw_ostream &OS,
7257                    const PrintingPolicy &Policy) const;
7258   const char *getSpelling() const;
7259   unsigned getVdm() const {
7260     return vdm;
7261   }
7262 
7263 
7264   MSVtorDispMode getVtorDispMode() const { return MSVtorDispMode(vdm); }
7265   
7266 
7267   static bool classof(const Attr *A) { return A->getKind() == attr::MSVtorDisp; }
7268 };
7269 
7270 class CLANG_ABI MaxFieldAlignmentAttr : public InheritableAttr {
7271 unsigned alignment;
7272 
7273 public:
7274   // Factory methods
7275   static MaxFieldAlignmentAttr *CreateImplicit(ASTContext &Ctx, unsigned Alignment, const AttributeCommonInfo &CommonInfo);
7276   static MaxFieldAlignmentAttr *Create(ASTContext &Ctx, unsigned Alignment, const AttributeCommonInfo &CommonInfo);
7277   static MaxFieldAlignmentAttr *CreateImplicit(ASTContext &Ctx, unsigned Alignment, SourceRange Range = {});
7278   static MaxFieldAlignmentAttr *Create(ASTContext &Ctx, unsigned Alignment, SourceRange Range = {});
7279 
7280   // Constructors
7281   MaxFieldAlignmentAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
7282               , unsigned Alignment
7283              );
7284 
7285   MaxFieldAlignmentAttr *clone(ASTContext &C) const;
7286   void printPretty(raw_ostream &OS,
7287                    const PrintingPolicy &Policy) const;
7288   const char *getSpelling() const;
7289   unsigned getAlignment() const {
7290     return alignment;
7291   }
7292 
7293 
7294 
7295   static bool classof(const Attr *A) { return A->getKind() == attr::MaxFieldAlignment; }
7296 };
7297 
7298 class CLANG_ABI MayAliasAttr : public InheritableAttr {
7299 public:
7300   enum Spelling {
7301     GNU_may_alias = 0,
7302     CXX11_gnu_may_alias = 1,
7303     C23_gnu_may_alias = 2,
7304   SpellingNotCalculated = 15
7305 
7306   };
7307 
7308   // Factory methods
7309   static MayAliasAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
7310   static MayAliasAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
7311   static MayAliasAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_may_alias);
7312   static MayAliasAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_may_alias);
7313 
7314   // Constructors
7315   MayAliasAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
7316              );
7317 
7318   MayAliasAttr *clone(ASTContext &C) const;
7319   void printPretty(raw_ostream &OS,
7320                    const PrintingPolicy &Policy) const;
7321   const char *getSpelling() const;
7322 
7323 
7324   static bool classof(const Attr *A) { return A->getKind() == attr::MayAlias; }
7325 };
7326 
7327 class CLANG_ABI MaybeUndefAttr : public InheritableAttr {
7328 public:
7329   enum Spelling {
7330     GNU_maybe_undef = 0,
7331     CXX11_clang_maybe_undef = 1,
7332     C23_clang_maybe_undef = 2,
7333   SpellingNotCalculated = 15
7334 
7335   };
7336 
7337   // Factory methods
7338   static MaybeUndefAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
7339   static MaybeUndefAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
7340   static MaybeUndefAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_maybe_undef);
7341   static MaybeUndefAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_maybe_undef);
7342 
7343   // Constructors
7344   MaybeUndefAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
7345              );
7346 
7347   MaybeUndefAttr *clone(ASTContext &C) const;
7348   void printPretty(raw_ostream &OS,
7349                    const PrintingPolicy &Policy) const;
7350   const char *getSpelling() const;
7351 
7352 
7353   static bool classof(const Attr *A) { return A->getKind() == attr::MaybeUndef; }
7354 };
7355 
7356 class CLANG_ABI MicroMipsAttr : public InheritableAttr {
7357 public:
7358   enum Spelling {
7359     GNU_micromips = 0,
7360     CXX11_gnu_micromips = 1,
7361     C23_gnu_micromips = 2,
7362   SpellingNotCalculated = 15
7363 
7364   };
7365 
7366   // Factory methods
7367   static MicroMipsAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
7368   static MicroMipsAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
7369   static MicroMipsAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_micromips);
7370   static MicroMipsAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_micromips);
7371 
7372   // Constructors
7373   MicroMipsAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
7374              );
7375 
7376   MicroMipsAttr *clone(ASTContext &C) const;
7377   void printPretty(raw_ostream &OS,
7378                    const PrintingPolicy &Policy) const;
7379   const char *getSpelling() const;
7380 
7381 
7382   static bool classof(const Attr *A) { return A->getKind() == attr::MicroMips; }
7383 };
7384 
7385 class CLANG_ABI MinSizeAttr : public InheritableAttr {
7386 public:
7387   enum Spelling {
7388     GNU_minsize = 0,
7389     CXX11_clang_minsize = 1,
7390     C23_clang_minsize = 2,
7391   SpellingNotCalculated = 15
7392 
7393   };
7394 
7395   // Factory methods
7396   static MinSizeAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
7397   static MinSizeAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
7398   static MinSizeAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_minsize);
7399   static MinSizeAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_minsize);
7400 
7401   // Constructors
7402   MinSizeAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
7403              );
7404 
7405   MinSizeAttr *clone(ASTContext &C) const;
7406   void printPretty(raw_ostream &OS,
7407                    const PrintingPolicy &Policy) const;
7408   const char *getSpelling() const;
7409 
7410 
7411   static bool classof(const Attr *A) { return A->getKind() == attr::MinSize; }
7412 };
7413 
7414 class CLANG_ABI MinVectorWidthAttr : public InheritableAttr {
7415 unsigned vectorWidth;
7416 
7417 public:
7418   enum Spelling {
7419     GNU_min_vector_width = 0,
7420     CXX11_clang_min_vector_width = 1,
7421     C23_clang_min_vector_width = 2,
7422   SpellingNotCalculated = 15
7423 
7424   };
7425 
7426   // Factory methods
7427   static MinVectorWidthAttr *CreateImplicit(ASTContext &Ctx, unsigned VectorWidth, const AttributeCommonInfo &CommonInfo);
7428   static MinVectorWidthAttr *Create(ASTContext &Ctx, unsigned VectorWidth, const AttributeCommonInfo &CommonInfo);
7429   static MinVectorWidthAttr *CreateImplicit(ASTContext &Ctx, unsigned VectorWidth, SourceRange Range = {}, Spelling S = GNU_min_vector_width);
7430   static MinVectorWidthAttr *Create(ASTContext &Ctx, unsigned VectorWidth, SourceRange Range = {}, Spelling S = GNU_min_vector_width);
7431 
7432   // Constructors
7433   MinVectorWidthAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
7434               , unsigned VectorWidth
7435              );
7436 
7437   MinVectorWidthAttr *clone(ASTContext &C) const;
7438   void printPretty(raw_ostream &OS,
7439                    const PrintingPolicy &Policy) const;
7440   const char *getSpelling() const;
7441   unsigned getVectorWidth() const {
7442     return vectorWidth;
7443   }
7444 
7445 
7446 
7447   static bool classof(const Attr *A) { return A->getKind() == attr::MinVectorWidth; }
7448 };
7449 
7450 class CLANG_ABI Mips16Attr : public InheritableAttr {
7451 public:
7452   enum Spelling {
7453     GNU_mips16 = 0,
7454     CXX11_gnu_mips16 = 1,
7455     C23_gnu_mips16 = 2,
7456   SpellingNotCalculated = 15
7457 
7458   };
7459 
7460   // Factory methods
7461   static Mips16Attr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
7462   static Mips16Attr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
7463   static Mips16Attr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_mips16);
7464   static Mips16Attr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_mips16);
7465 
7466   // Constructors
7467   Mips16Attr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
7468              );
7469 
7470   Mips16Attr *clone(ASTContext &C) const;
7471   void printPretty(raw_ostream &OS,
7472                    const PrintingPolicy &Policy) const;
7473   const char *getSpelling() const;
7474 
7475 
7476   static bool classof(const Attr *A) { return A->getKind() == attr::Mips16; }
7477 };
7478 
7479 class CLANG_ABI MipsInterruptAttr : public InheritableAttr {
7480 public:
7481   enum InterruptType {
7482     sw0,
7483     sw1,
7484     hw0,
7485     hw1,
7486     hw2,
7487     hw3,
7488     hw4,
7489     hw5,
7490     eic
7491   };
7492 private:
7493   MipsInterruptAttr::InterruptType interrupt;
7494 
7495 public:
7496   enum Spelling {
7497     GNU_interrupt = 0,
7498     CXX11_gnu_interrupt = 1,
7499     C23_gnu_interrupt = 2,
7500   SpellingNotCalculated = 15
7501 
7502   };
7503 
7504   // Factory methods
7505   static MipsInterruptAttr *CreateImplicit(ASTContext &Ctx, MipsInterruptAttr::InterruptType Interrupt, const AttributeCommonInfo &CommonInfo);
7506   static MipsInterruptAttr *Create(ASTContext &Ctx, MipsInterruptAttr::InterruptType Interrupt, const AttributeCommonInfo &CommonInfo);
7507   static MipsInterruptAttr *CreateImplicit(ASTContext &Ctx, MipsInterruptAttr::InterruptType Interrupt, SourceRange Range = {}, Spelling S = GNU_interrupt);
7508   static MipsInterruptAttr *Create(ASTContext &Ctx, MipsInterruptAttr::InterruptType Interrupt, SourceRange Range = {}, Spelling S = GNU_interrupt);
7509 
7510   // Constructors
7511   MipsInterruptAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
7512               , MipsInterruptAttr::InterruptType Interrupt
7513              );
7514 
7515   MipsInterruptAttr *clone(ASTContext &C) const;
7516   void printPretty(raw_ostream &OS,
7517                    const PrintingPolicy &Policy) const;
7518   const char *getSpelling() const;
7519   MipsInterruptAttr::InterruptType getInterrupt() const {
7520     return interrupt;
7521   }
7522 
7523   static bool ConvertStrToInterruptType(StringRef Val, MipsInterruptAttr::InterruptType &Out);
7524   static const char *ConvertInterruptTypeToStr(MipsInterruptAttr::InterruptType Val);
7525 
7526 
7527   static bool classof(const Attr *A) { return A->getKind() == attr::MipsInterrupt; }
7528 };
7529 
7530 class CLANG_ABI MipsLongCallAttr : public InheritableAttr {
7531 public:
7532   enum Spelling {
7533     GNU_long_call = 0,
7534     CXX11_gnu_long_call = 1,
7535     C23_gnu_long_call = 2,
7536     GNU_far = 3,
7537     CXX11_gnu_far = 4,
7538     C23_gnu_far = 5,
7539   SpellingNotCalculated = 15
7540 
7541   };
7542 
7543   // Factory methods
7544   static MipsLongCallAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
7545   static MipsLongCallAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
7546   static MipsLongCallAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_long_call);
7547   static MipsLongCallAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_long_call);
7548 
7549   // Constructors
7550   MipsLongCallAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
7551              );
7552 
7553   MipsLongCallAttr *clone(ASTContext &C) const;
7554   void printPretty(raw_ostream &OS,
7555                    const PrintingPolicy &Policy) const;
7556   const char *getSpelling() const;
7557   Spelling getSemanticSpelling() const;
7558 
7559 
7560   static bool classof(const Attr *A) { return A->getKind() == attr::MipsLongCall; }
7561 };
7562 
7563 class CLANG_ABI MipsShortCallAttr : public InheritableAttr {
7564 public:
7565   enum Spelling {
7566     GNU_short_call = 0,
7567     CXX11_gnu_short_call = 1,
7568     C23_gnu_short_call = 2,
7569     GNU_near = 3,
7570     CXX11_gnu_near = 4,
7571     C23_gnu_near = 5,
7572   SpellingNotCalculated = 15
7573 
7574   };
7575 
7576   // Factory methods
7577   static MipsShortCallAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
7578   static MipsShortCallAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
7579   static MipsShortCallAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_short_call);
7580   static MipsShortCallAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_short_call);
7581 
7582   // Constructors
7583   MipsShortCallAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
7584              );
7585 
7586   MipsShortCallAttr *clone(ASTContext &C) const;
7587   void printPretty(raw_ostream &OS,
7588                    const PrintingPolicy &Policy) const;
7589   const char *getSpelling() const;
7590   Spelling getSemanticSpelling() const;
7591 
7592 
7593   static bool classof(const Attr *A) { return A->getKind() == attr::MipsShortCall; }
7594 };
7595 
7596 class CLANG_ABI ModeAttr : public Attr {
7597 IdentifierInfo * mode;
7598 
7599 public:
7600   enum Spelling {
7601     GNU_mode = 0,
7602     CXX11_gnu_mode = 1,
7603     C23_gnu_mode = 2,
7604   SpellingNotCalculated = 15
7605 
7606   };
7607 
7608   // Factory methods
7609   static ModeAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * Mode, const AttributeCommonInfo &CommonInfo);
7610   static ModeAttr *Create(ASTContext &Ctx, IdentifierInfo * Mode, const AttributeCommonInfo &CommonInfo);
7611   static ModeAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * Mode, SourceRange Range = {}, Spelling S = GNU_mode);
7612   static ModeAttr *Create(ASTContext &Ctx, IdentifierInfo * Mode, SourceRange Range = {}, Spelling S = GNU_mode);
7613 
7614   // Constructors
7615   ModeAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
7616               , IdentifierInfo * Mode
7617              );
7618 
7619   ModeAttr *clone(ASTContext &C) const;
7620   void printPretty(raw_ostream &OS,
7621                    const PrintingPolicy &Policy) const;
7622   const char *getSpelling() const;
7623   IdentifierInfo * getMode() const {
7624     return mode;
7625   }
7626 
7627 
7628 
7629   static bool classof(const Attr *A) { return A->getKind() == attr::Mode; }
7630 };
7631 
7632 class CLANG_ABI MustTailAttr : public StmtAttr {
7633 public:
7634   enum Spelling {
7635     GNU_musttail = 0,
7636     CXX11_clang_musttail = 1,
7637     C23_clang_musttail = 2,
7638   SpellingNotCalculated = 15
7639 
7640   };
7641 
7642   // Factory methods
7643   static MustTailAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
7644   static MustTailAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
7645   static MustTailAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_musttail);
7646   static MustTailAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_musttail);
7647 
7648   // Constructors
7649   MustTailAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
7650              );
7651 
7652   MustTailAttr *clone(ASTContext &C) const;
7653   void printPretty(raw_ostream &OS,
7654                    const PrintingPolicy &Policy) const;
7655   const char *getSpelling() const;
7656 
7657 
7658   static bool classof(const Attr *A) { return A->getKind() == attr::MustTail; }
7659 };
7660 
7661 class CLANG_ABI NSConsumedAttr : public InheritableParamAttr {
7662 public:
7663   enum Spelling {
7664     GNU_ns_consumed = 0,
7665     CXX11_clang_ns_consumed = 1,
7666     C23_clang_ns_consumed = 2,
7667   SpellingNotCalculated = 15
7668 
7669   };
7670 
7671   // Factory methods
7672   static NSConsumedAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
7673   static NSConsumedAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
7674   static NSConsumedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_ns_consumed);
7675   static NSConsumedAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_ns_consumed);
7676 
7677   // Constructors
7678   NSConsumedAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
7679              );
7680 
7681   NSConsumedAttr *clone(ASTContext &C) const;
7682   void printPretty(raw_ostream &OS,
7683                    const PrintingPolicy &Policy) const;
7684   const char *getSpelling() const;
7685 
7686 
7687   static bool classof(const Attr *A) { return A->getKind() == attr::NSConsumed; }
7688 };
7689 
7690 class CLANG_ABI NSConsumesSelfAttr : public InheritableAttr {
7691 public:
7692   enum Spelling {
7693     GNU_ns_consumes_self = 0,
7694     CXX11_clang_ns_consumes_self = 1,
7695     C23_clang_ns_consumes_self = 2,
7696   SpellingNotCalculated = 15
7697 
7698   };
7699 
7700   // Factory methods
7701   static NSConsumesSelfAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
7702   static NSConsumesSelfAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
7703   static NSConsumesSelfAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_ns_consumes_self);
7704   static NSConsumesSelfAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_ns_consumes_self);
7705 
7706   // Constructors
7707   NSConsumesSelfAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
7708              );
7709 
7710   NSConsumesSelfAttr *clone(ASTContext &C) const;
7711   void printPretty(raw_ostream &OS,
7712                    const PrintingPolicy &Policy) const;
7713   const char *getSpelling() const;
7714 
7715 
7716   static bool classof(const Attr *A) { return A->getKind() == attr::NSConsumesSelf; }
7717 };
7718 
7719 class CLANG_ABI NSErrorDomainAttr : public InheritableAttr {
7720 IdentifierInfo * errorDomain;
7721 
7722 public:
7723   // Factory methods
7724   static NSErrorDomainAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * ErrorDomain, const AttributeCommonInfo &CommonInfo);
7725   static NSErrorDomainAttr *Create(ASTContext &Ctx, IdentifierInfo * ErrorDomain, const AttributeCommonInfo &CommonInfo);
7726   static NSErrorDomainAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * ErrorDomain, SourceRange Range = {});
7727   static NSErrorDomainAttr *Create(ASTContext &Ctx, IdentifierInfo * ErrorDomain, SourceRange Range = {});
7728 
7729   // Constructors
7730   NSErrorDomainAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
7731               , IdentifierInfo * ErrorDomain
7732              );
7733 
7734   NSErrorDomainAttr *clone(ASTContext &C) const;
7735   void printPretty(raw_ostream &OS,
7736                    const PrintingPolicy &Policy) const;
7737   const char *getSpelling() const;
7738   IdentifierInfo * getErrorDomain() const {
7739     return errorDomain;
7740   }
7741 
7742 
7743 
7744   static bool classof(const Attr *A) { return A->getKind() == attr::NSErrorDomain; }
7745 };
7746 
7747 class CLANG_ABI NSReturnsAutoreleasedAttr : public InheritableAttr {
7748 public:
7749   enum Spelling {
7750     GNU_ns_returns_autoreleased = 0,
7751     CXX11_clang_ns_returns_autoreleased = 1,
7752     C23_clang_ns_returns_autoreleased = 2,
7753   SpellingNotCalculated = 15
7754 
7755   };
7756 
7757   // Factory methods
7758   static NSReturnsAutoreleasedAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
7759   static NSReturnsAutoreleasedAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
7760   static NSReturnsAutoreleasedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_ns_returns_autoreleased);
7761   static NSReturnsAutoreleasedAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_ns_returns_autoreleased);
7762 
7763   // Constructors
7764   NSReturnsAutoreleasedAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
7765              );
7766 
7767   NSReturnsAutoreleasedAttr *clone(ASTContext &C) const;
7768   void printPretty(raw_ostream &OS,
7769                    const PrintingPolicy &Policy) const;
7770   const char *getSpelling() const;
7771 
7772 
7773   static bool classof(const Attr *A) { return A->getKind() == attr::NSReturnsAutoreleased; }
7774 };
7775 
7776 class CLANG_ABI NSReturnsNotRetainedAttr : public InheritableAttr {
7777 public:
7778   enum Spelling {
7779     GNU_ns_returns_not_retained = 0,
7780     CXX11_clang_ns_returns_not_retained = 1,
7781     C23_clang_ns_returns_not_retained = 2,
7782   SpellingNotCalculated = 15
7783 
7784   };
7785 
7786   // Factory methods
7787   static NSReturnsNotRetainedAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
7788   static NSReturnsNotRetainedAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
7789   static NSReturnsNotRetainedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_ns_returns_not_retained);
7790   static NSReturnsNotRetainedAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_ns_returns_not_retained);
7791 
7792   // Constructors
7793   NSReturnsNotRetainedAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
7794              );
7795 
7796   NSReturnsNotRetainedAttr *clone(ASTContext &C) const;
7797   void printPretty(raw_ostream &OS,
7798                    const PrintingPolicy &Policy) const;
7799   const char *getSpelling() const;
7800 
7801 
7802   static bool classof(const Attr *A) { return A->getKind() == attr::NSReturnsNotRetained; }
7803 };
7804 
7805 class CLANG_ABI NSReturnsRetainedAttr : public InheritableAttr {
7806 public:
7807   enum Spelling {
7808     GNU_ns_returns_retained = 0,
7809     CXX11_clang_ns_returns_retained = 1,
7810     C23_clang_ns_returns_retained = 2,
7811   SpellingNotCalculated = 15
7812 
7813   };
7814 
7815   // Factory methods
7816   static NSReturnsRetainedAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
7817   static NSReturnsRetainedAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
7818   static NSReturnsRetainedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_ns_returns_retained);
7819   static NSReturnsRetainedAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_ns_returns_retained);
7820 
7821   // Constructors
7822   NSReturnsRetainedAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
7823              );
7824 
7825   NSReturnsRetainedAttr *clone(ASTContext &C) const;
7826   void printPretty(raw_ostream &OS,
7827                    const PrintingPolicy &Policy) const;
7828   const char *getSpelling() const;
7829 
7830 
7831   static bool classof(const Attr *A) { return A->getKind() == attr::NSReturnsRetained; }
7832 };
7833 
7834 class CLANG_ABI NVPTXKernelAttr : public InheritableAttr {
7835 public:
7836   enum Spelling {
7837     GNU_nvptx_kernel = 0,
7838     CXX11_clang_nvptx_kernel = 1,
7839     C23_clang_nvptx_kernel = 2,
7840   SpellingNotCalculated = 15
7841 
7842   };
7843 
7844   // Factory methods
7845   static NVPTXKernelAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
7846   static NVPTXKernelAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
7847   static NVPTXKernelAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_nvptx_kernel);
7848   static NVPTXKernelAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_nvptx_kernel);
7849 
7850   // Constructors
7851   NVPTXKernelAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
7852              );
7853 
7854   NVPTXKernelAttr *clone(ASTContext &C) const;
7855   void printPretty(raw_ostream &OS,
7856                    const PrintingPolicy &Policy) const;
7857   const char *getSpelling() const;
7858 
7859 
7860   static bool classof(const Attr *A) { return A->getKind() == attr::NVPTXKernel; }
7861 };
7862 
7863 class CLANG_ABI NakedAttr : public InheritableAttr {
7864 public:
7865   enum Spelling {
7866     GNU_naked = 0,
7867     CXX11_gnu_naked = 1,
7868     C23_gnu_naked = 2,
7869     Declspec_naked = 3,
7870   SpellingNotCalculated = 15
7871 
7872   };
7873 
7874   // Factory methods
7875   static NakedAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
7876   static NakedAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
7877   static NakedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_naked);
7878   static NakedAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_naked);
7879 
7880   // Constructors
7881   NakedAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
7882              );
7883 
7884   NakedAttr *clone(ASTContext &C) const;
7885   void printPretty(raw_ostream &OS,
7886                    const PrintingPolicy &Policy) const;
7887   const char *getSpelling() const;
7888 
7889 
7890   static bool classof(const Attr *A) { return A->getKind() == attr::Naked; }
7891 };
7892 
7893 class CLANG_ABI NoAliasAttr : public InheritableAttr {
7894 public:
7895   // Factory methods
7896   static NoAliasAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
7897   static NoAliasAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
7898   static NoAliasAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {});
7899   static NoAliasAttr *Create(ASTContext &Ctx, SourceRange Range = {});
7900 
7901   // Constructors
7902   NoAliasAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
7903              );
7904 
7905   NoAliasAttr *clone(ASTContext &C) const;
7906   void printPretty(raw_ostream &OS,
7907                    const PrintingPolicy &Policy) const;
7908   const char *getSpelling() const;
7909 
7910 
7911   static bool classof(const Attr *A) { return A->getKind() == attr::NoAlias; }
7912 };
7913 
7914 class CLANG_ABI NoBuiltinAttr : public Attr {
7915   unsigned builtinNames_Size;
7916   StringRef *builtinNames_;
7917 
7918 public:
7919   enum Spelling {
7920     GNU_no_builtin = 0,
7921     CXX11_clang_no_builtin = 1,
7922     C23_clang_no_builtin = 2,
7923   SpellingNotCalculated = 15
7924 
7925   };
7926 
7927   // Factory methods
7928   static NoBuiltinAttr *CreateImplicit(ASTContext &Ctx, StringRef *BuiltinNames, unsigned BuiltinNamesSize, const AttributeCommonInfo &CommonInfo);
7929   static NoBuiltinAttr *Create(ASTContext &Ctx, StringRef *BuiltinNames, unsigned BuiltinNamesSize, const AttributeCommonInfo &CommonInfo);
7930   static NoBuiltinAttr *CreateImplicit(ASTContext &Ctx, StringRef *BuiltinNames, unsigned BuiltinNamesSize, SourceRange Range = {}, Spelling S = GNU_no_builtin);
7931   static NoBuiltinAttr *Create(ASTContext &Ctx, StringRef *BuiltinNames, unsigned BuiltinNamesSize, SourceRange Range = {}, Spelling S = GNU_no_builtin);
7932 
7933   // Constructors
7934   NoBuiltinAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
7935               , StringRef *BuiltinNames, unsigned BuiltinNamesSize
7936              );
7937   NoBuiltinAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
7938              );
7939 
7940   NoBuiltinAttr *clone(ASTContext &C) const;
7941   void printPretty(raw_ostream &OS,
7942                    const PrintingPolicy &Policy) const;
7943   const char *getSpelling() const;
7944   typedef StringRef* builtinNames_iterator;
7945   builtinNames_iterator builtinNames_begin() const { return builtinNames_; }
7946   builtinNames_iterator builtinNames_end() const { return builtinNames_ + builtinNames_Size; }
7947   unsigned builtinNames_size() const { return builtinNames_Size; }
7948   llvm::iterator_range<builtinNames_iterator> builtinNames() const { return llvm::make_range(builtinNames_begin(), builtinNames_end()); }
7949 
7950 
7951 
7952 
7953   static bool classof(const Attr *A) { return A->getKind() == attr::NoBuiltin; }
7954 };
7955 
7956 class CLANG_ABI NoCommonAttr : public InheritableAttr {
7957 public:
7958   enum Spelling {
7959     GNU_nocommon = 0,
7960     CXX11_gnu_nocommon = 1,
7961     C23_gnu_nocommon = 2,
7962   SpellingNotCalculated = 15
7963 
7964   };
7965 
7966   // Factory methods
7967   static NoCommonAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
7968   static NoCommonAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
7969   static NoCommonAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_nocommon);
7970   static NoCommonAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_nocommon);
7971 
7972   // Constructors
7973   NoCommonAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
7974              );
7975 
7976   NoCommonAttr *clone(ASTContext &C) const;
7977   void printPretty(raw_ostream &OS,
7978                    const PrintingPolicy &Policy) const;
7979   const char *getSpelling() const;
7980 
7981 
7982   static bool classof(const Attr *A) { return A->getKind() == attr::NoCommon; }
7983 };
7984 
7985 class CLANG_ABI NoConvergentAttr : public InheritableAttr {
7986 public:
7987   enum Spelling {
7988     GNU_noconvergent = 0,
7989     CXX11_clang_noconvergent = 1,
7990     C23_clang_noconvergent = 2,
7991     Declspec_noconvergent = 3,
7992   SpellingNotCalculated = 15
7993 
7994   };
7995 
7996   // Factory methods
7997   static NoConvergentAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
7998   static NoConvergentAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
7999   static NoConvergentAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_noconvergent);
8000   static NoConvergentAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_noconvergent);
8001 
8002   // Constructors
8003   NoConvergentAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
8004              );
8005 
8006   NoConvergentAttr *clone(ASTContext &C) const;
8007   void printPretty(raw_ostream &OS,
8008                    const PrintingPolicy &Policy) const;
8009   const char *getSpelling() const;
8010 
8011 
8012   static bool classof(const Attr *A) { return A->getKind() == attr::NoConvergent; }
8013 };
8014 
8015 class CLANG_ABI NoDebugAttr : public InheritableAttr {
8016 public:
8017   enum Spelling {
8018     GNU_nodebug = 0,
8019     CXX11_gnu_nodebug = 1,
8020     C23_gnu_nodebug = 2,
8021   SpellingNotCalculated = 15
8022 
8023   };
8024 
8025   // Factory methods
8026   static NoDebugAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
8027   static NoDebugAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
8028   static NoDebugAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_nodebug);
8029   static NoDebugAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_nodebug);
8030 
8031   // Constructors
8032   NoDebugAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
8033              );
8034 
8035   NoDebugAttr *clone(ASTContext &C) const;
8036   void printPretty(raw_ostream &OS,
8037                    const PrintingPolicy &Policy) const;
8038   const char *getSpelling() const;
8039 
8040 
8041   static bool classof(const Attr *A) { return A->getKind() == attr::NoDebug; }
8042 };
8043 
8044 class CLANG_ABI NoDerefAttr : public TypeAttr {
8045 public:
8046   enum Spelling {
8047     GNU_noderef = 0,
8048     CXX11_clang_noderef = 1,
8049     C23_clang_noderef = 2,
8050   SpellingNotCalculated = 15
8051 
8052   };
8053 
8054   // Factory methods
8055   static NoDerefAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
8056   static NoDerefAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
8057   static NoDerefAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_noderef);
8058   static NoDerefAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_noderef);
8059 
8060   // Constructors
8061   NoDerefAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
8062              );
8063 
8064   NoDerefAttr *clone(ASTContext &C) const;
8065   void printPretty(raw_ostream &OS,
8066                    const PrintingPolicy &Policy) const;
8067   const char *getSpelling() const;
8068 
8069 
8070   static bool classof(const Attr *A) { return A->getKind() == attr::NoDeref; }
8071 };
8072 
8073 class CLANG_ABI NoDestroyAttr : public InheritableAttr {
8074 public:
8075   enum Spelling {
8076     GNU_no_destroy = 0,
8077     CXX11_clang_no_destroy = 1,
8078   SpellingNotCalculated = 15
8079 
8080   };
8081 
8082   // Factory methods
8083   static NoDestroyAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
8084   static NoDestroyAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
8085   static NoDestroyAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_no_destroy);
8086   static NoDestroyAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_no_destroy);
8087 
8088   // Constructors
8089   NoDestroyAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
8090              );
8091 
8092   NoDestroyAttr *clone(ASTContext &C) const;
8093   void printPretty(raw_ostream &OS,
8094                    const PrintingPolicy &Policy) const;
8095   const char *getSpelling() const;
8096 
8097 
8098   static bool classof(const Attr *A) { return A->getKind() == attr::NoDestroy; }
8099 };
8100 
8101 class CLANG_ABI NoDuplicateAttr : public InheritableAttr {
8102 public:
8103   enum Spelling {
8104     GNU_noduplicate = 0,
8105     CXX11_clang_noduplicate = 1,
8106     C23_clang_noduplicate = 2,
8107   SpellingNotCalculated = 15
8108 
8109   };
8110 
8111   // Factory methods
8112   static NoDuplicateAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
8113   static NoDuplicateAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
8114   static NoDuplicateAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_noduplicate);
8115   static NoDuplicateAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_noduplicate);
8116 
8117   // Constructors
8118   NoDuplicateAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
8119              );
8120 
8121   NoDuplicateAttr *clone(ASTContext &C) const;
8122   void printPretty(raw_ostream &OS,
8123                    const PrintingPolicy &Policy) const;
8124   const char *getSpelling() const;
8125 
8126 
8127   static bool classof(const Attr *A) { return A->getKind() == attr::NoDuplicate; }
8128 };
8129 
8130 class CLANG_ABI NoEscapeAttr : public Attr {
8131 public:
8132   enum Spelling {
8133     GNU_noescape = 0,
8134     CXX11_clang_noescape = 1,
8135     C23_clang_noescape = 2,
8136   SpellingNotCalculated = 15
8137 
8138   };
8139 
8140   // Factory methods
8141   static NoEscapeAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
8142   static NoEscapeAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
8143   static NoEscapeAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_noescape);
8144   static NoEscapeAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_noescape);
8145 
8146   // Constructors
8147   NoEscapeAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
8148              );
8149 
8150   NoEscapeAttr *clone(ASTContext &C) const;
8151   void printPretty(raw_ostream &OS,
8152                    const PrintingPolicy &Policy) const;
8153   const char *getSpelling() const;
8154 
8155 
8156   static bool classof(const Attr *A) { return A->getKind() == attr::NoEscape; }
8157 };
8158 
8159 class CLANG_ABI NoInlineAttr : public DeclOrStmtAttr {
8160 public:
8161   enum Spelling {
8162     Keyword_noinline = 0,
8163     GNU_noinline = 1,
8164     CXX11_gnu_noinline = 2,
8165     C23_gnu_noinline = 3,
8166     CXX11_clang_noinline = 4,
8167     C23_clang_noinline = 5,
8168     CXX11_msvc_noinline = 6,
8169     C23_msvc_noinline = 7,
8170     Declspec_noinline = 8,
8171   SpellingNotCalculated = 15
8172 
8173   };
8174 
8175   // Factory methods
8176   static NoInlineAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
8177   static NoInlineAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
8178   static NoInlineAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = Keyword_noinline);
8179   static NoInlineAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = Keyword_noinline);
8180 
8181   // Constructors
8182   NoInlineAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
8183              );
8184 
8185   NoInlineAttr *clone(ASTContext &C) const;
8186   void printPretty(raw_ostream &OS,
8187                    const PrintingPolicy &Policy) const;
8188   const char *getSpelling() const;
8189   bool isStmtNoInline() const { return getAttributeSpellingListIndex() == 4 ||
8190     getAttributeSpellingListIndex() == 5 ||
8191     getAttributeSpellingListIndex() == 6 ||
8192     getAttributeSpellingListIndex() == 7; }
8193 
8194 
8195   static bool classof(const Attr *A) { return A->getKind() == attr::NoInline; }
8196 };
8197 
8198 class CLANG_ABI NoInstrumentFunctionAttr : public InheritableAttr {
8199 public:
8200   enum Spelling {
8201     GNU_no_instrument_function = 0,
8202     CXX11_gnu_no_instrument_function = 1,
8203     C23_gnu_no_instrument_function = 2,
8204   SpellingNotCalculated = 15
8205 
8206   };
8207 
8208   // Factory methods
8209   static NoInstrumentFunctionAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
8210   static NoInstrumentFunctionAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
8211   static NoInstrumentFunctionAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_no_instrument_function);
8212   static NoInstrumentFunctionAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_no_instrument_function);
8213 
8214   // Constructors
8215   NoInstrumentFunctionAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
8216              );
8217 
8218   NoInstrumentFunctionAttr *clone(ASTContext &C) const;
8219   void printPretty(raw_ostream &OS,
8220                    const PrintingPolicy &Policy) const;
8221   const char *getSpelling() const;
8222 
8223 
8224   static bool classof(const Attr *A) { return A->getKind() == attr::NoInstrumentFunction; }
8225 };
8226 
8227 class CLANG_ABI NoMergeAttr : public DeclOrStmtAttr {
8228 public:
8229   enum Spelling {
8230     GNU_nomerge = 0,
8231     CXX11_clang_nomerge = 1,
8232     C23_clang_nomerge = 2,
8233   SpellingNotCalculated = 15
8234 
8235   };
8236 
8237   // Factory methods
8238   static NoMergeAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
8239   static NoMergeAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
8240   static NoMergeAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_nomerge);
8241   static NoMergeAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_nomerge);
8242 
8243   // Constructors
8244   NoMergeAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
8245              );
8246 
8247   NoMergeAttr *clone(ASTContext &C) const;
8248   void printPretty(raw_ostream &OS,
8249                    const PrintingPolicy &Policy) const;
8250   const char *getSpelling() const;
8251 
8252 
8253   static bool classof(const Attr *A) { return A->getKind() == attr::NoMerge; }
8254 };
8255 
8256 class CLANG_ABI NoMicroMipsAttr : public InheritableAttr {
8257 public:
8258   enum Spelling {
8259     GNU_nomicromips = 0,
8260     CXX11_gnu_nomicromips = 1,
8261     C23_gnu_nomicromips = 2,
8262   SpellingNotCalculated = 15
8263 
8264   };
8265 
8266   // Factory methods
8267   static NoMicroMipsAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
8268   static NoMicroMipsAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
8269   static NoMicroMipsAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_nomicromips);
8270   static NoMicroMipsAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_nomicromips);
8271 
8272   // Constructors
8273   NoMicroMipsAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
8274              );
8275 
8276   NoMicroMipsAttr *clone(ASTContext &C) const;
8277   void printPretty(raw_ostream &OS,
8278                    const PrintingPolicy &Policy) const;
8279   const char *getSpelling() const;
8280 
8281 
8282   static bool classof(const Attr *A) { return A->getKind() == attr::NoMicroMips; }
8283 };
8284 
8285 class CLANG_ABI NoMips16Attr : public InheritableAttr {
8286 public:
8287   enum Spelling {
8288     GNU_nomips16 = 0,
8289     CXX11_gnu_nomips16 = 1,
8290     C23_gnu_nomips16 = 2,
8291   SpellingNotCalculated = 15
8292 
8293   };
8294 
8295   // Factory methods
8296   static NoMips16Attr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
8297   static NoMips16Attr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
8298   static NoMips16Attr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_nomips16);
8299   static NoMips16Attr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_nomips16);
8300 
8301   // Constructors
8302   NoMips16Attr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
8303              );
8304 
8305   NoMips16Attr *clone(ASTContext &C) const;
8306   void printPretty(raw_ostream &OS,
8307                    const PrintingPolicy &Policy) const;
8308   const char *getSpelling() const;
8309 
8310 
8311   static bool classof(const Attr *A) { return A->getKind() == attr::NoMips16; }
8312 };
8313 
8314 class CLANG_ABI NoProfileFunctionAttr : public InheritableAttr {
8315 public:
8316   enum Spelling {
8317     GNU_no_profile_instrument_function = 0,
8318     CXX11_gnu_no_profile_instrument_function = 1,
8319     C23_gnu_no_profile_instrument_function = 2,
8320   SpellingNotCalculated = 15
8321 
8322   };
8323 
8324   // Factory methods
8325   static NoProfileFunctionAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
8326   static NoProfileFunctionAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
8327   static NoProfileFunctionAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_no_profile_instrument_function);
8328   static NoProfileFunctionAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_no_profile_instrument_function);
8329 
8330   // Constructors
8331   NoProfileFunctionAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
8332              );
8333 
8334   NoProfileFunctionAttr *clone(ASTContext &C) const;
8335   void printPretty(raw_ostream &OS,
8336                    const PrintingPolicy &Policy) const;
8337   const char *getSpelling() const;
8338 
8339 
8340   static bool classof(const Attr *A) { return A->getKind() == attr::NoProfileFunction; }
8341 };
8342 
8343 class CLANG_ABI NoRandomizeLayoutAttr : public InheritableAttr {
8344 public:
8345   enum Spelling {
8346     GNU_no_randomize_layout = 0,
8347     CXX11_gnu_no_randomize_layout = 1,
8348     C23_gnu_no_randomize_layout = 2,
8349   SpellingNotCalculated = 15
8350 
8351   };
8352 
8353   // Factory methods
8354   static NoRandomizeLayoutAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
8355   static NoRandomizeLayoutAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
8356   static NoRandomizeLayoutAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_no_randomize_layout);
8357   static NoRandomizeLayoutAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_no_randomize_layout);
8358 
8359   // Constructors
8360   NoRandomizeLayoutAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
8361              );
8362 
8363   NoRandomizeLayoutAttr *clone(ASTContext &C) const;
8364   void printPretty(raw_ostream &OS,
8365                    const PrintingPolicy &Policy) const;
8366   const char *getSpelling() const;
8367 
8368 
8369   static bool classof(const Attr *A) { return A->getKind() == attr::NoRandomizeLayout; }
8370 };
8371 
8372 class CLANG_ABI NoReturnAttr : public InheritableAttr {
8373 public:
8374   enum Spelling {
8375     GNU_noreturn = 0,
8376     CXX11_gnu_noreturn = 1,
8377     C23_gnu_noreturn = 2,
8378     Declspec_noreturn = 3,
8379   SpellingNotCalculated = 15
8380 
8381   };
8382 
8383   // Factory methods
8384   static NoReturnAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
8385   static NoReturnAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
8386   static NoReturnAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_noreturn);
8387   static NoReturnAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_noreturn);
8388 
8389   // Constructors
8390   NoReturnAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
8391              );
8392 
8393   NoReturnAttr *clone(ASTContext &C) const;
8394   void printPretty(raw_ostream &OS,
8395                    const PrintingPolicy &Policy) const;
8396   const char *getSpelling() const;
8397 
8398 
8399   static bool classof(const Attr *A) { return A->getKind() == attr::NoReturn; }
8400 };
8401 
8402 class CLANG_ABI NoSanitizeAttr : public InheritableAttr {
8403   unsigned sanitizers_Size;
8404   StringRef *sanitizers_;
8405 
8406 public:
8407   enum Spelling {
8408     GNU_no_sanitize = 0,
8409     CXX11_clang_no_sanitize = 1,
8410     C23_clang_no_sanitize = 2,
8411   SpellingNotCalculated = 15
8412 
8413   };
8414 
8415   // Factory methods
8416   static NoSanitizeAttr *CreateImplicit(ASTContext &Ctx, StringRef *Sanitizers, unsigned SanitizersSize, const AttributeCommonInfo &CommonInfo);
8417   static NoSanitizeAttr *Create(ASTContext &Ctx, StringRef *Sanitizers, unsigned SanitizersSize, const AttributeCommonInfo &CommonInfo);
8418   static NoSanitizeAttr *CreateImplicit(ASTContext &Ctx, StringRef *Sanitizers, unsigned SanitizersSize, SourceRange Range = {}, Spelling S = GNU_no_sanitize);
8419   static NoSanitizeAttr *Create(ASTContext &Ctx, StringRef *Sanitizers, unsigned SanitizersSize, SourceRange Range = {}, Spelling S = GNU_no_sanitize);
8420 
8421   // Constructors
8422   NoSanitizeAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
8423               , StringRef *Sanitizers, unsigned SanitizersSize
8424              );
8425   NoSanitizeAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
8426              );
8427 
8428   NoSanitizeAttr *clone(ASTContext &C) const;
8429   void printPretty(raw_ostream &OS,
8430                    const PrintingPolicy &Policy) const;
8431   const char *getSpelling() const;
8432   typedef StringRef* sanitizers_iterator;
8433   sanitizers_iterator sanitizers_begin() const { return sanitizers_; }
8434   sanitizers_iterator sanitizers_end() const { return sanitizers_ + sanitizers_Size; }
8435   unsigned sanitizers_size() const { return sanitizers_Size; }
8436   llvm::iterator_range<sanitizers_iterator> sanitizers() const { return llvm::make_range(sanitizers_begin(), sanitizers_end()); }
8437 
8438 
8439 
8440     SanitizerMask getMask() const {
8441       SanitizerMask Mask;
8442       for (auto SanitizerName : sanitizers()) {
8443         SanitizerMask ParsedMask =
8444             parseSanitizerValue(SanitizerName, /*AllowGroups=*/true);
8445         Mask |= expandSanitizerGroups(ParsedMask);
8446       }
8447       return Mask;
8448     }
8449 
8450     bool hasCoverage() const {
8451       return llvm::is_contained(sanitizers(), "coverage");
8452     }
8453   
8454 
8455   static bool classof(const Attr *A) { return A->getKind() == attr::NoSanitize; }
8456 };
8457 
8458 class CLANG_ABI NoSpecializationsAttr : public InheritableAttr {
8459 unsigned messageLength;
8460 char *message;
8461 
8462 public:
8463   enum Spelling {
8464     GNU_no_specializations = 0,
8465     CXX11_clang_no_specializations = 1,
8466   SpellingNotCalculated = 15
8467 
8468   };
8469 
8470   // Factory methods
8471   static NoSpecializationsAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Message, const AttributeCommonInfo &CommonInfo);
8472   static NoSpecializationsAttr *Create(ASTContext &Ctx, llvm::StringRef Message, const AttributeCommonInfo &CommonInfo);
8473   static NoSpecializationsAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Message, SourceRange Range = {}, Spelling S = GNU_no_specializations);
8474   static NoSpecializationsAttr *Create(ASTContext &Ctx, llvm::StringRef Message, SourceRange Range = {}, Spelling S = GNU_no_specializations);
8475 
8476   // Constructors
8477   NoSpecializationsAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
8478               , llvm::StringRef Message
8479              );
8480   NoSpecializationsAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
8481              );
8482 
8483   NoSpecializationsAttr *clone(ASTContext &C) const;
8484   void printPretty(raw_ostream &OS,
8485                    const PrintingPolicy &Policy) const;
8486   const char *getSpelling() const;
8487   llvm::StringRef getMessage() const {
8488     return llvm::StringRef(message, messageLength);
8489   }
8490   unsigned getMessageLength() const {
8491     return messageLength;
8492   }
8493   void setMessage(ASTContext &C, llvm::StringRef S) {
8494     messageLength = S.size();
8495     this->message = new (C, 1) char [messageLength];
8496     if (!S.empty())
8497       std::memcpy(this->message, S.data(), messageLength);
8498   }
8499 
8500 
8501 
8502   static bool classof(const Attr *A) { return A->getKind() == attr::NoSpecializations; }
8503 };
8504 
8505 class CLANG_ABI NoSpeculativeLoadHardeningAttr : public InheritableAttr {
8506 public:
8507   enum Spelling {
8508     GNU_no_speculative_load_hardening = 0,
8509     CXX11_clang_no_speculative_load_hardening = 1,
8510     C23_clang_no_speculative_load_hardening = 2,
8511   SpellingNotCalculated = 15
8512 
8513   };
8514 
8515   // Factory methods
8516   static NoSpeculativeLoadHardeningAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
8517   static NoSpeculativeLoadHardeningAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
8518   static NoSpeculativeLoadHardeningAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_no_speculative_load_hardening);
8519   static NoSpeculativeLoadHardeningAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_no_speculative_load_hardening);
8520 
8521   // Constructors
8522   NoSpeculativeLoadHardeningAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
8523              );
8524 
8525   NoSpeculativeLoadHardeningAttr *clone(ASTContext &C) const;
8526   void printPretty(raw_ostream &OS,
8527                    const PrintingPolicy &Policy) const;
8528   const char *getSpelling() const;
8529 
8530 
8531   static bool classof(const Attr *A) { return A->getKind() == attr::NoSpeculativeLoadHardening; }
8532 };
8533 
8534 class CLANG_ABI NoSplitStackAttr : public InheritableAttr {
8535 public:
8536   enum Spelling {
8537     GNU_no_split_stack = 0,
8538     CXX11_gnu_no_split_stack = 1,
8539     C23_gnu_no_split_stack = 2,
8540   SpellingNotCalculated = 15
8541 
8542   };
8543 
8544   // Factory methods
8545   static NoSplitStackAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
8546   static NoSplitStackAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
8547   static NoSplitStackAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_no_split_stack);
8548   static NoSplitStackAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_no_split_stack);
8549 
8550   // Constructors
8551   NoSplitStackAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
8552              );
8553 
8554   NoSplitStackAttr *clone(ASTContext &C) const;
8555   void printPretty(raw_ostream &OS,
8556                    const PrintingPolicy &Policy) const;
8557   const char *getSpelling() const;
8558 
8559 
8560   static bool classof(const Attr *A) { return A->getKind() == attr::NoSplitStack; }
8561 };
8562 
8563 class CLANG_ABI NoStackProtectorAttr : public InheritableAttr {
8564 public:
8565   enum Spelling {
8566     GNU_no_stack_protector = 0,
8567     CXX11_clang_no_stack_protector = 1,
8568     C23_clang_no_stack_protector = 2,
8569     CXX11_gnu_no_stack_protector = 3,
8570     C23_gnu_no_stack_protector = 4,
8571     Declspec_safebuffers = 5,
8572   SpellingNotCalculated = 15
8573 
8574   };
8575 
8576   // Factory methods
8577   static NoStackProtectorAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
8578   static NoStackProtectorAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
8579   static NoStackProtectorAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_no_stack_protector);
8580   static NoStackProtectorAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_no_stack_protector);
8581 
8582   // Constructors
8583   NoStackProtectorAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
8584              );
8585 
8586   NoStackProtectorAttr *clone(ASTContext &C) const;
8587   void printPretty(raw_ostream &OS,
8588                    const PrintingPolicy &Policy) const;
8589   const char *getSpelling() const;
8590   Spelling getSemanticSpelling() const;
8591 
8592 
8593   static bool classof(const Attr *A) { return A->getKind() == attr::NoStackProtector; }
8594 };
8595 
8596 class CLANG_ABI NoThreadSafetyAnalysisAttr : public InheritableAttr {
8597 public:
8598   enum Spelling {
8599     GNU_no_thread_safety_analysis = 0,
8600     CXX11_clang_no_thread_safety_analysis = 1,
8601     C23_clang_no_thread_safety_analysis = 2,
8602   SpellingNotCalculated = 15
8603 
8604   };
8605 
8606   // Factory methods
8607   static NoThreadSafetyAnalysisAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
8608   static NoThreadSafetyAnalysisAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
8609   static NoThreadSafetyAnalysisAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_no_thread_safety_analysis);
8610   static NoThreadSafetyAnalysisAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_no_thread_safety_analysis);
8611 
8612   // Constructors
8613   NoThreadSafetyAnalysisAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
8614              );
8615 
8616   NoThreadSafetyAnalysisAttr *clone(ASTContext &C) const;
8617   void printPretty(raw_ostream &OS,
8618                    const PrintingPolicy &Policy) const;
8619   const char *getSpelling() const;
8620 
8621 
8622   static bool classof(const Attr *A) { return A->getKind() == attr::NoThreadSafetyAnalysis; }
8623 };
8624 
8625 class CLANG_ABI NoThrowAttr : public InheritableAttr {
8626 public:
8627   enum Spelling {
8628     GNU_nothrow = 0,
8629     CXX11_gnu_nothrow = 1,
8630     C23_gnu_nothrow = 2,
8631     Declspec_nothrow = 3,
8632   SpellingNotCalculated = 15
8633 
8634   };
8635 
8636   // Factory methods
8637   static NoThrowAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
8638   static NoThrowAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
8639   static NoThrowAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_nothrow);
8640   static NoThrowAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_nothrow);
8641 
8642   // Constructors
8643   NoThrowAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
8644              );
8645 
8646   NoThrowAttr *clone(ASTContext &C) const;
8647   void printPretty(raw_ostream &OS,
8648                    const PrintingPolicy &Policy) const;
8649   const char *getSpelling() const;
8650 
8651 
8652   static bool classof(const Attr *A) { return A->getKind() == attr::NoThrow; }
8653 };
8654 
8655 class CLANG_ABI NoTrivialAutoVarInitAttr : public InheritableAttr {
8656 public:
8657   // Factory methods
8658   static NoTrivialAutoVarInitAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
8659   static NoTrivialAutoVarInitAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
8660   static NoTrivialAutoVarInitAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {});
8661   static NoTrivialAutoVarInitAttr *Create(ASTContext &Ctx, SourceRange Range = {});
8662 
8663   // Constructors
8664   NoTrivialAutoVarInitAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
8665              );
8666 
8667   NoTrivialAutoVarInitAttr *clone(ASTContext &C) const;
8668   void printPretty(raw_ostream &OS,
8669                    const PrintingPolicy &Policy) const;
8670   const char *getSpelling() const;
8671 
8672 
8673   static bool classof(const Attr *A) { return A->getKind() == attr::NoTrivialAutoVarInit; }
8674 };
8675 
8676 class CLANG_ABI NoUniqueAddressAttr : public InheritableAttr {
8677 public:
8678   enum Spelling {
8679     CXX11_no_unique_address = 0,
8680     CXX11_msvc_no_unique_address = 1,
8681   SpellingNotCalculated = 15
8682 
8683   };
8684 
8685   // Factory methods
8686   static NoUniqueAddressAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
8687   static NoUniqueAddressAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
8688   static NoUniqueAddressAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = CXX11_no_unique_address);
8689   static NoUniqueAddressAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = CXX11_no_unique_address);
8690 
8691   // Constructors
8692   NoUniqueAddressAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
8693              );
8694 
8695   NoUniqueAddressAttr *clone(ASTContext &C) const;
8696   void printPretty(raw_ostream &OS,
8697                    const PrintingPolicy &Policy) const;
8698   const char *getSpelling() const;
8699 
8700 
8701   static bool classof(const Attr *A) { return A->getKind() == attr::NoUniqueAddress; }
8702 };
8703 
8704 class CLANG_ABI NoUwtableAttr : public InheritableAttr {
8705 public:
8706   enum Spelling {
8707     GNU_nouwtable = 0,
8708     CXX11_clang_nouwtable = 1,
8709     C23_clang_nouwtable = 2,
8710   SpellingNotCalculated = 15
8711 
8712   };
8713 
8714   // Factory methods
8715   static NoUwtableAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
8716   static NoUwtableAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
8717   static NoUwtableAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_nouwtable);
8718   static NoUwtableAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_nouwtable);
8719 
8720   // Constructors
8721   NoUwtableAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
8722              );
8723 
8724   NoUwtableAttr *clone(ASTContext &C) const;
8725   void printPretty(raw_ostream &OS,
8726                    const PrintingPolicy &Policy) const;
8727   const char *getSpelling() const;
8728 
8729 
8730   static bool classof(const Attr *A) { return A->getKind() == attr::NoUwtable; }
8731 };
8732 
8733 class CLANG_ABI NonAllocatingAttr : public TypeAttr {
8734 Expr * cond;
8735 
8736 public:
8737   enum Spelling {
8738     GNU_nonallocating = 0,
8739     CXX11_clang_nonallocating = 1,
8740     C23_clang_nonallocating = 2,
8741   SpellingNotCalculated = 15
8742 
8743   };
8744 
8745   // Factory methods
8746   static NonAllocatingAttr *CreateImplicit(ASTContext &Ctx, Expr * Cond, const AttributeCommonInfo &CommonInfo);
8747   static NonAllocatingAttr *Create(ASTContext &Ctx, Expr * Cond, const AttributeCommonInfo &CommonInfo);
8748   static NonAllocatingAttr *CreateImplicit(ASTContext &Ctx, Expr * Cond, SourceRange Range = {}, Spelling S = GNU_nonallocating);
8749   static NonAllocatingAttr *Create(ASTContext &Ctx, Expr * Cond, SourceRange Range = {}, Spelling S = GNU_nonallocating);
8750 
8751   // Constructors
8752   NonAllocatingAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
8753               , Expr * Cond
8754              );
8755   NonAllocatingAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
8756              );
8757 
8758   NonAllocatingAttr *clone(ASTContext &C) const;
8759   void printPretty(raw_ostream &OS,
8760                    const PrintingPolicy &Policy) const;
8761   const char *getSpelling() const;
8762   Expr * getCond() const {
8763     return cond;
8764   }
8765 
8766 
8767 
8768   static bool classof(const Attr *A) { return A->getKind() == attr::NonAllocating; }
8769 };
8770 
8771 class CLANG_ABI NonBlockingAttr : public TypeAttr {
8772 Expr * cond;
8773 
8774 public:
8775   enum Spelling {
8776     GNU_nonblocking = 0,
8777     CXX11_clang_nonblocking = 1,
8778     C23_clang_nonblocking = 2,
8779   SpellingNotCalculated = 15
8780 
8781   };
8782 
8783   // Factory methods
8784   static NonBlockingAttr *CreateImplicit(ASTContext &Ctx, Expr * Cond, const AttributeCommonInfo &CommonInfo);
8785   static NonBlockingAttr *Create(ASTContext &Ctx, Expr * Cond, const AttributeCommonInfo &CommonInfo);
8786   static NonBlockingAttr *CreateImplicit(ASTContext &Ctx, Expr * Cond, SourceRange Range = {}, Spelling S = GNU_nonblocking);
8787   static NonBlockingAttr *Create(ASTContext &Ctx, Expr * Cond, SourceRange Range = {}, Spelling S = GNU_nonblocking);
8788 
8789   // Constructors
8790   NonBlockingAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
8791               , Expr * Cond
8792              );
8793   NonBlockingAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
8794              );
8795 
8796   NonBlockingAttr *clone(ASTContext &C) const;
8797   void printPretty(raw_ostream &OS,
8798                    const PrintingPolicy &Policy) const;
8799   const char *getSpelling() const;
8800   Expr * getCond() const {
8801     return cond;
8802   }
8803 
8804 
8805 
8806   static bool classof(const Attr *A) { return A->getKind() == attr::NonBlocking; }
8807 };
8808 
8809 class CLANG_ABI NonNullAttr : public InheritableParamAttr {
8810   unsigned args_Size;
8811   ParamIdx *args_;
8812 
8813 public:
8814   enum Spelling {
8815     GNU_nonnull = 0,
8816     CXX11_gnu_nonnull = 1,
8817     C23_gnu_nonnull = 2,
8818   SpellingNotCalculated = 15
8819 
8820   };
8821 
8822   // Factory methods
8823   static NonNullAttr *CreateImplicit(ASTContext &Ctx, ParamIdx *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo);
8824   static NonNullAttr *Create(ASTContext &Ctx, ParamIdx *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo);
8825   static NonNullAttr *CreateImplicit(ASTContext &Ctx, ParamIdx *Args, unsigned ArgsSize, SourceRange Range = {}, Spelling S = GNU_nonnull);
8826   static NonNullAttr *Create(ASTContext &Ctx, ParamIdx *Args, unsigned ArgsSize, SourceRange Range = {}, Spelling S = GNU_nonnull);
8827 
8828   // Constructors
8829   NonNullAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
8830               , ParamIdx *Args, unsigned ArgsSize
8831              );
8832   NonNullAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
8833              );
8834 
8835   NonNullAttr *clone(ASTContext &C) const;
8836   void printPretty(raw_ostream &OS,
8837                    const PrintingPolicy &Policy) const;
8838   const char *getSpelling() const;
8839   typedef ParamIdx* args_iterator;
8840   args_iterator args_begin() const { return args_; }
8841   args_iterator args_end() const { return args_ + args_Size; }
8842   unsigned args_size() const { return args_Size; }
8843   llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }
8844 
8845 
8846 
8847     bool isNonNull(unsigned IdxAST) const {
8848       if (!args_size())
8849         return true;
8850       return llvm::any_of(args(), [=](const ParamIdx &Idx) {
8851         return Idx.getASTIndex() == IdxAST;
8852       });
8853     }
8854   
8855 
8856   static bool classof(const Attr *A) { return A->getKind() == attr::NonNull; }
8857 };
8858 
8859 class CLANG_ABI NotTailCalledAttr : public InheritableAttr {
8860 public:
8861   enum Spelling {
8862     GNU_not_tail_called = 0,
8863     CXX11_clang_not_tail_called = 1,
8864     C23_clang_not_tail_called = 2,
8865   SpellingNotCalculated = 15
8866 
8867   };
8868 
8869   // Factory methods
8870   static NotTailCalledAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
8871   static NotTailCalledAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
8872   static NotTailCalledAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_not_tail_called);
8873   static NotTailCalledAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_not_tail_called);
8874 
8875   // Constructors
8876   NotTailCalledAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
8877              );
8878 
8879   NotTailCalledAttr *clone(ASTContext &C) const;
8880   void printPretty(raw_ostream &OS,
8881                    const PrintingPolicy &Policy) const;
8882   const char *getSpelling() const;
8883 
8884 
8885   static bool classof(const Attr *A) { return A->getKind() == attr::NotTailCalled; }
8886 };
8887 
8888 class CLANG_ABI OMPAllocateDeclAttr : public InheritableAttr {
8889 public:
8890   enum AllocatorTypeTy {
8891     OMPNullMemAlloc,
8892     OMPDefaultMemAlloc,
8893     OMPLargeCapMemAlloc,
8894     OMPConstMemAlloc,
8895     OMPHighBWMemAlloc,
8896     OMPLowLatMemAlloc,
8897     OMPCGroupMemAlloc,
8898     OMPPTeamMemAlloc,
8899     OMPThreadMemAlloc,
8900     OMPUserDefinedMemAlloc
8901   };
8902 private:
8903   OMPAllocateDeclAttr::AllocatorTypeTy allocatorType;
8904 
8905 Expr * allocator;
8906 
8907 Expr * alignment;
8908 
8909 public:
8910   // Factory methods
8911   static OMPAllocateDeclAttr *CreateImplicit(ASTContext &Ctx, OMPAllocateDeclAttr::AllocatorTypeTy AllocatorType, Expr * Allocator, Expr * Alignment, const AttributeCommonInfo &CommonInfo);
8912   static OMPAllocateDeclAttr *Create(ASTContext &Ctx, OMPAllocateDeclAttr::AllocatorTypeTy AllocatorType, Expr * Allocator, Expr * Alignment, const AttributeCommonInfo &CommonInfo);
8913   static OMPAllocateDeclAttr *CreateImplicit(ASTContext &Ctx, OMPAllocateDeclAttr::AllocatorTypeTy AllocatorType, Expr * Allocator, Expr * Alignment, SourceRange Range = {});
8914   static OMPAllocateDeclAttr *Create(ASTContext &Ctx, OMPAllocateDeclAttr::AllocatorTypeTy AllocatorType, Expr * Allocator, Expr * Alignment, SourceRange Range = {});
8915 
8916   // Constructors
8917   OMPAllocateDeclAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
8918               , OMPAllocateDeclAttr::AllocatorTypeTy AllocatorType
8919               , Expr * Allocator
8920               , Expr * Alignment
8921              );
8922 
8923   OMPAllocateDeclAttr *clone(ASTContext &C) const;
8924   void printPretty(raw_ostream &OS,
8925                    const PrintingPolicy &Policy) const;
8926   const char *getSpelling() const;
8927   OMPAllocateDeclAttr::AllocatorTypeTy getAllocatorType() const {
8928     return allocatorType;
8929   }
8930 
8931   static bool ConvertStrToAllocatorTypeTy(StringRef Val, OMPAllocateDeclAttr::AllocatorTypeTy &Out);
8932   static const char *ConvertAllocatorTypeTyToStr(OMPAllocateDeclAttr::AllocatorTypeTy Val);
8933   Expr * getAllocator() const {
8934     return allocator;
8935   }
8936 
8937   Expr * getAlignment() const {
8938     return alignment;
8939   }
8940 
8941 
8942 
8943   static bool classof(const Attr *A) { return A->getKind() == attr::OMPAllocateDecl; }
8944 };
8945 
8946 class CLANG_ABI OMPAssumeAttr : public InheritableAttr {
8947 unsigned assumptionLength;
8948 char *assumption;
8949 
8950 public:
8951   // Factory methods
8952   static OMPAssumeAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Assumption, const AttributeCommonInfo &CommonInfo);
8953   static OMPAssumeAttr *Create(ASTContext &Ctx, llvm::StringRef Assumption, const AttributeCommonInfo &CommonInfo);
8954   static OMPAssumeAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Assumption, SourceRange Range = {});
8955   static OMPAssumeAttr *Create(ASTContext &Ctx, llvm::StringRef Assumption, SourceRange Range = {});
8956 
8957   // Constructors
8958   OMPAssumeAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
8959               , llvm::StringRef Assumption
8960              );
8961 
8962   OMPAssumeAttr *clone(ASTContext &C) const;
8963   void printPretty(raw_ostream &OS,
8964                    const PrintingPolicy &Policy) const;
8965   const char *getSpelling() const;
8966   llvm::StringRef getAssumption() const {
8967     return llvm::StringRef(assumption, assumptionLength);
8968   }
8969   unsigned getAssumptionLength() const {
8970     return assumptionLength;
8971   }
8972   void setAssumption(ASTContext &C, llvm::StringRef S) {
8973     assumptionLength = S.size();
8974     this->assumption = new (C, 1) char [assumptionLength];
8975     if (!S.empty())
8976       std::memcpy(this->assumption, S.data(), assumptionLength);
8977   }
8978 
8979 
8980 
8981   static bool classof(const Attr *A) { return A->getKind() == attr::OMPAssume; }
8982 };
8983 
8984 class CLANG_ABI OMPCaptureKindAttr : public Attr {
8985 unsigned captureKindVal;
8986 
8987 public:
8988   // Factory methods
8989   static OMPCaptureKindAttr *CreateImplicit(ASTContext &Ctx, unsigned CaptureKindVal, const AttributeCommonInfo &CommonInfo);
8990   static OMPCaptureKindAttr *Create(ASTContext &Ctx, unsigned CaptureKindVal, const AttributeCommonInfo &CommonInfo);
8991   static OMPCaptureKindAttr *CreateImplicit(ASTContext &Ctx, unsigned CaptureKindVal, SourceRange Range = {});
8992   static OMPCaptureKindAttr *Create(ASTContext &Ctx, unsigned CaptureKindVal, SourceRange Range = {});
8993 
8994   // Constructors
8995   OMPCaptureKindAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
8996               , unsigned CaptureKindVal
8997              );
8998 
8999   OMPCaptureKindAttr *clone(ASTContext &C) const;
9000   void printPretty(raw_ostream &OS,
9001                    const PrintingPolicy &Policy) const;
9002   const char *getSpelling() const;
9003   unsigned getCaptureKindVal() const {
9004     return captureKindVal;
9005   }
9006 
9007 
9008     llvm::omp::Clause getCaptureKind() const {
9009       return static_cast<llvm::omp::Clause>(getCaptureKindVal());
9010     }
9011   
9012 
9013   static bool classof(const Attr *A) { return A->getKind() == attr::OMPCaptureKind; }
9014 };
9015 
9016 class CLANG_ABI OMPCaptureNoInitAttr : public InheritableAttr {
9017 public:
9018   // Factory methods
9019   static OMPCaptureNoInitAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
9020   static OMPCaptureNoInitAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
9021   static OMPCaptureNoInitAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {});
9022   static OMPCaptureNoInitAttr *Create(ASTContext &Ctx, SourceRange Range = {});
9023 
9024   // Constructors
9025   OMPCaptureNoInitAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
9026              );
9027 
9028   OMPCaptureNoInitAttr *clone(ASTContext &C) const;
9029   void printPretty(raw_ostream &OS,
9030                    const PrintingPolicy &Policy) const;
9031   const char *getSpelling() const;
9032 
9033 
9034   static bool classof(const Attr *A) { return A->getKind() == attr::OMPCaptureNoInit; }
9035 };
9036 
9037 class CLANG_ABI OMPDeclareSimdDeclAttr : public Attr {
9038 public:
9039   enum BranchStateTy {
9040     BS_Undefined,
9041     BS_Inbranch,
9042     BS_Notinbranch
9043   };
9044 private:
9045   OMPDeclareSimdDeclAttr::BranchStateTy branchState;
9046 
9047 Expr * simdlen;
9048 
9049   unsigned uniforms_Size;
9050   Expr * *uniforms_;
9051 
9052   unsigned aligneds_Size;
9053   Expr * *aligneds_;
9054 
9055   unsigned alignments_Size;
9056   Expr * *alignments_;
9057 
9058   unsigned linears_Size;
9059   Expr * *linears_;
9060 
9061   unsigned modifiers_Size;
9062   unsigned *modifiers_;
9063 
9064   unsigned steps_Size;
9065   Expr * *steps_;
9066 
9067 public:
9068   // Factory methods
9069   static OMPDeclareSimdDeclAttr *CreateImplicit(ASTContext &Ctx, OMPDeclareSimdDeclAttr::BranchStateTy BranchState, Expr * Simdlen, Expr * *Uniforms, unsigned UniformsSize, Expr * *Aligneds, unsigned AlignedsSize, Expr * *Alignments, unsigned AlignmentsSize, Expr * *Linears, unsigned LinearsSize, unsigned *Modifiers, unsigned ModifiersSize, Expr * *Steps, unsigned StepsSize, const AttributeCommonInfo &CommonInfo);
9070   static OMPDeclareSimdDeclAttr *Create(ASTContext &Ctx, OMPDeclareSimdDeclAttr::BranchStateTy BranchState, Expr * Simdlen, Expr * *Uniforms, unsigned UniformsSize, Expr * *Aligneds, unsigned AlignedsSize, Expr * *Alignments, unsigned AlignmentsSize, Expr * *Linears, unsigned LinearsSize, unsigned *Modifiers, unsigned ModifiersSize, Expr * *Steps, unsigned StepsSize, const AttributeCommonInfo &CommonInfo);
9071   static OMPDeclareSimdDeclAttr *CreateImplicit(ASTContext &Ctx, OMPDeclareSimdDeclAttr::BranchStateTy BranchState, Expr * Simdlen, Expr * *Uniforms, unsigned UniformsSize, Expr * *Aligneds, unsigned AlignedsSize, Expr * *Alignments, unsigned AlignmentsSize, Expr * *Linears, unsigned LinearsSize, unsigned *Modifiers, unsigned ModifiersSize, Expr * *Steps, unsigned StepsSize, SourceRange Range = {});
9072   static OMPDeclareSimdDeclAttr *Create(ASTContext &Ctx, OMPDeclareSimdDeclAttr::BranchStateTy BranchState, Expr * Simdlen, Expr * *Uniforms, unsigned UniformsSize, Expr * *Aligneds, unsigned AlignedsSize, Expr * *Alignments, unsigned AlignmentsSize, Expr * *Linears, unsigned LinearsSize, unsigned *Modifiers, unsigned ModifiersSize, Expr * *Steps, unsigned StepsSize, SourceRange Range = {});
9073 
9074   // Constructors
9075   OMPDeclareSimdDeclAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
9076               , OMPDeclareSimdDeclAttr::BranchStateTy BranchState
9077               , Expr * Simdlen
9078               , Expr * *Uniforms, unsigned UniformsSize
9079               , Expr * *Aligneds, unsigned AlignedsSize
9080               , Expr * *Alignments, unsigned AlignmentsSize
9081               , Expr * *Linears, unsigned LinearsSize
9082               , unsigned *Modifiers, unsigned ModifiersSize
9083               , Expr * *Steps, unsigned StepsSize
9084              );
9085   OMPDeclareSimdDeclAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
9086               , OMPDeclareSimdDeclAttr::BranchStateTy BranchState
9087               , Expr * Simdlen
9088              );
9089 
9090   OMPDeclareSimdDeclAttr *clone(ASTContext &C) const;
9091   void printPretty(raw_ostream &OS,
9092                    const PrintingPolicy &Policy) const;
9093   const char *getSpelling() const;
9094   OMPDeclareSimdDeclAttr::BranchStateTy getBranchState() const {
9095     return branchState;
9096   }
9097 
9098   static bool ConvertStrToBranchStateTy(StringRef Val, OMPDeclareSimdDeclAttr::BranchStateTy &Out);
9099   static const char *ConvertBranchStateTyToStr(OMPDeclareSimdDeclAttr::BranchStateTy Val);
9100   Expr * getSimdlen() const {
9101     return simdlen;
9102   }
9103 
9104   typedef Expr ** uniforms_iterator;
9105   uniforms_iterator uniforms_begin() const { return uniforms_; }
9106   uniforms_iterator uniforms_end() const { return uniforms_ + uniforms_Size; }
9107   unsigned uniforms_size() const { return uniforms_Size; }
9108   llvm::iterator_range<uniforms_iterator> uniforms() const { return llvm::make_range(uniforms_begin(), uniforms_end()); }
9109 
9110 
9111   typedef Expr ** aligneds_iterator;
9112   aligneds_iterator aligneds_begin() const { return aligneds_; }
9113   aligneds_iterator aligneds_end() const { return aligneds_ + aligneds_Size; }
9114   unsigned aligneds_size() const { return aligneds_Size; }
9115   llvm::iterator_range<aligneds_iterator> aligneds() const { return llvm::make_range(aligneds_begin(), aligneds_end()); }
9116 
9117 
9118   typedef Expr ** alignments_iterator;
9119   alignments_iterator alignments_begin() const { return alignments_; }
9120   alignments_iterator alignments_end() const { return alignments_ + alignments_Size; }
9121   unsigned alignments_size() const { return alignments_Size; }
9122   llvm::iterator_range<alignments_iterator> alignments() const { return llvm::make_range(alignments_begin(), alignments_end()); }
9123 
9124 
9125   typedef Expr ** linears_iterator;
9126   linears_iterator linears_begin() const { return linears_; }
9127   linears_iterator linears_end() const { return linears_ + linears_Size; }
9128   unsigned linears_size() const { return linears_Size; }
9129   llvm::iterator_range<linears_iterator> linears() const { return llvm::make_range(linears_begin(), linears_end()); }
9130 
9131 
9132   typedef unsigned* modifiers_iterator;
9133   modifiers_iterator modifiers_begin() const { return modifiers_; }
9134   modifiers_iterator modifiers_end() const { return modifiers_ + modifiers_Size; }
9135   unsigned modifiers_size() const { return modifiers_Size; }
9136   llvm::iterator_range<modifiers_iterator> modifiers() const { return llvm::make_range(modifiers_begin(), modifiers_end()); }
9137 
9138 
9139   typedef Expr ** steps_iterator;
9140   steps_iterator steps_begin() const { return steps_; }
9141   steps_iterator steps_end() const { return steps_ + steps_Size; }
9142   unsigned steps_size() const { return steps_Size; }
9143   llvm::iterator_range<steps_iterator> steps() const { return llvm::make_range(steps_begin(), steps_end()); }
9144 
9145 
9146 
9147     void printPrettyPragma(raw_ostream & OS, const PrintingPolicy &Policy)
9148         const;
9149   
9150 
9151   static bool classof(const Attr *A) { return A->getKind() == attr::OMPDeclareSimdDecl; }
9152 };
9153 
9154 class CLANG_ABI OMPDeclareTargetDeclAttr : public InheritableAttr {
9155 public:
9156   enum MapTypeTy {
9157     MT_To,
9158     MT_Enter,
9159     MT_Link
9160   };
9161 private:
9162   OMPDeclareTargetDeclAttr::MapTypeTy mapType;
9163 
9164 public:
9165   enum DevTypeTy {
9166     DT_Host,
9167     DT_NoHost,
9168     DT_Any
9169   };
9170 private:
9171   OMPDeclareTargetDeclAttr::DevTypeTy devType;
9172 
9173 Expr * indirectExpr;
9174 
9175 bool indirect;
9176 
9177 unsigned level;
9178 
9179 public:
9180   // Factory methods
9181   static OMPDeclareTargetDeclAttr *CreateImplicit(ASTContext &Ctx, OMPDeclareTargetDeclAttr::MapTypeTy MapType, OMPDeclareTargetDeclAttr::DevTypeTy DevType, Expr * IndirectExpr, bool Indirect, unsigned Level, const AttributeCommonInfo &CommonInfo);
9182   static OMPDeclareTargetDeclAttr *Create(ASTContext &Ctx, OMPDeclareTargetDeclAttr::MapTypeTy MapType, OMPDeclareTargetDeclAttr::DevTypeTy DevType, Expr * IndirectExpr, bool Indirect, unsigned Level, const AttributeCommonInfo &CommonInfo);
9183   static OMPDeclareTargetDeclAttr *CreateImplicit(ASTContext &Ctx, OMPDeclareTargetDeclAttr::MapTypeTy MapType, OMPDeclareTargetDeclAttr::DevTypeTy DevType, Expr * IndirectExpr, bool Indirect, unsigned Level, SourceRange Range = {});
9184   static OMPDeclareTargetDeclAttr *Create(ASTContext &Ctx, OMPDeclareTargetDeclAttr::MapTypeTy MapType, OMPDeclareTargetDeclAttr::DevTypeTy DevType, Expr * IndirectExpr, bool Indirect, unsigned Level, SourceRange Range = {});
9185 
9186   // Constructors
9187   OMPDeclareTargetDeclAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
9188               , OMPDeclareTargetDeclAttr::MapTypeTy MapType
9189               , OMPDeclareTargetDeclAttr::DevTypeTy DevType
9190               , Expr * IndirectExpr
9191               , bool Indirect
9192               , unsigned Level
9193              );
9194 
9195   OMPDeclareTargetDeclAttr *clone(ASTContext &C) const;
9196   void printPretty(raw_ostream &OS,
9197                    const PrintingPolicy &Policy) const;
9198   const char *getSpelling() const;
9199   OMPDeclareTargetDeclAttr::MapTypeTy getMapType() const {
9200     return mapType;
9201   }
9202 
9203   static bool ConvertStrToMapTypeTy(StringRef Val, OMPDeclareTargetDeclAttr::MapTypeTy &Out);
9204   static const char *ConvertMapTypeTyToStr(OMPDeclareTargetDeclAttr::MapTypeTy Val);
9205   OMPDeclareTargetDeclAttr::DevTypeTy getDevType() const {
9206     return devType;
9207   }
9208 
9209   static bool ConvertStrToDevTypeTy(StringRef Val, OMPDeclareTargetDeclAttr::DevTypeTy &Out);
9210   static const char *ConvertDevTypeTyToStr(OMPDeclareTargetDeclAttr::DevTypeTy Val);
9211   Expr * getIndirectExpr() const {
9212     return indirectExpr;
9213   }
9214 
9215   bool getIndirect() const {
9216     return indirect;
9217   }
9218 
9219   unsigned getLevel() const {
9220     return level;
9221   }
9222 
9223 
9224     void printPrettyPragma(raw_ostream &OS, const PrintingPolicy &Policy) const;
9225     static std::optional<MapTypeTy>
9226     isDeclareTargetDeclaration(const ValueDecl *VD);
9227     static std::optional<OMPDeclareTargetDeclAttr*> getActiveAttr(const ValueDecl *VD);
9228     static std::optional<DevTypeTy> getDeviceType(const ValueDecl *VD);
9229     static std::optional<SourceLocation> getLocation(const ValueDecl *VD);
9230   
9231 
9232   static bool classof(const Attr *A) { return A->getKind() == attr::OMPDeclareTargetDecl; }
9233 };
9234 
9235 class CLANG_ABI OMPDeclareVariantAttr : public InheritableAttr {
9236 Expr * variantFuncRef;
9237 
9238 OMPTraitInfo * traitInfos;
9239 
9240   unsigned adjustArgsNothing_Size;
9241   Expr * *adjustArgsNothing_;
9242 
9243   unsigned adjustArgsNeedDevicePtr_Size;
9244   Expr * *adjustArgsNeedDevicePtr_;
9245 
9246   unsigned appendArgs_Size;
9247   OMPInteropInfo *appendArgs_;
9248 
9249 public:
9250   // Factory methods
9251   static OMPDeclareVariantAttr *CreateImplicit(ASTContext &Ctx, Expr * VariantFuncRef, OMPTraitInfo * TraitInfos, Expr * *AdjustArgsNothing, unsigned AdjustArgsNothingSize, Expr * *AdjustArgsNeedDevicePtr, unsigned AdjustArgsNeedDevicePtrSize, OMPInteropInfo *AppendArgs, unsigned AppendArgsSize, const AttributeCommonInfo &CommonInfo);
9252   static OMPDeclareVariantAttr *Create(ASTContext &Ctx, Expr * VariantFuncRef, OMPTraitInfo * TraitInfos, Expr * *AdjustArgsNothing, unsigned AdjustArgsNothingSize, Expr * *AdjustArgsNeedDevicePtr, unsigned AdjustArgsNeedDevicePtrSize, OMPInteropInfo *AppendArgs, unsigned AppendArgsSize, const AttributeCommonInfo &CommonInfo);
9253   static OMPDeclareVariantAttr *CreateImplicit(ASTContext &Ctx, Expr * VariantFuncRef, OMPTraitInfo * TraitInfos, Expr * *AdjustArgsNothing, unsigned AdjustArgsNothingSize, Expr * *AdjustArgsNeedDevicePtr, unsigned AdjustArgsNeedDevicePtrSize, OMPInteropInfo *AppendArgs, unsigned AppendArgsSize, SourceRange Range = {});
9254   static OMPDeclareVariantAttr *Create(ASTContext &Ctx, Expr * VariantFuncRef, OMPTraitInfo * TraitInfos, Expr * *AdjustArgsNothing, unsigned AdjustArgsNothingSize, Expr * *AdjustArgsNeedDevicePtr, unsigned AdjustArgsNeedDevicePtrSize, OMPInteropInfo *AppendArgs, unsigned AppendArgsSize, SourceRange Range = {});
9255 
9256   // Constructors
9257   OMPDeclareVariantAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
9258               , Expr * VariantFuncRef
9259               , OMPTraitInfo * TraitInfos
9260               , Expr * *AdjustArgsNothing, unsigned AdjustArgsNothingSize
9261               , Expr * *AdjustArgsNeedDevicePtr, unsigned AdjustArgsNeedDevicePtrSize
9262               , OMPInteropInfo *AppendArgs, unsigned AppendArgsSize
9263              );
9264   OMPDeclareVariantAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
9265               , Expr * VariantFuncRef
9266               , OMPTraitInfo * TraitInfos
9267               , OMPInteropInfo *AppendArgs, unsigned AppendArgsSize
9268              );
9269 
9270   OMPDeclareVariantAttr *clone(ASTContext &C) const;
9271   void printPretty(raw_ostream &OS,
9272                    const PrintingPolicy &Policy) const;
9273   const char *getSpelling() const;
9274   Expr * getVariantFuncRef() const {
9275     return variantFuncRef;
9276   }
9277 
9278   OMPTraitInfo * getTraitInfos() const {
9279     return traitInfos;
9280   }
9281 
9282   typedef Expr ** adjustArgsNothing_iterator;
9283   adjustArgsNothing_iterator adjustArgsNothing_begin() const { return adjustArgsNothing_; }
9284   adjustArgsNothing_iterator adjustArgsNothing_end() const { return adjustArgsNothing_ + adjustArgsNothing_Size; }
9285   unsigned adjustArgsNothing_size() const { return adjustArgsNothing_Size; }
9286   llvm::iterator_range<adjustArgsNothing_iterator> adjustArgsNothing() const { return llvm::make_range(adjustArgsNothing_begin(), adjustArgsNothing_end()); }
9287 
9288 
9289   typedef Expr ** adjustArgsNeedDevicePtr_iterator;
9290   adjustArgsNeedDevicePtr_iterator adjustArgsNeedDevicePtr_begin() const { return adjustArgsNeedDevicePtr_; }
9291   adjustArgsNeedDevicePtr_iterator adjustArgsNeedDevicePtr_end() const { return adjustArgsNeedDevicePtr_ + adjustArgsNeedDevicePtr_Size; }
9292   unsigned adjustArgsNeedDevicePtr_size() const { return adjustArgsNeedDevicePtr_Size; }
9293   llvm::iterator_range<adjustArgsNeedDevicePtr_iterator> adjustArgsNeedDevicePtr() const { return llvm::make_range(adjustArgsNeedDevicePtr_begin(), adjustArgsNeedDevicePtr_end()); }
9294 
9295 
9296   typedef OMPInteropInfo* appendArgs_iterator;
9297   appendArgs_iterator appendArgs_begin() const { return appendArgs_; }
9298   appendArgs_iterator appendArgs_end() const { return appendArgs_ + appendArgs_Size; }
9299   unsigned appendArgs_size() const { return appendArgs_Size; }
9300   llvm::iterator_range<appendArgs_iterator> appendArgs() const { return llvm::make_range(appendArgs_begin(), appendArgs_end()); }
9301 
9302 
9303 
9304     OMPTraitInfo &getTraitInfo() { return *traitInfos; }
9305     void printPrettyPragma(raw_ostream & OS, const PrintingPolicy &Policy)
9306         const;
9307     static StringRef getInteropTypeString(const OMPInteropInfo *I) {
9308       if (I->IsTarget && I->IsTargetSync)
9309         return "target,targetsync";
9310       if (I->IsTarget)
9311         return "target";
9312       return "targetsync";
9313     }
9314   
9315 
9316   static bool classof(const Attr *A) { return A->getKind() == attr::OMPDeclareVariant; }
9317 };
9318 
9319 class CLANG_ABI OMPReferencedVarAttr : public Attr {
9320 Expr * ref;
9321 
9322 public:
9323   // Factory methods
9324   static OMPReferencedVarAttr *CreateImplicit(ASTContext &Ctx, Expr * Ref, const AttributeCommonInfo &CommonInfo);
9325   static OMPReferencedVarAttr *Create(ASTContext &Ctx, Expr * Ref, const AttributeCommonInfo &CommonInfo);
9326   static OMPReferencedVarAttr *CreateImplicit(ASTContext &Ctx, Expr * Ref, SourceRange Range = {});
9327   static OMPReferencedVarAttr *Create(ASTContext &Ctx, Expr * Ref, SourceRange Range = {});
9328 
9329   // Constructors
9330   OMPReferencedVarAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
9331               , Expr * Ref
9332              );
9333 
9334   OMPReferencedVarAttr *clone(ASTContext &C) const;
9335   void printPretty(raw_ostream &OS,
9336                    const PrintingPolicy &Policy) const;
9337   const char *getSpelling() const;
9338   Expr * getRef() const {
9339     return ref;
9340   }
9341 
9342 
9343 
9344   static bool classof(const Attr *A) { return A->getKind() == attr::OMPReferencedVar; }
9345 };
9346 
9347 class CLANG_ABI OMPThreadPrivateDeclAttr : public InheritableAttr {
9348 public:
9349   // Factory methods
9350   static OMPThreadPrivateDeclAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
9351   static OMPThreadPrivateDeclAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
9352   static OMPThreadPrivateDeclAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {});
9353   static OMPThreadPrivateDeclAttr *Create(ASTContext &Ctx, SourceRange Range = {});
9354 
9355   // Constructors
9356   OMPThreadPrivateDeclAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
9357              );
9358 
9359   OMPThreadPrivateDeclAttr *clone(ASTContext &C) const;
9360   void printPretty(raw_ostream &OS,
9361                    const PrintingPolicy &Policy) const;
9362   const char *getSpelling() const;
9363 
9364 
9365   static bool classof(const Attr *A) { return A->getKind() == attr::OMPThreadPrivateDecl; }
9366 };
9367 
9368 class CLANG_ABI OSConsumedAttr : public InheritableParamAttr {
9369 public:
9370   enum Spelling {
9371     GNU_os_consumed = 0,
9372     CXX11_clang_os_consumed = 1,
9373     C23_clang_os_consumed = 2,
9374   SpellingNotCalculated = 15
9375 
9376   };
9377 
9378   // Factory methods
9379   static OSConsumedAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
9380   static OSConsumedAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
9381   static OSConsumedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_os_consumed);
9382   static OSConsumedAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_os_consumed);
9383 
9384   // Constructors
9385   OSConsumedAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
9386              );
9387 
9388   OSConsumedAttr *clone(ASTContext &C) const;
9389   void printPretty(raw_ostream &OS,
9390                    const PrintingPolicy &Policy) const;
9391   const char *getSpelling() const;
9392 
9393 
9394   static bool classof(const Attr *A) { return A->getKind() == attr::OSConsumed; }
9395 };
9396 
9397 class CLANG_ABI OSConsumesThisAttr : public InheritableAttr {
9398 public:
9399   enum Spelling {
9400     GNU_os_consumes_this = 0,
9401     CXX11_clang_os_consumes_this = 1,
9402     C23_clang_os_consumes_this = 2,
9403   SpellingNotCalculated = 15
9404 
9405   };
9406 
9407   // Factory methods
9408   static OSConsumesThisAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
9409   static OSConsumesThisAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
9410   static OSConsumesThisAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_os_consumes_this);
9411   static OSConsumesThisAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_os_consumes_this);
9412 
9413   // Constructors
9414   OSConsumesThisAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
9415              );
9416 
9417   OSConsumesThisAttr *clone(ASTContext &C) const;
9418   void printPretty(raw_ostream &OS,
9419                    const PrintingPolicy &Policy) const;
9420   const char *getSpelling() const;
9421 
9422 
9423   static bool classof(const Attr *A) { return A->getKind() == attr::OSConsumesThis; }
9424 };
9425 
9426 class CLANG_ABI OSReturnsNotRetainedAttr : public InheritableAttr {
9427 public:
9428   enum Spelling {
9429     GNU_os_returns_not_retained = 0,
9430     CXX11_clang_os_returns_not_retained = 1,
9431     C23_clang_os_returns_not_retained = 2,
9432   SpellingNotCalculated = 15
9433 
9434   };
9435 
9436   // Factory methods
9437   static OSReturnsNotRetainedAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
9438   static OSReturnsNotRetainedAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
9439   static OSReturnsNotRetainedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_os_returns_not_retained);
9440   static OSReturnsNotRetainedAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_os_returns_not_retained);
9441 
9442   // Constructors
9443   OSReturnsNotRetainedAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
9444              );
9445 
9446   OSReturnsNotRetainedAttr *clone(ASTContext &C) const;
9447   void printPretty(raw_ostream &OS,
9448                    const PrintingPolicy &Policy) const;
9449   const char *getSpelling() const;
9450 
9451 
9452   static bool classof(const Attr *A) { return A->getKind() == attr::OSReturnsNotRetained; }
9453 };
9454 
9455 class CLANG_ABI OSReturnsRetainedAttr : public InheritableAttr {
9456 public:
9457   enum Spelling {
9458     GNU_os_returns_retained = 0,
9459     CXX11_clang_os_returns_retained = 1,
9460     C23_clang_os_returns_retained = 2,
9461   SpellingNotCalculated = 15
9462 
9463   };
9464 
9465   // Factory methods
9466   static OSReturnsRetainedAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
9467   static OSReturnsRetainedAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
9468   static OSReturnsRetainedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_os_returns_retained);
9469   static OSReturnsRetainedAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_os_returns_retained);
9470 
9471   // Constructors
9472   OSReturnsRetainedAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
9473              );
9474 
9475   OSReturnsRetainedAttr *clone(ASTContext &C) const;
9476   void printPretty(raw_ostream &OS,
9477                    const PrintingPolicy &Policy) const;
9478   const char *getSpelling() const;
9479 
9480 
9481   static bool classof(const Attr *A) { return A->getKind() == attr::OSReturnsRetained; }
9482 };
9483 
9484 class CLANG_ABI OSReturnsRetainedOnNonZeroAttr : public InheritableAttr {
9485 public:
9486   enum Spelling {
9487     GNU_os_returns_retained_on_non_zero = 0,
9488     CXX11_clang_os_returns_retained_on_non_zero = 1,
9489     C23_clang_os_returns_retained_on_non_zero = 2,
9490   SpellingNotCalculated = 15
9491 
9492   };
9493 
9494   // Factory methods
9495   static OSReturnsRetainedOnNonZeroAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
9496   static OSReturnsRetainedOnNonZeroAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
9497   static OSReturnsRetainedOnNonZeroAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_os_returns_retained_on_non_zero);
9498   static OSReturnsRetainedOnNonZeroAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_os_returns_retained_on_non_zero);
9499 
9500   // Constructors
9501   OSReturnsRetainedOnNonZeroAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
9502              );
9503 
9504   OSReturnsRetainedOnNonZeroAttr *clone(ASTContext &C) const;
9505   void printPretty(raw_ostream &OS,
9506                    const PrintingPolicy &Policy) const;
9507   const char *getSpelling() const;
9508 
9509 
9510   static bool classof(const Attr *A) { return A->getKind() == attr::OSReturnsRetainedOnNonZero; }
9511 };
9512 
9513 class CLANG_ABI OSReturnsRetainedOnZeroAttr : public InheritableAttr {
9514 public:
9515   enum Spelling {
9516     GNU_os_returns_retained_on_zero = 0,
9517     CXX11_clang_os_returns_retained_on_zero = 1,
9518     C23_clang_os_returns_retained_on_zero = 2,
9519   SpellingNotCalculated = 15
9520 
9521   };
9522 
9523   // Factory methods
9524   static OSReturnsRetainedOnZeroAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
9525   static OSReturnsRetainedOnZeroAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
9526   static OSReturnsRetainedOnZeroAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_os_returns_retained_on_zero);
9527   static OSReturnsRetainedOnZeroAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_os_returns_retained_on_zero);
9528 
9529   // Constructors
9530   OSReturnsRetainedOnZeroAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
9531              );
9532 
9533   OSReturnsRetainedOnZeroAttr *clone(ASTContext &C) const;
9534   void printPretty(raw_ostream &OS,
9535                    const PrintingPolicy &Policy) const;
9536   const char *getSpelling() const;
9537 
9538 
9539   static bool classof(const Attr *A) { return A->getKind() == attr::OSReturnsRetainedOnZero; }
9540 };
9541 
9542 class CLANG_ABI ObjCBoxableAttr : public Attr {
9543 public:
9544   enum Spelling {
9545     GNU_objc_boxable = 0,
9546     CXX11_clang_objc_boxable = 1,
9547     C23_clang_objc_boxable = 2,
9548   SpellingNotCalculated = 15
9549 
9550   };
9551 
9552   // Factory methods
9553   static ObjCBoxableAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
9554   static ObjCBoxableAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
9555   static ObjCBoxableAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_objc_boxable);
9556   static ObjCBoxableAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_objc_boxable);
9557 
9558   // Constructors
9559   ObjCBoxableAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
9560              );
9561 
9562   ObjCBoxableAttr *clone(ASTContext &C) const;
9563   void printPretty(raw_ostream &OS,
9564                    const PrintingPolicy &Policy) const;
9565   const char *getSpelling() const;
9566 
9567 
9568   static bool classof(const Attr *A) { return A->getKind() == attr::ObjCBoxable; }
9569 };
9570 
9571 class CLANG_ABI ObjCBridgeAttr : public InheritableAttr {
9572 IdentifierInfo * bridgedType;
9573 
9574 public:
9575   enum Spelling {
9576     GNU_objc_bridge = 0,
9577     CXX11_clang_objc_bridge = 1,
9578     C23_clang_objc_bridge = 2,
9579   SpellingNotCalculated = 15
9580 
9581   };
9582 
9583   // Factory methods
9584   static ObjCBridgeAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * BridgedType, const AttributeCommonInfo &CommonInfo);
9585   static ObjCBridgeAttr *Create(ASTContext &Ctx, IdentifierInfo * BridgedType, const AttributeCommonInfo &CommonInfo);
9586   static ObjCBridgeAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * BridgedType, SourceRange Range = {}, Spelling S = GNU_objc_bridge);
9587   static ObjCBridgeAttr *Create(ASTContext &Ctx, IdentifierInfo * BridgedType, SourceRange Range = {}, Spelling S = GNU_objc_bridge);
9588 
9589   // Constructors
9590   ObjCBridgeAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
9591               , IdentifierInfo * BridgedType
9592              );
9593 
9594   ObjCBridgeAttr *clone(ASTContext &C) const;
9595   void printPretty(raw_ostream &OS,
9596                    const PrintingPolicy &Policy) const;
9597   const char *getSpelling() const;
9598   IdentifierInfo * getBridgedType() const {
9599     return bridgedType;
9600   }
9601 
9602 
9603 
9604   static bool classof(const Attr *A) { return A->getKind() == attr::ObjCBridge; }
9605 };
9606 
9607 class CLANG_ABI ObjCBridgeMutableAttr : public InheritableAttr {
9608 IdentifierInfo * bridgedType;
9609 
9610 public:
9611   enum Spelling {
9612     GNU_objc_bridge_mutable = 0,
9613     CXX11_clang_objc_bridge_mutable = 1,
9614     C23_clang_objc_bridge_mutable = 2,
9615   SpellingNotCalculated = 15
9616 
9617   };
9618 
9619   // Factory methods
9620   static ObjCBridgeMutableAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * BridgedType, const AttributeCommonInfo &CommonInfo);
9621   static ObjCBridgeMutableAttr *Create(ASTContext &Ctx, IdentifierInfo * BridgedType, const AttributeCommonInfo &CommonInfo);
9622   static ObjCBridgeMutableAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * BridgedType, SourceRange Range = {}, Spelling S = GNU_objc_bridge_mutable);
9623   static ObjCBridgeMutableAttr *Create(ASTContext &Ctx, IdentifierInfo * BridgedType, SourceRange Range = {}, Spelling S = GNU_objc_bridge_mutable);
9624 
9625   // Constructors
9626   ObjCBridgeMutableAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
9627               , IdentifierInfo * BridgedType
9628              );
9629 
9630   ObjCBridgeMutableAttr *clone(ASTContext &C) const;
9631   void printPretty(raw_ostream &OS,
9632                    const PrintingPolicy &Policy) const;
9633   const char *getSpelling() const;
9634   IdentifierInfo * getBridgedType() const {
9635     return bridgedType;
9636   }
9637 
9638 
9639 
9640   static bool classof(const Attr *A) { return A->getKind() == attr::ObjCBridgeMutable; }
9641 };
9642 
9643 class CLANG_ABI ObjCBridgeRelatedAttr : public InheritableAttr {
9644 IdentifierInfo * relatedClass;
9645 
9646 IdentifierInfo * classMethod;
9647 
9648 IdentifierInfo * instanceMethod;
9649 
9650 public:
9651   enum Spelling {
9652     GNU_objc_bridge_related = 0,
9653     CXX11_clang_objc_bridge_related = 1,
9654     C23_clang_objc_bridge_related = 2,
9655   SpellingNotCalculated = 15
9656 
9657   };
9658 
9659   // Factory methods
9660   static ObjCBridgeRelatedAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * RelatedClass, IdentifierInfo * ClassMethod, IdentifierInfo * InstanceMethod, const AttributeCommonInfo &CommonInfo);
9661   static ObjCBridgeRelatedAttr *Create(ASTContext &Ctx, IdentifierInfo * RelatedClass, IdentifierInfo * ClassMethod, IdentifierInfo * InstanceMethod, const AttributeCommonInfo &CommonInfo);
9662   static ObjCBridgeRelatedAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * RelatedClass, IdentifierInfo * ClassMethod, IdentifierInfo * InstanceMethod, SourceRange Range = {}, Spelling S = GNU_objc_bridge_related);
9663   static ObjCBridgeRelatedAttr *Create(ASTContext &Ctx, IdentifierInfo * RelatedClass, IdentifierInfo * ClassMethod, IdentifierInfo * InstanceMethod, SourceRange Range = {}, Spelling S = GNU_objc_bridge_related);
9664 
9665   // Constructors
9666   ObjCBridgeRelatedAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
9667               , IdentifierInfo * RelatedClass
9668               , IdentifierInfo * ClassMethod
9669               , IdentifierInfo * InstanceMethod
9670              );
9671 
9672   ObjCBridgeRelatedAttr *clone(ASTContext &C) const;
9673   void printPretty(raw_ostream &OS,
9674                    const PrintingPolicy &Policy) const;
9675   const char *getSpelling() const;
9676   IdentifierInfo * getRelatedClass() const {
9677     return relatedClass;
9678   }
9679 
9680   IdentifierInfo * getClassMethod() const {
9681     return classMethod;
9682   }
9683 
9684   IdentifierInfo * getInstanceMethod() const {
9685     return instanceMethod;
9686   }
9687 
9688 
9689 
9690   static bool classof(const Attr *A) { return A->getKind() == attr::ObjCBridgeRelated; }
9691 };
9692 
9693 class CLANG_ABI ObjCClassStubAttr : public Attr {
9694 public:
9695   enum Spelling {
9696     GNU_objc_class_stub = 0,
9697     CXX11_clang_objc_class_stub = 1,
9698     C23_clang_objc_class_stub = 2,
9699   SpellingNotCalculated = 15
9700 
9701   };
9702 
9703   // Factory methods
9704   static ObjCClassStubAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
9705   static ObjCClassStubAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
9706   static ObjCClassStubAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_objc_class_stub);
9707   static ObjCClassStubAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_objc_class_stub);
9708 
9709   // Constructors
9710   ObjCClassStubAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
9711              );
9712 
9713   ObjCClassStubAttr *clone(ASTContext &C) const;
9714   void printPretty(raw_ostream &OS,
9715                    const PrintingPolicy &Policy) const;
9716   const char *getSpelling() const;
9717 
9718 
9719   static bool classof(const Attr *A) { return A->getKind() == attr::ObjCClassStub; }
9720 };
9721 
9722 class CLANG_ABI ObjCDesignatedInitializerAttr : public Attr {
9723 public:
9724   enum Spelling {
9725     GNU_objc_designated_initializer = 0,
9726     CXX11_clang_objc_designated_initializer = 1,
9727     C23_clang_objc_designated_initializer = 2,
9728   SpellingNotCalculated = 15
9729 
9730   };
9731 
9732   // Factory methods
9733   static ObjCDesignatedInitializerAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
9734   static ObjCDesignatedInitializerAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
9735   static ObjCDesignatedInitializerAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_objc_designated_initializer);
9736   static ObjCDesignatedInitializerAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_objc_designated_initializer);
9737 
9738   // Constructors
9739   ObjCDesignatedInitializerAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
9740              );
9741 
9742   ObjCDesignatedInitializerAttr *clone(ASTContext &C) const;
9743   void printPretty(raw_ostream &OS,
9744                    const PrintingPolicy &Policy) const;
9745   const char *getSpelling() const;
9746 
9747 
9748   static bool classof(const Attr *A) { return A->getKind() == attr::ObjCDesignatedInitializer; }
9749 };
9750 
9751 class CLANG_ABI ObjCDirectAttr : public Attr {
9752 public:
9753   enum Spelling {
9754     GNU_objc_direct = 0,
9755     CXX11_clang_objc_direct = 1,
9756     C23_clang_objc_direct = 2,
9757   SpellingNotCalculated = 15
9758 
9759   };
9760 
9761   // Factory methods
9762   static ObjCDirectAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
9763   static ObjCDirectAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
9764   static ObjCDirectAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_objc_direct);
9765   static ObjCDirectAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_objc_direct);
9766 
9767   // Constructors
9768   ObjCDirectAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
9769              );
9770 
9771   ObjCDirectAttr *clone(ASTContext &C) const;
9772   void printPretty(raw_ostream &OS,
9773                    const PrintingPolicy &Policy) const;
9774   const char *getSpelling() const;
9775 
9776 
9777   static bool classof(const Attr *A) { return A->getKind() == attr::ObjCDirect; }
9778 };
9779 
9780 class CLANG_ABI ObjCDirectMembersAttr : public Attr {
9781 public:
9782   enum Spelling {
9783     GNU_objc_direct_members = 0,
9784     CXX11_clang_objc_direct_members = 1,
9785     C23_clang_objc_direct_members = 2,
9786   SpellingNotCalculated = 15
9787 
9788   };
9789 
9790   // Factory methods
9791   static ObjCDirectMembersAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
9792   static ObjCDirectMembersAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
9793   static ObjCDirectMembersAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_objc_direct_members);
9794   static ObjCDirectMembersAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_objc_direct_members);
9795 
9796   // Constructors
9797   ObjCDirectMembersAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
9798              );
9799 
9800   ObjCDirectMembersAttr *clone(ASTContext &C) const;
9801   void printPretty(raw_ostream &OS,
9802                    const PrintingPolicy &Policy) const;
9803   const char *getSpelling() const;
9804 
9805 
9806   static bool classof(const Attr *A) { return A->getKind() == attr::ObjCDirectMembers; }
9807 };
9808 
9809 class CLANG_ABI ObjCExceptionAttr : public InheritableAttr {
9810 public:
9811   enum Spelling {
9812     GNU_objc_exception = 0,
9813     CXX11_clang_objc_exception = 1,
9814     C23_clang_objc_exception = 2,
9815   SpellingNotCalculated = 15
9816 
9817   };
9818 
9819   // Factory methods
9820   static ObjCExceptionAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
9821   static ObjCExceptionAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
9822   static ObjCExceptionAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_objc_exception);
9823   static ObjCExceptionAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_objc_exception);
9824 
9825   // Constructors
9826   ObjCExceptionAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
9827              );
9828 
9829   ObjCExceptionAttr *clone(ASTContext &C) const;
9830   void printPretty(raw_ostream &OS,
9831                    const PrintingPolicy &Policy) const;
9832   const char *getSpelling() const;
9833 
9834 
9835   static bool classof(const Attr *A) { return A->getKind() == attr::ObjCException; }
9836 };
9837 
9838 class CLANG_ABI ObjCExplicitProtocolImplAttr : public InheritableAttr {
9839 public:
9840   enum Spelling {
9841     GNU_objc_protocol_requires_explicit_implementation = 0,
9842     CXX11_clang_objc_protocol_requires_explicit_implementation = 1,
9843     C23_clang_objc_protocol_requires_explicit_implementation = 2,
9844   SpellingNotCalculated = 15
9845 
9846   };
9847 
9848   // Factory methods
9849   static ObjCExplicitProtocolImplAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
9850   static ObjCExplicitProtocolImplAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
9851   static ObjCExplicitProtocolImplAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_objc_protocol_requires_explicit_implementation);
9852   static ObjCExplicitProtocolImplAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_objc_protocol_requires_explicit_implementation);
9853 
9854   // Constructors
9855   ObjCExplicitProtocolImplAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
9856              );
9857 
9858   ObjCExplicitProtocolImplAttr *clone(ASTContext &C) const;
9859   void printPretty(raw_ostream &OS,
9860                    const PrintingPolicy &Policy) const;
9861   const char *getSpelling() const;
9862 
9863 
9864   static bool classof(const Attr *A) { return A->getKind() == attr::ObjCExplicitProtocolImpl; }
9865 };
9866 
9867 class CLANG_ABI ObjCExternallyRetainedAttr : public InheritableAttr {
9868 public:
9869   enum Spelling {
9870     GNU_objc_externally_retained = 0,
9871     CXX11_clang_objc_externally_retained = 1,
9872     C23_clang_objc_externally_retained = 2,
9873   SpellingNotCalculated = 15
9874 
9875   };
9876 
9877   // Factory methods
9878   static ObjCExternallyRetainedAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
9879   static ObjCExternallyRetainedAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
9880   static ObjCExternallyRetainedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_objc_externally_retained);
9881   static ObjCExternallyRetainedAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_objc_externally_retained);
9882 
9883   // Constructors
9884   ObjCExternallyRetainedAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
9885              );
9886 
9887   ObjCExternallyRetainedAttr *clone(ASTContext &C) const;
9888   void printPretty(raw_ostream &OS,
9889                    const PrintingPolicy &Policy) const;
9890   const char *getSpelling() const;
9891 
9892 
9893   static bool classof(const Attr *A) { return A->getKind() == attr::ObjCExternallyRetained; }
9894 };
9895 
9896 class CLANG_ABI ObjCGCAttr : public TypeAttr {
9897 IdentifierInfo * kind;
9898 
9899 public:
9900   enum Spelling {
9901     GNU_objc_gc = 0,
9902     CXX11_clang_objc_gc = 1,
9903     C23_clang_objc_gc = 2,
9904   SpellingNotCalculated = 15
9905 
9906   };
9907 
9908   // Factory methods
9909   static ObjCGCAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * Kind, const AttributeCommonInfo &CommonInfo);
9910   static ObjCGCAttr *Create(ASTContext &Ctx, IdentifierInfo * Kind, const AttributeCommonInfo &CommonInfo);
9911   static ObjCGCAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * Kind, SourceRange Range = {}, Spelling S = GNU_objc_gc);
9912   static ObjCGCAttr *Create(ASTContext &Ctx, IdentifierInfo * Kind, SourceRange Range = {}, Spelling S = GNU_objc_gc);
9913 
9914   // Constructors
9915   ObjCGCAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
9916               , IdentifierInfo * Kind
9917              );
9918 
9919   ObjCGCAttr *clone(ASTContext &C) const;
9920   void printPretty(raw_ostream &OS,
9921                    const PrintingPolicy &Policy) const;
9922   const char *getSpelling() const;
9923   IdentifierInfo * getKind() const {
9924     return kind;
9925   }
9926 
9927 
9928 
9929   static bool classof(const Attr *A) { return A->getKind() == attr::ObjCGC; }
9930 };
9931 
9932 class CLANG_ABI ObjCIndependentClassAttr : public InheritableAttr {
9933 public:
9934   enum Spelling {
9935     GNU_objc_independent_class = 0,
9936     CXX11_clang_objc_independent_class = 1,
9937     C23_clang_objc_independent_class = 2,
9938   SpellingNotCalculated = 15
9939 
9940   };
9941 
9942   // Factory methods
9943   static ObjCIndependentClassAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
9944   static ObjCIndependentClassAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
9945   static ObjCIndependentClassAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_objc_independent_class);
9946   static ObjCIndependentClassAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_objc_independent_class);
9947 
9948   // Constructors
9949   ObjCIndependentClassAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
9950              );
9951 
9952   ObjCIndependentClassAttr *clone(ASTContext &C) const;
9953   void printPretty(raw_ostream &OS,
9954                    const PrintingPolicy &Policy) const;
9955   const char *getSpelling() const;
9956 
9957 
9958   static bool classof(const Attr *A) { return A->getKind() == attr::ObjCIndependentClass; }
9959 };
9960 
9961 class CLANG_ABI ObjCInertUnsafeUnretainedAttr : public TypeAttr {
9962 public:
9963   // Factory methods
9964   static ObjCInertUnsafeUnretainedAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
9965   static ObjCInertUnsafeUnretainedAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
9966   static ObjCInertUnsafeUnretainedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {});
9967   static ObjCInertUnsafeUnretainedAttr *Create(ASTContext &Ctx, SourceRange Range = {});
9968 
9969   // Constructors
9970   ObjCInertUnsafeUnretainedAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
9971              );
9972 
9973   ObjCInertUnsafeUnretainedAttr *clone(ASTContext &C) const;
9974   void printPretty(raw_ostream &OS,
9975                    const PrintingPolicy &Policy) const;
9976   const char *getSpelling() const;
9977 
9978 
9979   static bool classof(const Attr *A) { return A->getKind() == attr::ObjCInertUnsafeUnretained; }
9980 };
9981 
9982 class CLANG_ABI ObjCKindOfAttr : public TypeAttr {
9983 public:
9984   // Factory methods
9985   static ObjCKindOfAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
9986   static ObjCKindOfAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
9987   static ObjCKindOfAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {});
9988   static ObjCKindOfAttr *Create(ASTContext &Ctx, SourceRange Range = {});
9989 
9990   // Constructors
9991   ObjCKindOfAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
9992              );
9993 
9994   ObjCKindOfAttr *clone(ASTContext &C) const;
9995   void printPretty(raw_ostream &OS,
9996                    const PrintingPolicy &Policy) const;
9997   const char *getSpelling() const;
9998 
9999 
10000   static bool classof(const Attr *A) { return A->getKind() == attr::ObjCKindOf; }
10001 };
10002 
10003 class CLANG_ABI ObjCMethodFamilyAttr : public InheritableAttr {
10004 public:
10005   enum FamilyKind {
10006     OMF_None,
10007     OMF_alloc,
10008     OMF_copy,
10009     OMF_init,
10010     OMF_mutableCopy,
10011     OMF_new
10012   };
10013 private:
10014   ObjCMethodFamilyAttr::FamilyKind family;
10015 
10016 public:
10017   enum Spelling {
10018     GNU_objc_method_family = 0,
10019     CXX11_clang_objc_method_family = 1,
10020     C23_clang_objc_method_family = 2,
10021   SpellingNotCalculated = 15
10022 
10023   };
10024 
10025   // Factory methods
10026   static ObjCMethodFamilyAttr *CreateImplicit(ASTContext &Ctx, ObjCMethodFamilyAttr::FamilyKind Family, const AttributeCommonInfo &CommonInfo);
10027   static ObjCMethodFamilyAttr *Create(ASTContext &Ctx, ObjCMethodFamilyAttr::FamilyKind Family, const AttributeCommonInfo &CommonInfo);
10028   static ObjCMethodFamilyAttr *CreateImplicit(ASTContext &Ctx, ObjCMethodFamilyAttr::FamilyKind Family, SourceRange Range = {}, Spelling S = GNU_objc_method_family);
10029   static ObjCMethodFamilyAttr *Create(ASTContext &Ctx, ObjCMethodFamilyAttr::FamilyKind Family, SourceRange Range = {}, Spelling S = GNU_objc_method_family);
10030 
10031   // Constructors
10032   ObjCMethodFamilyAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
10033               , ObjCMethodFamilyAttr::FamilyKind Family
10034              );
10035 
10036   ObjCMethodFamilyAttr *clone(ASTContext &C) const;
10037   void printPretty(raw_ostream &OS,
10038                    const PrintingPolicy &Policy) const;
10039   const char *getSpelling() const;
10040   ObjCMethodFamilyAttr::FamilyKind getFamily() const {
10041     return family;
10042   }
10043 
10044   static bool ConvertStrToFamilyKind(StringRef Val, ObjCMethodFamilyAttr::FamilyKind &Out);
10045   static const char *ConvertFamilyKindToStr(ObjCMethodFamilyAttr::FamilyKind Val);
10046 
10047 
10048   static bool classof(const Attr *A) { return A->getKind() == attr::ObjCMethodFamily; }
10049 };
10050 
10051 class CLANG_ABI ObjCNSObjectAttr : public InheritableAttr {
10052 public:
10053   enum Spelling {
10054     GNU_NSObject = 0,
10055     CXX11_clang_NSObject = 1,
10056     C23_clang_NSObject = 2,
10057   SpellingNotCalculated = 15
10058 
10059   };
10060 
10061   // Factory methods
10062   static ObjCNSObjectAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
10063   static ObjCNSObjectAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
10064   static ObjCNSObjectAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_NSObject);
10065   static ObjCNSObjectAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_NSObject);
10066 
10067   // Constructors
10068   ObjCNSObjectAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
10069              );
10070 
10071   ObjCNSObjectAttr *clone(ASTContext &C) const;
10072   void printPretty(raw_ostream &OS,
10073                    const PrintingPolicy &Policy) const;
10074   const char *getSpelling() const;
10075 
10076 
10077   static bool classof(const Attr *A) { return A->getKind() == attr::ObjCNSObject; }
10078 };
10079 
10080 class CLANG_ABI ObjCNonLazyClassAttr : public Attr {
10081 public:
10082   enum Spelling {
10083     GNU_objc_nonlazy_class = 0,
10084     CXX11_clang_objc_nonlazy_class = 1,
10085     C23_clang_objc_nonlazy_class = 2,
10086   SpellingNotCalculated = 15
10087 
10088   };
10089 
10090   // Factory methods
10091   static ObjCNonLazyClassAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
10092   static ObjCNonLazyClassAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
10093   static ObjCNonLazyClassAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_objc_nonlazy_class);
10094   static ObjCNonLazyClassAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_objc_nonlazy_class);
10095 
10096   // Constructors
10097   ObjCNonLazyClassAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
10098              );
10099 
10100   ObjCNonLazyClassAttr *clone(ASTContext &C) const;
10101   void printPretty(raw_ostream &OS,
10102                    const PrintingPolicy &Policy) const;
10103   const char *getSpelling() const;
10104 
10105 
10106   static bool classof(const Attr *A) { return A->getKind() == attr::ObjCNonLazyClass; }
10107 };
10108 
10109 class CLANG_ABI ObjCNonRuntimeProtocolAttr : public Attr {
10110 public:
10111   enum Spelling {
10112     GNU_objc_non_runtime_protocol = 0,
10113     CXX11_clang_objc_non_runtime_protocol = 1,
10114     C23_clang_objc_non_runtime_protocol = 2,
10115   SpellingNotCalculated = 15
10116 
10117   };
10118 
10119   // Factory methods
10120   static ObjCNonRuntimeProtocolAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
10121   static ObjCNonRuntimeProtocolAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
10122   static ObjCNonRuntimeProtocolAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_objc_non_runtime_protocol);
10123   static ObjCNonRuntimeProtocolAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_objc_non_runtime_protocol);
10124 
10125   // Constructors
10126   ObjCNonRuntimeProtocolAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
10127              );
10128 
10129   ObjCNonRuntimeProtocolAttr *clone(ASTContext &C) const;
10130   void printPretty(raw_ostream &OS,
10131                    const PrintingPolicy &Policy) const;
10132   const char *getSpelling() const;
10133 
10134 
10135   static bool classof(const Attr *A) { return A->getKind() == attr::ObjCNonRuntimeProtocol; }
10136 };
10137 
10138 class CLANG_ABI ObjCOwnershipAttr : public InheritableAttr {
10139 IdentifierInfo * kind;
10140 
10141 public:
10142   enum Spelling {
10143     GNU_objc_ownership = 0,
10144     CXX11_clang_objc_ownership = 1,
10145     C23_clang_objc_ownership = 2,
10146   SpellingNotCalculated = 15
10147 
10148   };
10149 
10150   // Factory methods
10151   static ObjCOwnershipAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * Kind, const AttributeCommonInfo &CommonInfo);
10152   static ObjCOwnershipAttr *Create(ASTContext &Ctx, IdentifierInfo * Kind, const AttributeCommonInfo &CommonInfo);
10153   static ObjCOwnershipAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * Kind, SourceRange Range = {}, Spelling S = GNU_objc_ownership);
10154   static ObjCOwnershipAttr *Create(ASTContext &Ctx, IdentifierInfo * Kind, SourceRange Range = {}, Spelling S = GNU_objc_ownership);
10155 
10156   // Constructors
10157   ObjCOwnershipAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
10158               , IdentifierInfo * Kind
10159              );
10160 
10161   ObjCOwnershipAttr *clone(ASTContext &C) const;
10162   void printPretty(raw_ostream &OS,
10163                    const PrintingPolicy &Policy) const;
10164   const char *getSpelling() const;
10165   IdentifierInfo * getKind() const {
10166     return kind;
10167   }
10168 
10169 
10170 
10171   static bool classof(const Attr *A) { return A->getKind() == attr::ObjCOwnership; }
10172 };
10173 
10174 class CLANG_ABI ObjCPreciseLifetimeAttr : public InheritableAttr {
10175 public:
10176   enum Spelling {
10177     GNU_objc_precise_lifetime = 0,
10178     CXX11_clang_objc_precise_lifetime = 1,
10179     C23_clang_objc_precise_lifetime = 2,
10180   SpellingNotCalculated = 15
10181 
10182   };
10183 
10184   // Factory methods
10185   static ObjCPreciseLifetimeAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
10186   static ObjCPreciseLifetimeAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
10187   static ObjCPreciseLifetimeAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_objc_precise_lifetime);
10188   static ObjCPreciseLifetimeAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_objc_precise_lifetime);
10189 
10190   // Constructors
10191   ObjCPreciseLifetimeAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
10192              );
10193 
10194   ObjCPreciseLifetimeAttr *clone(ASTContext &C) const;
10195   void printPretty(raw_ostream &OS,
10196                    const PrintingPolicy &Policy) const;
10197   const char *getSpelling() const;
10198 
10199 
10200   static bool classof(const Attr *A) { return A->getKind() == attr::ObjCPreciseLifetime; }
10201 };
10202 
10203 class CLANG_ABI ObjCRequiresPropertyDefsAttr : public InheritableAttr {
10204 public:
10205   enum Spelling {
10206     GNU_objc_requires_property_definitions = 0,
10207     CXX11_clang_objc_requires_property_definitions = 1,
10208     C23_clang_objc_requires_property_definitions = 2,
10209   SpellingNotCalculated = 15
10210 
10211   };
10212 
10213   // Factory methods
10214   static ObjCRequiresPropertyDefsAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
10215   static ObjCRequiresPropertyDefsAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
10216   static ObjCRequiresPropertyDefsAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_objc_requires_property_definitions);
10217   static ObjCRequiresPropertyDefsAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_objc_requires_property_definitions);
10218 
10219   // Constructors
10220   ObjCRequiresPropertyDefsAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
10221              );
10222 
10223   ObjCRequiresPropertyDefsAttr *clone(ASTContext &C) const;
10224   void printPretty(raw_ostream &OS,
10225                    const PrintingPolicy &Policy) const;
10226   const char *getSpelling() const;
10227 
10228 
10229   static bool classof(const Attr *A) { return A->getKind() == attr::ObjCRequiresPropertyDefs; }
10230 };
10231 
10232 class CLANG_ABI ObjCRequiresSuperAttr : public InheritableAttr {
10233 public:
10234   enum Spelling {
10235     GNU_objc_requires_super = 0,
10236     CXX11_clang_objc_requires_super = 1,
10237     C23_clang_objc_requires_super = 2,
10238   SpellingNotCalculated = 15
10239 
10240   };
10241 
10242   // Factory methods
10243   static ObjCRequiresSuperAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
10244   static ObjCRequiresSuperAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
10245   static ObjCRequiresSuperAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_objc_requires_super);
10246   static ObjCRequiresSuperAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_objc_requires_super);
10247 
10248   // Constructors
10249   ObjCRequiresSuperAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
10250              );
10251 
10252   ObjCRequiresSuperAttr *clone(ASTContext &C) const;
10253   void printPretty(raw_ostream &OS,
10254                    const PrintingPolicy &Policy) const;
10255   const char *getSpelling() const;
10256 
10257 
10258   static bool classof(const Attr *A) { return A->getKind() == attr::ObjCRequiresSuper; }
10259 };
10260 
10261 class CLANG_ABI ObjCReturnsInnerPointerAttr : public InheritableAttr {
10262 public:
10263   enum Spelling {
10264     GNU_objc_returns_inner_pointer = 0,
10265     CXX11_clang_objc_returns_inner_pointer = 1,
10266     C23_clang_objc_returns_inner_pointer = 2,
10267   SpellingNotCalculated = 15
10268 
10269   };
10270 
10271   // Factory methods
10272   static ObjCReturnsInnerPointerAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
10273   static ObjCReturnsInnerPointerAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
10274   static ObjCReturnsInnerPointerAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_objc_returns_inner_pointer);
10275   static ObjCReturnsInnerPointerAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_objc_returns_inner_pointer);
10276 
10277   // Constructors
10278   ObjCReturnsInnerPointerAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
10279              );
10280 
10281   ObjCReturnsInnerPointerAttr *clone(ASTContext &C) const;
10282   void printPretty(raw_ostream &OS,
10283                    const PrintingPolicy &Policy) const;
10284   const char *getSpelling() const;
10285 
10286 
10287   static bool classof(const Attr *A) { return A->getKind() == attr::ObjCReturnsInnerPointer; }
10288 };
10289 
10290 class CLANG_ABI ObjCRootClassAttr : public InheritableAttr {
10291 public:
10292   enum Spelling {
10293     GNU_objc_root_class = 0,
10294     CXX11_clang_objc_root_class = 1,
10295     C23_clang_objc_root_class = 2,
10296   SpellingNotCalculated = 15
10297 
10298   };
10299 
10300   // Factory methods
10301   static ObjCRootClassAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
10302   static ObjCRootClassAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
10303   static ObjCRootClassAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_objc_root_class);
10304   static ObjCRootClassAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_objc_root_class);
10305 
10306   // Constructors
10307   ObjCRootClassAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
10308              );
10309 
10310   ObjCRootClassAttr *clone(ASTContext &C) const;
10311   void printPretty(raw_ostream &OS,
10312                    const PrintingPolicy &Policy) const;
10313   const char *getSpelling() const;
10314 
10315 
10316   static bool classof(const Attr *A) { return A->getKind() == attr::ObjCRootClass; }
10317 };
10318 
10319 class CLANG_ABI ObjCRuntimeNameAttr : public Attr {
10320 unsigned metadataNameLength;
10321 char *metadataName;
10322 
10323 public:
10324   enum Spelling {
10325     GNU_objc_runtime_name = 0,
10326     CXX11_clang_objc_runtime_name = 1,
10327     C23_clang_objc_runtime_name = 2,
10328   SpellingNotCalculated = 15
10329 
10330   };
10331 
10332   // Factory methods
10333   static ObjCRuntimeNameAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef MetadataName, const AttributeCommonInfo &CommonInfo);
10334   static ObjCRuntimeNameAttr *Create(ASTContext &Ctx, llvm::StringRef MetadataName, const AttributeCommonInfo &CommonInfo);
10335   static ObjCRuntimeNameAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef MetadataName, SourceRange Range = {}, Spelling S = GNU_objc_runtime_name);
10336   static ObjCRuntimeNameAttr *Create(ASTContext &Ctx, llvm::StringRef MetadataName, SourceRange Range = {}, Spelling S = GNU_objc_runtime_name);
10337 
10338   // Constructors
10339   ObjCRuntimeNameAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
10340               , llvm::StringRef MetadataName
10341              );
10342 
10343   ObjCRuntimeNameAttr *clone(ASTContext &C) const;
10344   void printPretty(raw_ostream &OS,
10345                    const PrintingPolicy &Policy) const;
10346   const char *getSpelling() const;
10347   llvm::StringRef getMetadataName() const {
10348     return llvm::StringRef(metadataName, metadataNameLength);
10349   }
10350   unsigned getMetadataNameLength() const {
10351     return metadataNameLength;
10352   }
10353   void setMetadataName(ASTContext &C, llvm::StringRef S) {
10354     metadataNameLength = S.size();
10355     this->metadataName = new (C, 1) char [metadataNameLength];
10356     if (!S.empty())
10357       std::memcpy(this->metadataName, S.data(), metadataNameLength);
10358   }
10359 
10360 
10361 
10362   static bool classof(const Attr *A) { return A->getKind() == attr::ObjCRuntimeName; }
10363 };
10364 
10365 class CLANG_ABI ObjCRuntimeVisibleAttr : public Attr {
10366 public:
10367   enum Spelling {
10368     GNU_objc_runtime_visible = 0,
10369     CXX11_clang_objc_runtime_visible = 1,
10370     C23_clang_objc_runtime_visible = 2,
10371   SpellingNotCalculated = 15
10372 
10373   };
10374 
10375   // Factory methods
10376   static ObjCRuntimeVisibleAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
10377   static ObjCRuntimeVisibleAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
10378   static ObjCRuntimeVisibleAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_objc_runtime_visible);
10379   static ObjCRuntimeVisibleAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_objc_runtime_visible);
10380 
10381   // Constructors
10382   ObjCRuntimeVisibleAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
10383              );
10384 
10385   ObjCRuntimeVisibleAttr *clone(ASTContext &C) const;
10386   void printPretty(raw_ostream &OS,
10387                    const PrintingPolicy &Policy) const;
10388   const char *getSpelling() const;
10389 
10390 
10391   static bool classof(const Attr *A) { return A->getKind() == attr::ObjCRuntimeVisible; }
10392 };
10393 
10394 class CLANG_ABI ObjCSubclassingRestrictedAttr : public InheritableAttr {
10395 public:
10396   enum Spelling {
10397     GNU_objc_subclassing_restricted = 0,
10398     CXX11_clang_objc_subclassing_restricted = 1,
10399     C23_clang_objc_subclassing_restricted = 2,
10400   SpellingNotCalculated = 15
10401 
10402   };
10403 
10404   // Factory methods
10405   static ObjCSubclassingRestrictedAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
10406   static ObjCSubclassingRestrictedAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
10407   static ObjCSubclassingRestrictedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_objc_subclassing_restricted);
10408   static ObjCSubclassingRestrictedAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_objc_subclassing_restricted);
10409 
10410   // Constructors
10411   ObjCSubclassingRestrictedAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
10412              );
10413 
10414   ObjCSubclassingRestrictedAttr *clone(ASTContext &C) const;
10415   void printPretty(raw_ostream &OS,
10416                    const PrintingPolicy &Policy) const;
10417   const char *getSpelling() const;
10418 
10419 
10420   static bool classof(const Attr *A) { return A->getKind() == attr::ObjCSubclassingRestricted; }
10421 };
10422 
10423 class CLANG_ABI OpenCLAccessAttr : public Attr {
10424 public:
10425   enum Spelling {
10426     Keyword_read_only = 0,
10427     Keyword_write_only = 2,
10428     Keyword_read_write = 4,
10429   SpellingNotCalculated = 15
10430 
10431   };
10432 
10433   // Factory methods
10434   static OpenCLAccessAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
10435   static OpenCLAccessAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
10436   static OpenCLAccessAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = Keyword_read_only);
10437   static OpenCLAccessAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = Keyword_read_only);
10438 
10439   // Constructors
10440   OpenCLAccessAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
10441              );
10442 
10443   OpenCLAccessAttr *clone(ASTContext &C) const;
10444   void printPretty(raw_ostream &OS,
10445                    const PrintingPolicy &Policy) const;
10446   const char *getSpelling() const;
10447   Spelling getSemanticSpelling() const;
10448   bool isReadOnly() const { return getAttributeSpellingListIndex() == 0 ||
10449     getAttributeSpellingListIndex() == 1; }
10450   bool isReadWrite() const { return getAttributeSpellingListIndex() == 4 ||
10451     getAttributeSpellingListIndex() == 5; }
10452   bool isWriteOnly() const { return getAttributeSpellingListIndex() == 2 ||
10453     getAttributeSpellingListIndex() == 3; }
10454 
10455 
10456   static bool classof(const Attr *A) { return A->getKind() == attr::OpenCLAccess; }
10457 };
10458 
10459 class CLANG_ABI OpenCLConstantAddressSpaceAttr : public TypeAttr {
10460 public:
10461   enum Spelling {
10462     Keyword_constant = 0,
10463     GNU_opencl_constant = 2,
10464     CXX11_clang_opencl_constant = 3,
10465     C23_clang_opencl_constant = 4,
10466   SpellingNotCalculated = 15
10467 
10468   };
10469 
10470   // Factory methods
10471   static OpenCLConstantAddressSpaceAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
10472   static OpenCLConstantAddressSpaceAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
10473   static OpenCLConstantAddressSpaceAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = Keyword_constant);
10474   static OpenCLConstantAddressSpaceAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = Keyword_constant);
10475 
10476   // Constructors
10477   OpenCLConstantAddressSpaceAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
10478              );
10479 
10480   OpenCLConstantAddressSpaceAttr *clone(ASTContext &C) const;
10481   void printPretty(raw_ostream &OS,
10482                    const PrintingPolicy &Policy) const;
10483   const char *getSpelling() const;
10484   Spelling getSemanticSpelling() const;
10485 
10486 
10487   static bool classof(const Attr *A) { return A->getKind() == attr::OpenCLConstantAddressSpace; }
10488 };
10489 
10490 class CLANG_ABI OpenCLGenericAddressSpaceAttr : public TypeAttr {
10491 public:
10492   enum Spelling {
10493     Keyword_generic = 0,
10494     GNU_opencl_generic = 2,
10495     CXX11_clang_opencl_generic = 3,
10496     C23_clang_opencl_generic = 4,
10497   SpellingNotCalculated = 15
10498 
10499   };
10500 
10501   // Factory methods
10502   static OpenCLGenericAddressSpaceAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
10503   static OpenCLGenericAddressSpaceAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
10504   static OpenCLGenericAddressSpaceAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = Keyword_generic);
10505   static OpenCLGenericAddressSpaceAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = Keyword_generic);
10506 
10507   // Constructors
10508   OpenCLGenericAddressSpaceAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
10509              );
10510 
10511   OpenCLGenericAddressSpaceAttr *clone(ASTContext &C) const;
10512   void printPretty(raw_ostream &OS,
10513                    const PrintingPolicy &Policy) const;
10514   const char *getSpelling() const;
10515   Spelling getSemanticSpelling() const;
10516 
10517 
10518   static bool classof(const Attr *A) { return A->getKind() == attr::OpenCLGenericAddressSpace; }
10519 };
10520 
10521 class CLANG_ABI OpenCLGlobalAddressSpaceAttr : public TypeAttr {
10522 public:
10523   enum Spelling {
10524     Keyword_global = 0,
10525     GNU_opencl_global = 2,
10526     CXX11_clang_opencl_global = 3,
10527     C23_clang_opencl_global = 4,
10528   SpellingNotCalculated = 15
10529 
10530   };
10531 
10532   // Factory methods
10533   static OpenCLGlobalAddressSpaceAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
10534   static OpenCLGlobalAddressSpaceAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
10535   static OpenCLGlobalAddressSpaceAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = Keyword_global);
10536   static OpenCLGlobalAddressSpaceAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = Keyword_global);
10537 
10538   // Constructors
10539   OpenCLGlobalAddressSpaceAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
10540              );
10541 
10542   OpenCLGlobalAddressSpaceAttr *clone(ASTContext &C) const;
10543   void printPretty(raw_ostream &OS,
10544                    const PrintingPolicy &Policy) const;
10545   const char *getSpelling() const;
10546   Spelling getSemanticSpelling() const;
10547 
10548 
10549   static bool classof(const Attr *A) { return A->getKind() == attr::OpenCLGlobalAddressSpace; }
10550 };
10551 
10552 class CLANG_ABI OpenCLGlobalDeviceAddressSpaceAttr : public TypeAttr {
10553 public:
10554   enum Spelling {
10555     GNU_opencl_global_device = 0,
10556     CXX11_clang_opencl_global_device = 1,
10557     C23_clang_opencl_global_device = 2,
10558   SpellingNotCalculated = 15
10559 
10560   };
10561 
10562   // Factory methods
10563   static OpenCLGlobalDeviceAddressSpaceAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
10564   static OpenCLGlobalDeviceAddressSpaceAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
10565   static OpenCLGlobalDeviceAddressSpaceAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_opencl_global_device);
10566   static OpenCLGlobalDeviceAddressSpaceAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_opencl_global_device);
10567 
10568   // Constructors
10569   OpenCLGlobalDeviceAddressSpaceAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
10570              );
10571 
10572   OpenCLGlobalDeviceAddressSpaceAttr *clone(ASTContext &C) const;
10573   void printPretty(raw_ostream &OS,
10574                    const PrintingPolicy &Policy) const;
10575   const char *getSpelling() const;
10576 
10577 
10578   static bool classof(const Attr *A) { return A->getKind() == attr::OpenCLGlobalDeviceAddressSpace; }
10579 };
10580 
10581 class CLANG_ABI OpenCLGlobalHostAddressSpaceAttr : public TypeAttr {
10582 public:
10583   enum Spelling {
10584     GNU_opencl_global_host = 0,
10585     CXX11_clang_opencl_global_host = 1,
10586     C23_clang_opencl_global_host = 2,
10587   SpellingNotCalculated = 15
10588 
10589   };
10590 
10591   // Factory methods
10592   static OpenCLGlobalHostAddressSpaceAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
10593   static OpenCLGlobalHostAddressSpaceAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
10594   static OpenCLGlobalHostAddressSpaceAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_opencl_global_host);
10595   static OpenCLGlobalHostAddressSpaceAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_opencl_global_host);
10596 
10597   // Constructors
10598   OpenCLGlobalHostAddressSpaceAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
10599              );
10600 
10601   OpenCLGlobalHostAddressSpaceAttr *clone(ASTContext &C) const;
10602   void printPretty(raw_ostream &OS,
10603                    const PrintingPolicy &Policy) const;
10604   const char *getSpelling() const;
10605 
10606 
10607   static bool classof(const Attr *A) { return A->getKind() == attr::OpenCLGlobalHostAddressSpace; }
10608 };
10609 
10610 class CLANG_ABI OpenCLIntelReqdSubGroupSizeAttr : public InheritableAttr {
10611 unsigned subGroupSize;
10612 
10613 public:
10614   // Factory methods
10615   static OpenCLIntelReqdSubGroupSizeAttr *CreateImplicit(ASTContext &Ctx, unsigned SubGroupSize, const AttributeCommonInfo &CommonInfo);
10616   static OpenCLIntelReqdSubGroupSizeAttr *Create(ASTContext &Ctx, unsigned SubGroupSize, const AttributeCommonInfo &CommonInfo);
10617   static OpenCLIntelReqdSubGroupSizeAttr *CreateImplicit(ASTContext &Ctx, unsigned SubGroupSize, SourceRange Range = {});
10618   static OpenCLIntelReqdSubGroupSizeAttr *Create(ASTContext &Ctx, unsigned SubGroupSize, SourceRange Range = {});
10619 
10620   // Constructors
10621   OpenCLIntelReqdSubGroupSizeAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
10622               , unsigned SubGroupSize
10623              );
10624 
10625   OpenCLIntelReqdSubGroupSizeAttr *clone(ASTContext &C) const;
10626   void printPretty(raw_ostream &OS,
10627                    const PrintingPolicy &Policy) const;
10628   const char *getSpelling() const;
10629   unsigned getSubGroupSize() const {
10630     return subGroupSize;
10631   }
10632 
10633 
10634 
10635   static bool classof(const Attr *A) { return A->getKind() == attr::OpenCLIntelReqdSubGroupSize; }
10636 };
10637 
10638 class CLANG_ABI OpenCLKernelAttr : public InheritableAttr {
10639 public:
10640   enum Spelling {
10641     Keyword_kernel = 0,
10642   SpellingNotCalculated = 15
10643 
10644   };
10645 
10646   // Factory methods
10647   static OpenCLKernelAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
10648   static OpenCLKernelAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
10649   static OpenCLKernelAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = Keyword_kernel);
10650   static OpenCLKernelAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = Keyword_kernel);
10651 
10652   // Constructors
10653   OpenCLKernelAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
10654              );
10655 
10656   OpenCLKernelAttr *clone(ASTContext &C) const;
10657   void printPretty(raw_ostream &OS,
10658                    const PrintingPolicy &Policy) const;
10659   const char *getSpelling() const;
10660 
10661 
10662   static bool classof(const Attr *A) { return A->getKind() == attr::OpenCLKernel; }
10663 };
10664 
10665 class CLANG_ABI OpenCLLocalAddressSpaceAttr : public TypeAttr {
10666 public:
10667   enum Spelling {
10668     Keyword_local = 0,
10669     GNU_opencl_local = 2,
10670     CXX11_clang_opencl_local = 3,
10671     C23_clang_opencl_local = 4,
10672   SpellingNotCalculated = 15
10673 
10674   };
10675 
10676   // Factory methods
10677   static OpenCLLocalAddressSpaceAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
10678   static OpenCLLocalAddressSpaceAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
10679   static OpenCLLocalAddressSpaceAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = Keyword_local);
10680   static OpenCLLocalAddressSpaceAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = Keyword_local);
10681 
10682   // Constructors
10683   OpenCLLocalAddressSpaceAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
10684              );
10685 
10686   OpenCLLocalAddressSpaceAttr *clone(ASTContext &C) const;
10687   void printPretty(raw_ostream &OS,
10688                    const PrintingPolicy &Policy) const;
10689   const char *getSpelling() const;
10690   Spelling getSemanticSpelling() const;
10691 
10692 
10693   static bool classof(const Attr *A) { return A->getKind() == attr::OpenCLLocalAddressSpace; }
10694 };
10695 
10696 class CLANG_ABI OpenCLPrivateAddressSpaceAttr : public TypeAttr {
10697 public:
10698   enum Spelling {
10699     Keyword_private = 0,
10700     GNU_opencl_private = 2,
10701     CXX11_clang_opencl_private = 3,
10702     C23_clang_opencl_private = 4,
10703   SpellingNotCalculated = 15
10704 
10705   };
10706 
10707   // Factory methods
10708   static OpenCLPrivateAddressSpaceAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
10709   static OpenCLPrivateAddressSpaceAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
10710   static OpenCLPrivateAddressSpaceAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = Keyword_private);
10711   static OpenCLPrivateAddressSpaceAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = Keyword_private);
10712 
10713   // Constructors
10714   OpenCLPrivateAddressSpaceAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
10715              );
10716 
10717   OpenCLPrivateAddressSpaceAttr *clone(ASTContext &C) const;
10718   void printPretty(raw_ostream &OS,
10719                    const PrintingPolicy &Policy) const;
10720   const char *getSpelling() const;
10721   Spelling getSemanticSpelling() const;
10722 
10723 
10724   static bool classof(const Attr *A) { return A->getKind() == attr::OpenCLPrivateAddressSpace; }
10725 };
10726 
10727 class CLANG_ABI OpenCLUnrollHintAttr : public StmtAttr {
10728 unsigned unrollHint;
10729 
10730 public:
10731   // Factory methods
10732   static OpenCLUnrollHintAttr *CreateImplicit(ASTContext &Ctx, unsigned UnrollHint, const AttributeCommonInfo &CommonInfo);
10733   static OpenCLUnrollHintAttr *Create(ASTContext &Ctx, unsigned UnrollHint, const AttributeCommonInfo &CommonInfo);
10734   static OpenCLUnrollHintAttr *CreateImplicit(ASTContext &Ctx, unsigned UnrollHint, SourceRange Range = {});
10735   static OpenCLUnrollHintAttr *Create(ASTContext &Ctx, unsigned UnrollHint, SourceRange Range = {});
10736 
10737   // Constructors
10738   OpenCLUnrollHintAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
10739               , unsigned UnrollHint
10740              );
10741   OpenCLUnrollHintAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
10742              );
10743 
10744   OpenCLUnrollHintAttr *clone(ASTContext &C) const;
10745   void printPretty(raw_ostream &OS,
10746                    const PrintingPolicy &Policy) const;
10747   const char *getSpelling() const;
10748   unsigned getUnrollHint() const {
10749     return unrollHint;
10750   }
10751 
10752 
10753 
10754   static bool classof(const Attr *A) { return A->getKind() == attr::OpenCLUnrollHint; }
10755 };
10756 
10757 class CLANG_ABI OptimizeNoneAttr : public InheritableAttr {
10758 public:
10759   enum Spelling {
10760     GNU_optnone = 0,
10761     CXX11_clang_optnone = 1,
10762     C23_clang_optnone = 2,
10763   SpellingNotCalculated = 15
10764 
10765   };
10766 
10767   // Factory methods
10768   static OptimizeNoneAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
10769   static OptimizeNoneAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
10770   static OptimizeNoneAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_optnone);
10771   static OptimizeNoneAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_optnone);
10772 
10773   // Constructors
10774   OptimizeNoneAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
10775              );
10776 
10777   OptimizeNoneAttr *clone(ASTContext &C) const;
10778   void printPretty(raw_ostream &OS,
10779                    const PrintingPolicy &Policy) const;
10780   const char *getSpelling() const;
10781 
10782 
10783   static bool classof(const Attr *A) { return A->getKind() == attr::OptimizeNone; }
10784 };
10785 
10786 class CLANG_ABI OverloadableAttr : public Attr {
10787 public:
10788   enum Spelling {
10789     GNU_overloadable = 0,
10790     CXX11_clang_overloadable = 1,
10791     C23_clang_overloadable = 2,
10792   SpellingNotCalculated = 15
10793 
10794   };
10795 
10796   // Factory methods
10797   static OverloadableAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
10798   static OverloadableAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
10799   static OverloadableAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_overloadable);
10800   static OverloadableAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_overloadable);
10801 
10802   // Constructors
10803   OverloadableAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
10804              );
10805 
10806   OverloadableAttr *clone(ASTContext &C) const;
10807   void printPretty(raw_ostream &OS,
10808                    const PrintingPolicy &Policy) const;
10809   const char *getSpelling() const;
10810 
10811 
10812   static bool classof(const Attr *A) { return A->getKind() == attr::Overloadable; }
10813 };
10814 
10815 class CLANG_ABI OverrideAttr : public InheritableAttr {
10816 public:
10817   // Factory methods
10818   static OverrideAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
10819   static OverrideAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
10820   static OverrideAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {});
10821   static OverrideAttr *Create(ASTContext &Ctx, SourceRange Range = {});
10822 
10823   // Constructors
10824   OverrideAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
10825              );
10826 
10827   OverrideAttr *clone(ASTContext &C) const;
10828   void printPretty(raw_ostream &OS,
10829                    const PrintingPolicy &Policy) const;
10830   const char *getSpelling() const;
10831 
10832 
10833   static bool classof(const Attr *A) { return A->getKind() == attr::Override; }
10834 };
10835 
10836 class CLANG_ABI OwnerAttr : public InheritableAttr {
10837 TypeSourceInfo * derefType;
10838 
10839 public:
10840   // Factory methods
10841   static OwnerAttr *CreateImplicit(ASTContext &Ctx, TypeSourceInfo * DerefType, const AttributeCommonInfo &CommonInfo);
10842   static OwnerAttr *Create(ASTContext &Ctx, TypeSourceInfo * DerefType, const AttributeCommonInfo &CommonInfo);
10843   static OwnerAttr *CreateImplicit(ASTContext &Ctx, TypeSourceInfo * DerefType, SourceRange Range = {});
10844   static OwnerAttr *Create(ASTContext &Ctx, TypeSourceInfo * DerefType, SourceRange Range = {});
10845 
10846   // Constructors
10847   OwnerAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
10848               , TypeSourceInfo * DerefType
10849              );
10850   OwnerAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
10851              );
10852 
10853   OwnerAttr *clone(ASTContext &C) const;
10854   void printPretty(raw_ostream &OS,
10855                    const PrintingPolicy &Policy) const;
10856   const char *getSpelling() const;
10857   QualType getDerefType() const {
10858     return derefType->getType();
10859   }  TypeSourceInfo * getDerefTypeLoc() const {
10860     return derefType;
10861   }
10862 
10863 
10864 
10865   static bool classof(const Attr *A) { return A->getKind() == attr::Owner; }
10866 };
10867 
10868 class CLANG_ABI OwnershipAttr : public InheritableAttr {
10869 IdentifierInfo * module;
10870 
10871   unsigned args_Size;
10872   ParamIdx *args_;
10873 
10874 public:
10875   enum Spelling {
10876     GNU_ownership_holds = 0,
10877     CXX11_clang_ownership_holds = 1,
10878     C23_clang_ownership_holds = 2,
10879     GNU_ownership_returns = 3,
10880     CXX11_clang_ownership_returns = 4,
10881     C23_clang_ownership_returns = 5,
10882     GNU_ownership_takes = 6,
10883     CXX11_clang_ownership_takes = 7,
10884     C23_clang_ownership_takes = 8,
10885   SpellingNotCalculated = 15
10886 
10887   };
10888 
10889   // Factory methods
10890   static OwnershipAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * Module, ParamIdx *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo);
10891   static OwnershipAttr *Create(ASTContext &Ctx, IdentifierInfo * Module, ParamIdx *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo);
10892   static OwnershipAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * Module, ParamIdx *Args, unsigned ArgsSize, SourceRange Range = {}, Spelling S = GNU_ownership_holds);
10893   static OwnershipAttr *Create(ASTContext &Ctx, IdentifierInfo * Module, ParamIdx *Args, unsigned ArgsSize, SourceRange Range = {}, Spelling S = GNU_ownership_holds);
10894 
10895   // Constructors
10896   OwnershipAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
10897               , IdentifierInfo * Module
10898               , ParamIdx *Args, unsigned ArgsSize
10899              );
10900   OwnershipAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
10901               , IdentifierInfo * Module
10902              );
10903 
10904   OwnershipAttr *clone(ASTContext &C) const;
10905   void printPretty(raw_ostream &OS,
10906                    const PrintingPolicy &Policy) const;
10907   const char *getSpelling() const;
10908   Spelling getSemanticSpelling() const;
10909   bool isHolds() const { return getAttributeSpellingListIndex() == 0 ||
10910     getAttributeSpellingListIndex() == 1 ||
10911     getAttributeSpellingListIndex() == 2; }
10912   bool isReturns() const { return getAttributeSpellingListIndex() == 3 ||
10913     getAttributeSpellingListIndex() == 4 ||
10914     getAttributeSpellingListIndex() == 5; }
10915   bool isTakes() const { return getAttributeSpellingListIndex() == 6 ||
10916     getAttributeSpellingListIndex() == 7 ||
10917     getAttributeSpellingListIndex() == 8; }
10918   IdentifierInfo * getModule() const {
10919     return module;
10920   }
10921 
10922   typedef ParamIdx* args_iterator;
10923   args_iterator args_begin() const { return args_; }
10924   args_iterator args_end() const { return args_ + args_Size; }
10925   unsigned args_size() const { return args_Size; }
10926   llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }
10927 
10928 
10929 
10930     enum OwnershipKind { Holds, Returns, Takes };
10931     OwnershipKind getOwnKind() const {
10932       return isHolds() ? Holds :
10933              isTakes() ? Takes :
10934              Returns;
10935     }
10936   
10937 
10938   static bool classof(const Attr *A) { return A->getKind() == attr::Ownership; }
10939 };
10940 
10941 class CLANG_ABI PackedAttr : public InheritableAttr {
10942 public:
10943   enum Spelling {
10944     GNU_packed = 0,
10945     CXX11_gnu_packed = 1,
10946     C23_gnu_packed = 2,
10947   SpellingNotCalculated = 15
10948 
10949   };
10950 
10951   // Factory methods
10952   static PackedAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
10953   static PackedAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
10954   static PackedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_packed);
10955   static PackedAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_packed);
10956 
10957   // Constructors
10958   PackedAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
10959              );
10960 
10961   PackedAttr *clone(ASTContext &C) const;
10962   void printPretty(raw_ostream &OS,
10963                    const PrintingPolicy &Policy) const;
10964   const char *getSpelling() const;
10965 
10966 
10967   static bool classof(const Attr *A) { return A->getKind() == attr::Packed; }
10968 };
10969 
10970 class CLANG_ABI ParamTypestateAttr : public InheritableAttr {
10971 public:
10972   enum ConsumedState {
10973     Unknown,
10974     Consumed,
10975     Unconsumed
10976   };
10977 private:
10978   ParamTypestateAttr::ConsumedState paramState;
10979 
10980 public:
10981   enum Spelling {
10982     GNU_param_typestate = 0,
10983     CXX11_clang_param_typestate = 1,
10984   SpellingNotCalculated = 15
10985 
10986   };
10987 
10988   // Factory methods
10989   static ParamTypestateAttr *CreateImplicit(ASTContext &Ctx, ParamTypestateAttr::ConsumedState ParamState, const AttributeCommonInfo &CommonInfo);
10990   static ParamTypestateAttr *Create(ASTContext &Ctx, ParamTypestateAttr::ConsumedState ParamState, const AttributeCommonInfo &CommonInfo);
10991   static ParamTypestateAttr *CreateImplicit(ASTContext &Ctx, ParamTypestateAttr::ConsumedState ParamState, SourceRange Range = {}, Spelling S = GNU_param_typestate);
10992   static ParamTypestateAttr *Create(ASTContext &Ctx, ParamTypestateAttr::ConsumedState ParamState, SourceRange Range = {}, Spelling S = GNU_param_typestate);
10993 
10994   // Constructors
10995   ParamTypestateAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
10996               , ParamTypestateAttr::ConsumedState ParamState
10997              );
10998 
10999   ParamTypestateAttr *clone(ASTContext &C) const;
11000   void printPretty(raw_ostream &OS,
11001                    const PrintingPolicy &Policy) const;
11002   const char *getSpelling() const;
11003   ParamTypestateAttr::ConsumedState getParamState() const {
11004     return paramState;
11005   }
11006 
11007   static bool ConvertStrToConsumedState(StringRef Val, ParamTypestateAttr::ConsumedState &Out);
11008   static const char *ConvertConsumedStateToStr(ParamTypestateAttr::ConsumedState Val);
11009 
11010 
11011   static bool classof(const Attr *A) { return A->getKind() == attr::ParamTypestate; }
11012 };
11013 
11014 class CLANG_ABI PascalAttr : public InheritableAttr {
11015 public:
11016   enum Spelling {
11017     GNU_pascal = 0,
11018     CXX11_clang_pascal = 1,
11019     C23_clang_pascal = 2,
11020     Keyword_pascal = 3,
11021   SpellingNotCalculated = 15
11022 
11023   };
11024 
11025   // Factory methods
11026   static PascalAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
11027   static PascalAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
11028   static PascalAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_pascal);
11029   static PascalAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_pascal);
11030 
11031   // Constructors
11032   PascalAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
11033              );
11034 
11035   PascalAttr *clone(ASTContext &C) const;
11036   void printPretty(raw_ostream &OS,
11037                    const PrintingPolicy &Policy) const;
11038   const char *getSpelling() const;
11039 
11040 
11041   static bool classof(const Attr *A) { return A->getKind() == attr::Pascal; }
11042 };
11043 
11044 class CLANG_ABI PassObjectSizeAttr : public InheritableParamAttr {
11045 int type;
11046 
11047 public:
11048   enum Spelling {
11049     GNU_pass_object_size = 0,
11050     CXX11_clang_pass_object_size = 1,
11051     C23_clang_pass_object_size = 2,
11052     GNU_pass_dynamic_object_size = 3,
11053     CXX11_clang_pass_dynamic_object_size = 4,
11054     C23_clang_pass_dynamic_object_size = 5,
11055   SpellingNotCalculated = 15
11056 
11057   };
11058 
11059   // Factory methods
11060   static PassObjectSizeAttr *CreateImplicit(ASTContext &Ctx, int Type, const AttributeCommonInfo &CommonInfo);
11061   static PassObjectSizeAttr *Create(ASTContext &Ctx, int Type, const AttributeCommonInfo &CommonInfo);
11062   static PassObjectSizeAttr *CreateImplicit(ASTContext &Ctx, int Type, SourceRange Range = {}, Spelling S = GNU_pass_object_size);
11063   static PassObjectSizeAttr *Create(ASTContext &Ctx, int Type, SourceRange Range = {}, Spelling S = GNU_pass_object_size);
11064 
11065   // Constructors
11066   PassObjectSizeAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
11067               , int Type
11068              );
11069 
11070   PassObjectSizeAttr *clone(ASTContext &C) const;
11071   void printPretty(raw_ostream &OS,
11072                    const PrintingPolicy &Policy) const;
11073   const char *getSpelling() const;
11074   Spelling getSemanticSpelling() const;
11075   bool isDynamic() const { return getAttributeSpellingListIndex() == 3 ||
11076     getAttributeSpellingListIndex() == 4 ||
11077     getAttributeSpellingListIndex() == 5; }
11078   int getType() const {
11079     return type;
11080   }
11081 
11082 
11083 
11084   static bool classof(const Attr *A) { return A->getKind() == attr::PassObjectSize; }
11085 };
11086 
11087 class CLANG_ABI PatchableFunctionEntryAttr : public InheritableAttr {
11088 unsigned count;
11089 
11090 int offset;
11091 
11092 public:
11093   enum Spelling {
11094     GNU_patchable_function_entry = 0,
11095     CXX11_gnu_patchable_function_entry = 1,
11096     C23_gnu_patchable_function_entry = 2,
11097   SpellingNotCalculated = 15
11098 
11099   };
11100 
11101   // Factory methods
11102   static PatchableFunctionEntryAttr *CreateImplicit(ASTContext &Ctx, unsigned Count, int Offset, const AttributeCommonInfo &CommonInfo);
11103   static PatchableFunctionEntryAttr *Create(ASTContext &Ctx, unsigned Count, int Offset, const AttributeCommonInfo &CommonInfo);
11104   static PatchableFunctionEntryAttr *CreateImplicit(ASTContext &Ctx, unsigned Count, int Offset, SourceRange Range = {}, Spelling S = GNU_patchable_function_entry);
11105   static PatchableFunctionEntryAttr *Create(ASTContext &Ctx, unsigned Count, int Offset, SourceRange Range = {}, Spelling S = GNU_patchable_function_entry);
11106 
11107   // Constructors
11108   PatchableFunctionEntryAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
11109               , unsigned Count
11110               , int Offset
11111              );
11112   PatchableFunctionEntryAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
11113               , unsigned Count
11114              );
11115 
11116   PatchableFunctionEntryAttr *clone(ASTContext &C) const;
11117   void printPretty(raw_ostream &OS,
11118                    const PrintingPolicy &Policy) const;
11119   const char *getSpelling() const;
11120   unsigned getCount() const {
11121     return count;
11122   }
11123 
11124   int getOffset() const {
11125     return offset;
11126   }
11127 
11128   static const int DefaultOffset = 0;
11129 
11130 
11131 
11132   static bool classof(const Attr *A) { return A->getKind() == attr::PatchableFunctionEntry; }
11133 };
11134 
11135 class CLANG_ABI PcsAttr : public InheritableAttr {
11136 public:
11137   enum PCSType {
11138     AAPCS,
11139     AAPCS_VFP
11140   };
11141 private:
11142   PcsAttr::PCSType pCS;
11143 
11144 public:
11145   enum Spelling {
11146     GNU_pcs = 0,
11147     CXX11_gnu_pcs = 1,
11148     C23_gnu_pcs = 2,
11149   SpellingNotCalculated = 15
11150 
11151   };
11152 
11153   // Factory methods
11154   static PcsAttr *CreateImplicit(ASTContext &Ctx, PcsAttr::PCSType PCS, const AttributeCommonInfo &CommonInfo);
11155   static PcsAttr *Create(ASTContext &Ctx, PcsAttr::PCSType PCS, const AttributeCommonInfo &CommonInfo);
11156   static PcsAttr *CreateImplicit(ASTContext &Ctx, PcsAttr::PCSType PCS, SourceRange Range = {}, Spelling S = GNU_pcs);
11157   static PcsAttr *Create(ASTContext &Ctx, PcsAttr::PCSType PCS, SourceRange Range = {}, Spelling S = GNU_pcs);
11158 
11159   // Constructors
11160   PcsAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
11161               , PcsAttr::PCSType PCS
11162              );
11163 
11164   PcsAttr *clone(ASTContext &C) const;
11165   void printPretty(raw_ostream &OS,
11166                    const PrintingPolicy &Policy) const;
11167   const char *getSpelling() const;
11168   PcsAttr::PCSType getPCS() const {
11169     return pCS;
11170   }
11171 
11172   static bool ConvertStrToPCSType(StringRef Val, PcsAttr::PCSType &Out);
11173   static const char *ConvertPCSTypeToStr(PcsAttr::PCSType Val);
11174 
11175 
11176   static bool classof(const Attr *A) { return A->getKind() == attr::Pcs; }
11177 };
11178 
11179 class CLANG_ABI PointerAttr : public InheritableAttr {
11180 TypeSourceInfo * derefType;
11181 
11182 public:
11183   // Factory methods
11184   static PointerAttr *CreateImplicit(ASTContext &Ctx, TypeSourceInfo * DerefType, const AttributeCommonInfo &CommonInfo);
11185   static PointerAttr *Create(ASTContext &Ctx, TypeSourceInfo * DerefType, const AttributeCommonInfo &CommonInfo);
11186   static PointerAttr *CreateImplicit(ASTContext &Ctx, TypeSourceInfo * DerefType, SourceRange Range = {});
11187   static PointerAttr *Create(ASTContext &Ctx, TypeSourceInfo * DerefType, SourceRange Range = {});
11188 
11189   // Constructors
11190   PointerAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
11191               , TypeSourceInfo * DerefType
11192              );
11193   PointerAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
11194              );
11195 
11196   PointerAttr *clone(ASTContext &C) const;
11197   void printPretty(raw_ostream &OS,
11198                    const PrintingPolicy &Policy) const;
11199   const char *getSpelling() const;
11200   QualType getDerefType() const {
11201     return derefType->getType();
11202   }  TypeSourceInfo * getDerefTypeLoc() const {
11203     return derefType;
11204   }
11205 
11206 
11207 
11208   static bool classof(const Attr *A) { return A->getKind() == attr::Pointer; }
11209 };
11210 
11211 class CLANG_ABI PragmaClangBSSSectionAttr : public InheritableAttr {
11212 unsigned nameLength;
11213 char *name;
11214 
11215 public:
11216   // Factory methods
11217   static PragmaClangBSSSectionAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Name, const AttributeCommonInfo &CommonInfo);
11218   static PragmaClangBSSSectionAttr *Create(ASTContext &Ctx, llvm::StringRef Name, const AttributeCommonInfo &CommonInfo);
11219   static PragmaClangBSSSectionAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Name, SourceRange Range = {});
11220   static PragmaClangBSSSectionAttr *Create(ASTContext &Ctx, llvm::StringRef Name, SourceRange Range = {});
11221 
11222   // Constructors
11223   PragmaClangBSSSectionAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
11224               , llvm::StringRef Name
11225              );
11226 
11227   PragmaClangBSSSectionAttr *clone(ASTContext &C) const;
11228   void printPretty(raw_ostream &OS,
11229                    const PrintingPolicy &Policy) const;
11230   const char *getSpelling() const;
11231   llvm::StringRef getName() const {
11232     return llvm::StringRef(name, nameLength);
11233   }
11234   unsigned getNameLength() const {
11235     return nameLength;
11236   }
11237   void setName(ASTContext &C, llvm::StringRef S) {
11238     nameLength = S.size();
11239     this->name = new (C, 1) char [nameLength];
11240     if (!S.empty())
11241       std::memcpy(this->name, S.data(), nameLength);
11242   }
11243 
11244 
11245 
11246   static bool classof(const Attr *A) { return A->getKind() == attr::PragmaClangBSSSection; }
11247 };
11248 
11249 class CLANG_ABI PragmaClangDataSectionAttr : public InheritableAttr {
11250 unsigned nameLength;
11251 char *name;
11252 
11253 public:
11254   // Factory methods
11255   static PragmaClangDataSectionAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Name, const AttributeCommonInfo &CommonInfo);
11256   static PragmaClangDataSectionAttr *Create(ASTContext &Ctx, llvm::StringRef Name, const AttributeCommonInfo &CommonInfo);
11257   static PragmaClangDataSectionAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Name, SourceRange Range = {});
11258   static PragmaClangDataSectionAttr *Create(ASTContext &Ctx, llvm::StringRef Name, SourceRange Range = {});
11259 
11260   // Constructors
11261   PragmaClangDataSectionAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
11262               , llvm::StringRef Name
11263              );
11264 
11265   PragmaClangDataSectionAttr *clone(ASTContext &C) const;
11266   void printPretty(raw_ostream &OS,
11267                    const PrintingPolicy &Policy) const;
11268   const char *getSpelling() const;
11269   llvm::StringRef getName() const {
11270     return llvm::StringRef(name, nameLength);
11271   }
11272   unsigned getNameLength() const {
11273     return nameLength;
11274   }
11275   void setName(ASTContext &C, llvm::StringRef S) {
11276     nameLength = S.size();
11277     this->name = new (C, 1) char [nameLength];
11278     if (!S.empty())
11279       std::memcpy(this->name, S.data(), nameLength);
11280   }
11281 
11282 
11283 
11284   static bool classof(const Attr *A) { return A->getKind() == attr::PragmaClangDataSection; }
11285 };
11286 
11287 class CLANG_ABI PragmaClangRelroSectionAttr : public InheritableAttr {
11288 unsigned nameLength;
11289 char *name;
11290 
11291 public:
11292   // Factory methods
11293   static PragmaClangRelroSectionAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Name, const AttributeCommonInfo &CommonInfo);
11294   static PragmaClangRelroSectionAttr *Create(ASTContext &Ctx, llvm::StringRef Name, const AttributeCommonInfo &CommonInfo);
11295   static PragmaClangRelroSectionAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Name, SourceRange Range = {});
11296   static PragmaClangRelroSectionAttr *Create(ASTContext &Ctx, llvm::StringRef Name, SourceRange Range = {});
11297 
11298   // Constructors
11299   PragmaClangRelroSectionAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
11300               , llvm::StringRef Name
11301              );
11302 
11303   PragmaClangRelroSectionAttr *clone(ASTContext &C) const;
11304   void printPretty(raw_ostream &OS,
11305                    const PrintingPolicy &Policy) const;
11306   const char *getSpelling() const;
11307   llvm::StringRef getName() const {
11308     return llvm::StringRef(name, nameLength);
11309   }
11310   unsigned getNameLength() const {
11311     return nameLength;
11312   }
11313   void setName(ASTContext &C, llvm::StringRef S) {
11314     nameLength = S.size();
11315     this->name = new (C, 1) char [nameLength];
11316     if (!S.empty())
11317       std::memcpy(this->name, S.data(), nameLength);
11318   }
11319 
11320 
11321 
11322   static bool classof(const Attr *A) { return A->getKind() == attr::PragmaClangRelroSection; }
11323 };
11324 
11325 class CLANG_ABI PragmaClangRodataSectionAttr : public InheritableAttr {
11326 unsigned nameLength;
11327 char *name;
11328 
11329 public:
11330   // Factory methods
11331   static PragmaClangRodataSectionAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Name, const AttributeCommonInfo &CommonInfo);
11332   static PragmaClangRodataSectionAttr *Create(ASTContext &Ctx, llvm::StringRef Name, const AttributeCommonInfo &CommonInfo);
11333   static PragmaClangRodataSectionAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Name, SourceRange Range = {});
11334   static PragmaClangRodataSectionAttr *Create(ASTContext &Ctx, llvm::StringRef Name, SourceRange Range = {});
11335 
11336   // Constructors
11337   PragmaClangRodataSectionAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
11338               , llvm::StringRef Name
11339              );
11340 
11341   PragmaClangRodataSectionAttr *clone(ASTContext &C) const;
11342   void printPretty(raw_ostream &OS,
11343                    const PrintingPolicy &Policy) const;
11344   const char *getSpelling() const;
11345   llvm::StringRef getName() const {
11346     return llvm::StringRef(name, nameLength);
11347   }
11348   unsigned getNameLength() const {
11349     return nameLength;
11350   }
11351   void setName(ASTContext &C, llvm::StringRef S) {
11352     nameLength = S.size();
11353     this->name = new (C, 1) char [nameLength];
11354     if (!S.empty())
11355       std::memcpy(this->name, S.data(), nameLength);
11356   }
11357 
11358 
11359 
11360   static bool classof(const Attr *A) { return A->getKind() == attr::PragmaClangRodataSection; }
11361 };
11362 
11363 class CLANG_ABI PragmaClangTextSectionAttr : public InheritableAttr {
11364 unsigned nameLength;
11365 char *name;
11366 
11367 public:
11368   // Factory methods
11369   static PragmaClangTextSectionAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Name, const AttributeCommonInfo &CommonInfo);
11370   static PragmaClangTextSectionAttr *Create(ASTContext &Ctx, llvm::StringRef Name, const AttributeCommonInfo &CommonInfo);
11371   static PragmaClangTextSectionAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Name, SourceRange Range = {});
11372   static PragmaClangTextSectionAttr *Create(ASTContext &Ctx, llvm::StringRef Name, SourceRange Range = {});
11373 
11374   // Constructors
11375   PragmaClangTextSectionAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
11376               , llvm::StringRef Name
11377              );
11378 
11379   PragmaClangTextSectionAttr *clone(ASTContext &C) const;
11380   void printPretty(raw_ostream &OS,
11381                    const PrintingPolicy &Policy) const;
11382   const char *getSpelling() const;
11383   llvm::StringRef getName() const {
11384     return llvm::StringRef(name, nameLength);
11385   }
11386   unsigned getNameLength() const {
11387     return nameLength;
11388   }
11389   void setName(ASTContext &C, llvm::StringRef S) {
11390     nameLength = S.size();
11391     this->name = new (C, 1) char [nameLength];
11392     if (!S.empty())
11393       std::memcpy(this->name, S.data(), nameLength);
11394   }
11395 
11396 
11397 
11398   static bool classof(const Attr *A) { return A->getKind() == attr::PragmaClangTextSection; }
11399 };
11400 
11401 class CLANG_ABI PreferredNameAttr : public InheritableAttr {
11402 TypeSourceInfo * typedefType;
11403 
11404 public:
11405   enum Spelling {
11406     GNU_preferred_name = 0,
11407     CXX11_clang_preferred_name = 1,
11408   SpellingNotCalculated = 15
11409 
11410   };
11411 
11412   // Factory methods
11413   static PreferredNameAttr *CreateImplicit(ASTContext &Ctx, TypeSourceInfo * TypedefType, const AttributeCommonInfo &CommonInfo);
11414   static PreferredNameAttr *Create(ASTContext &Ctx, TypeSourceInfo * TypedefType, const AttributeCommonInfo &CommonInfo);
11415   static PreferredNameAttr *CreateImplicit(ASTContext &Ctx, TypeSourceInfo * TypedefType, SourceRange Range = {}, Spelling S = GNU_preferred_name);
11416   static PreferredNameAttr *Create(ASTContext &Ctx, TypeSourceInfo * TypedefType, SourceRange Range = {}, Spelling S = GNU_preferred_name);
11417 
11418   // Constructors
11419   PreferredNameAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
11420               , TypeSourceInfo * TypedefType
11421              );
11422 
11423   PreferredNameAttr *clone(ASTContext &C) const;
11424   void printPretty(raw_ostream &OS,
11425                    const PrintingPolicy &Policy) const;
11426   const char *getSpelling() const;
11427   QualType getTypedefType() const {
11428     return typedefType->getType();
11429   }  TypeSourceInfo * getTypedefTypeLoc() const {
11430     return typedefType;
11431   }
11432 
11433 
11434 
11435   static bool classof(const Attr *A) { return A->getKind() == attr::PreferredName; }
11436 };
11437 
11438 class CLANG_ABI PreferredTypeAttr : public InheritableAttr {
11439 TypeSourceInfo * type;
11440 
11441 public:
11442   enum Spelling {
11443     GNU_preferred_type = 0,
11444     CXX11_clang_preferred_type = 1,
11445     C23_clang_preferred_type = 2,
11446   SpellingNotCalculated = 15
11447 
11448   };
11449 
11450   // Factory methods
11451   static PreferredTypeAttr *CreateImplicit(ASTContext &Ctx, TypeSourceInfo * Type, const AttributeCommonInfo &CommonInfo);
11452   static PreferredTypeAttr *Create(ASTContext &Ctx, TypeSourceInfo * Type, const AttributeCommonInfo &CommonInfo);
11453   static PreferredTypeAttr *CreateImplicit(ASTContext &Ctx, TypeSourceInfo * Type, SourceRange Range = {}, Spelling S = GNU_preferred_type);
11454   static PreferredTypeAttr *Create(ASTContext &Ctx, TypeSourceInfo * Type, SourceRange Range = {}, Spelling S = GNU_preferred_type);
11455 
11456   // Constructors
11457   PreferredTypeAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
11458               , TypeSourceInfo * Type
11459              );
11460   PreferredTypeAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
11461              );
11462 
11463   PreferredTypeAttr *clone(ASTContext &C) const;
11464   void printPretty(raw_ostream &OS,
11465                    const PrintingPolicy &Policy) const;
11466   const char *getSpelling() const;
11467   QualType getType() const {
11468     return type->getType();
11469   }  TypeSourceInfo * getTypeLoc() const {
11470     return type;
11471   }
11472 
11473 
11474 
11475   static bool classof(const Attr *A) { return A->getKind() == attr::PreferredType; }
11476 };
11477 
11478 class CLANG_ABI PreserveAllAttr : public InheritableAttr {
11479 public:
11480   enum Spelling {
11481     GNU_preserve_all = 0,
11482     CXX11_clang_preserve_all = 1,
11483     C23_clang_preserve_all = 2,
11484   SpellingNotCalculated = 15
11485 
11486   };
11487 
11488   // Factory methods
11489   static PreserveAllAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
11490   static PreserveAllAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
11491   static PreserveAllAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_preserve_all);
11492   static PreserveAllAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_preserve_all);
11493 
11494   // Constructors
11495   PreserveAllAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
11496              );
11497 
11498   PreserveAllAttr *clone(ASTContext &C) const;
11499   void printPretty(raw_ostream &OS,
11500                    const PrintingPolicy &Policy) const;
11501   const char *getSpelling() const;
11502 
11503 
11504   static bool classof(const Attr *A) { return A->getKind() == attr::PreserveAll; }
11505 };
11506 
11507 class CLANG_ABI PreserveMostAttr : public InheritableAttr {
11508 public:
11509   enum Spelling {
11510     GNU_preserve_most = 0,
11511     CXX11_clang_preserve_most = 1,
11512     C23_clang_preserve_most = 2,
11513   SpellingNotCalculated = 15
11514 
11515   };
11516 
11517   // Factory methods
11518   static PreserveMostAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
11519   static PreserveMostAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
11520   static PreserveMostAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_preserve_most);
11521   static PreserveMostAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_preserve_most);
11522 
11523   // Constructors
11524   PreserveMostAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
11525              );
11526 
11527   PreserveMostAttr *clone(ASTContext &C) const;
11528   void printPretty(raw_ostream &OS,
11529                    const PrintingPolicy &Policy) const;
11530   const char *getSpelling() const;
11531 
11532 
11533   static bool classof(const Attr *A) { return A->getKind() == attr::PreserveMost; }
11534 };
11535 
11536 class CLANG_ABI PreserveNoneAttr : public InheritableAttr {
11537 public:
11538   enum Spelling {
11539     GNU_preserve_none = 0,
11540     CXX11_clang_preserve_none = 1,
11541     C23_clang_preserve_none = 2,
11542   SpellingNotCalculated = 15
11543 
11544   };
11545 
11546   // Factory methods
11547   static PreserveNoneAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
11548   static PreserveNoneAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
11549   static PreserveNoneAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_preserve_none);
11550   static PreserveNoneAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_preserve_none);
11551 
11552   // Constructors
11553   PreserveNoneAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
11554              );
11555 
11556   PreserveNoneAttr *clone(ASTContext &C) const;
11557   void printPretty(raw_ostream &OS,
11558                    const PrintingPolicy &Policy) const;
11559   const char *getSpelling() const;
11560 
11561 
11562   static bool classof(const Attr *A) { return A->getKind() == attr::PreserveNone; }
11563 };
11564 
11565 class CLANG_ABI PtGuardedByAttr : public InheritableAttr {
11566 Expr * arg;
11567 
11568 public:
11569   // Factory methods
11570   static PtGuardedByAttr *CreateImplicit(ASTContext &Ctx, Expr * Arg, const AttributeCommonInfo &CommonInfo);
11571   static PtGuardedByAttr *Create(ASTContext &Ctx, Expr * Arg, const AttributeCommonInfo &CommonInfo);
11572   static PtGuardedByAttr *CreateImplicit(ASTContext &Ctx, Expr * Arg, SourceRange Range = {});
11573   static PtGuardedByAttr *Create(ASTContext &Ctx, Expr * Arg, SourceRange Range = {});
11574 
11575   // Constructors
11576   PtGuardedByAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
11577               , Expr * Arg
11578              );
11579 
11580   PtGuardedByAttr *clone(ASTContext &C) const;
11581   void printPretty(raw_ostream &OS,
11582                    const PrintingPolicy &Policy) const;
11583   const char *getSpelling() const;
11584   Expr * getArg() const {
11585     return arg;
11586   }
11587 
11588 
11589 
11590   static bool classof(const Attr *A) { return A->getKind() == attr::PtGuardedBy; }
11591 };
11592 
11593 class CLANG_ABI PtGuardedVarAttr : public InheritableAttr {
11594 public:
11595   enum Spelling {
11596     GNU_pt_guarded_var = 0,
11597     CXX11_clang_pt_guarded_var = 1,
11598   SpellingNotCalculated = 15
11599 
11600   };
11601 
11602   // Factory methods
11603   static PtGuardedVarAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
11604   static PtGuardedVarAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
11605   static PtGuardedVarAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_pt_guarded_var);
11606   static PtGuardedVarAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_pt_guarded_var);
11607 
11608   // Constructors
11609   PtGuardedVarAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
11610              );
11611 
11612   PtGuardedVarAttr *clone(ASTContext &C) const;
11613   void printPretty(raw_ostream &OS,
11614                    const PrintingPolicy &Policy) const;
11615   const char *getSpelling() const;
11616 
11617 
11618   static bool classof(const Attr *A) { return A->getKind() == attr::PtGuardedVar; }
11619 };
11620 
11621 class CLANG_ABI Ptr32Attr : public TypeAttr {
11622 public:
11623   // Factory methods
11624   static Ptr32Attr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
11625   static Ptr32Attr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
11626   static Ptr32Attr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {});
11627   static Ptr32Attr *Create(ASTContext &Ctx, SourceRange Range = {});
11628 
11629   // Constructors
11630   Ptr32Attr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
11631              );
11632 
11633   Ptr32Attr *clone(ASTContext &C) const;
11634   void printPretty(raw_ostream &OS,
11635                    const PrintingPolicy &Policy) const;
11636   const char *getSpelling() const;
11637 
11638 
11639   static bool classof(const Attr *A) { return A->getKind() == attr::Ptr32; }
11640 };
11641 
11642 class CLANG_ABI Ptr64Attr : public TypeAttr {
11643 public:
11644   // Factory methods
11645   static Ptr64Attr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
11646   static Ptr64Attr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
11647   static Ptr64Attr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {});
11648   static Ptr64Attr *Create(ASTContext &Ctx, SourceRange Range = {});
11649 
11650   // Constructors
11651   Ptr64Attr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
11652              );
11653 
11654   Ptr64Attr *clone(ASTContext &C) const;
11655   void printPretty(raw_ostream &OS,
11656                    const PrintingPolicy &Policy) const;
11657   const char *getSpelling() const;
11658 
11659 
11660   static bool classof(const Attr *A) { return A->getKind() == attr::Ptr64; }
11661 };
11662 
11663 class CLANG_ABI PureAttr : public InheritableAttr {
11664 public:
11665   enum Spelling {
11666     GNU_pure = 0,
11667     CXX11_gnu_pure = 1,
11668     C23_gnu_pure = 2,
11669   SpellingNotCalculated = 15
11670 
11671   };
11672 
11673   // Factory methods
11674   static PureAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
11675   static PureAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
11676   static PureAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_pure);
11677   static PureAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_pure);
11678 
11679   // Constructors
11680   PureAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
11681              );
11682 
11683   PureAttr *clone(ASTContext &C) const;
11684   void printPretty(raw_ostream &OS,
11685                    const PrintingPolicy &Policy) const;
11686   const char *getSpelling() const;
11687 
11688 
11689   static bool classof(const Attr *A) { return A->getKind() == attr::Pure; }
11690 };
11691 
11692 class CLANG_ABI RISCVInterruptAttr : public InheritableAttr {
11693 public:
11694   enum InterruptType {
11695     supervisor,
11696     machine
11697   };
11698 private:
11699   RISCVInterruptAttr::InterruptType interrupt;
11700 
11701 public:
11702   enum Spelling {
11703     GNU_interrupt = 0,
11704     CXX11_gnu_interrupt = 1,
11705     C23_gnu_interrupt = 2,
11706   SpellingNotCalculated = 15
11707 
11708   };
11709 
11710   // Factory methods
11711   static RISCVInterruptAttr *CreateImplicit(ASTContext &Ctx, RISCVInterruptAttr::InterruptType Interrupt, const AttributeCommonInfo &CommonInfo);
11712   static RISCVInterruptAttr *Create(ASTContext &Ctx, RISCVInterruptAttr::InterruptType Interrupt, const AttributeCommonInfo &CommonInfo);
11713   static RISCVInterruptAttr *CreateImplicit(ASTContext &Ctx, RISCVInterruptAttr::InterruptType Interrupt, SourceRange Range = {}, Spelling S = GNU_interrupt);
11714   static RISCVInterruptAttr *Create(ASTContext &Ctx, RISCVInterruptAttr::InterruptType Interrupt, SourceRange Range = {}, Spelling S = GNU_interrupt);
11715 
11716   // Constructors
11717   RISCVInterruptAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
11718               , RISCVInterruptAttr::InterruptType Interrupt
11719              );
11720   RISCVInterruptAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
11721              );
11722 
11723   RISCVInterruptAttr *clone(ASTContext &C) const;
11724   void printPretty(raw_ostream &OS,
11725                    const PrintingPolicy &Policy) const;
11726   const char *getSpelling() const;
11727   RISCVInterruptAttr::InterruptType getInterrupt() const {
11728     return interrupt;
11729   }
11730 
11731   static bool ConvertStrToInterruptType(StringRef Val, RISCVInterruptAttr::InterruptType &Out);
11732   static const char *ConvertInterruptTypeToStr(RISCVInterruptAttr::InterruptType Val);
11733 
11734 
11735   static bool classof(const Attr *A) { return A->getKind() == attr::RISCVInterrupt; }
11736 };
11737 
11738 class CLANG_ABI RISCVVectorCCAttr : public InheritableAttr {
11739 public:
11740   enum Spelling {
11741     CXX11_riscv_vector_cc = 0,
11742     C23_riscv_vector_cc = 1,
11743     GNU_riscv_vector_cc = 2,
11744     CXX11_clang_riscv_vector_cc = 3,
11745     C23_clang_riscv_vector_cc = 4,
11746   SpellingNotCalculated = 15
11747 
11748   };
11749 
11750   // Factory methods
11751   static RISCVVectorCCAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
11752   static RISCVVectorCCAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
11753   static RISCVVectorCCAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = CXX11_riscv_vector_cc);
11754   static RISCVVectorCCAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = CXX11_riscv_vector_cc);
11755 
11756   // Constructors
11757   RISCVVectorCCAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
11758              );
11759 
11760   RISCVVectorCCAttr *clone(ASTContext &C) const;
11761   void printPretty(raw_ostream &OS,
11762                    const PrintingPolicy &Policy) const;
11763   const char *getSpelling() const;
11764   Spelling getSemanticSpelling() const;
11765 
11766 
11767   static bool classof(const Attr *A) { return A->getKind() == attr::RISCVVectorCC; }
11768 };
11769 
11770 class CLANG_ABI RandomizeLayoutAttr : public InheritableAttr {
11771 public:
11772   enum Spelling {
11773     GNU_randomize_layout = 0,
11774     CXX11_gnu_randomize_layout = 1,
11775     C23_gnu_randomize_layout = 2,
11776   SpellingNotCalculated = 15
11777 
11778   };
11779 
11780   // Factory methods
11781   static RandomizeLayoutAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
11782   static RandomizeLayoutAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
11783   static RandomizeLayoutAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_randomize_layout);
11784   static RandomizeLayoutAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_randomize_layout);
11785 
11786   // Constructors
11787   RandomizeLayoutAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
11788              );
11789 
11790   RandomizeLayoutAttr *clone(ASTContext &C) const;
11791   void printPretty(raw_ostream &OS,
11792                    const PrintingPolicy &Policy) const;
11793   const char *getSpelling() const;
11794 
11795 
11796   static bool classof(const Attr *A) { return A->getKind() == attr::RandomizeLayout; }
11797 };
11798 
11799 class CLANG_ABI ReadOnlyPlacementAttr : public InheritableAttr {
11800 public:
11801   enum Spelling {
11802     GNU_enforce_read_only_placement = 0,
11803     CXX11_clang_enforce_read_only_placement = 1,
11804     C23_clang_enforce_read_only_placement = 2,
11805   SpellingNotCalculated = 15
11806 
11807   };
11808 
11809   // Factory methods
11810   static ReadOnlyPlacementAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
11811   static ReadOnlyPlacementAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
11812   static ReadOnlyPlacementAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_enforce_read_only_placement);
11813   static ReadOnlyPlacementAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_enforce_read_only_placement);
11814 
11815   // Constructors
11816   ReadOnlyPlacementAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
11817              );
11818 
11819   ReadOnlyPlacementAttr *clone(ASTContext &C) const;
11820   void printPretty(raw_ostream &OS,
11821                    const PrintingPolicy &Policy) const;
11822   const char *getSpelling() const;
11823 
11824 
11825   static bool classof(const Attr *A) { return A->getKind() == attr::ReadOnlyPlacement; }
11826 };
11827 
11828 class CLANG_ABI RegCallAttr : public InheritableAttr {
11829 public:
11830   enum Spelling {
11831     GNU_regcall = 0,
11832     CXX11_gnu_regcall = 1,
11833     C23_gnu_regcall = 2,
11834     Keyword_regcall = 3,
11835   SpellingNotCalculated = 15
11836 
11837   };
11838 
11839   // Factory methods
11840   static RegCallAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
11841   static RegCallAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
11842   static RegCallAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_regcall);
11843   static RegCallAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_regcall);
11844 
11845   // Constructors
11846   RegCallAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
11847              );
11848 
11849   RegCallAttr *clone(ASTContext &C) const;
11850   void printPretty(raw_ostream &OS,
11851                    const PrintingPolicy &Policy) const;
11852   const char *getSpelling() const;
11853 
11854 
11855   static bool classof(const Attr *A) { return A->getKind() == attr::RegCall; }
11856 };
11857 
11858 class CLANG_ABI ReinitializesAttr : public InheritableAttr {
11859 public:
11860   enum Spelling {
11861     GNU_reinitializes = 0,
11862     CXX11_clang_reinitializes = 1,
11863   SpellingNotCalculated = 15
11864 
11865   };
11866 
11867   // Factory methods
11868   static ReinitializesAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
11869   static ReinitializesAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
11870   static ReinitializesAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_reinitializes);
11871   static ReinitializesAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_reinitializes);
11872 
11873   // Constructors
11874   ReinitializesAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
11875              );
11876 
11877   ReinitializesAttr *clone(ASTContext &C) const;
11878   void printPretty(raw_ostream &OS,
11879                    const PrintingPolicy &Policy) const;
11880   const char *getSpelling() const;
11881 
11882 
11883   static bool classof(const Attr *A) { return A->getKind() == attr::Reinitializes; }
11884 };
11885 
11886 class CLANG_ABI ReleaseCapabilityAttr : public InheritableAttr {
11887   unsigned args_Size;
11888   Expr * *args_;
11889 
11890 public:
11891   enum Spelling {
11892     GNU_release_capability = 0,
11893     CXX11_clang_release_capability = 1,
11894     GNU_release_shared_capability = 2,
11895     CXX11_clang_release_shared_capability = 3,
11896     GNU_release_generic_capability = 4,
11897     CXX11_clang_release_generic_capability = 5,
11898     GNU_unlock_function = 6,
11899     CXX11_clang_unlock_function = 7,
11900   SpellingNotCalculated = 15
11901 
11902   };
11903 
11904   // Factory methods
11905   static ReleaseCapabilityAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo);
11906   static ReleaseCapabilityAttr *Create(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo);
11907   static ReleaseCapabilityAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Range = {}, Spelling S = GNU_release_capability);
11908   static ReleaseCapabilityAttr *Create(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Range = {}, Spelling S = GNU_release_capability);
11909 
11910   // Constructors
11911   ReleaseCapabilityAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
11912               , Expr * *Args, unsigned ArgsSize
11913              );
11914   ReleaseCapabilityAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
11915              );
11916 
11917   ReleaseCapabilityAttr *clone(ASTContext &C) const;
11918   void printPretty(raw_ostream &OS,
11919                    const PrintingPolicy &Policy) const;
11920   const char *getSpelling() const;
11921   Spelling getSemanticSpelling() const;
11922   bool isShared() const { return getAttributeSpellingListIndex() == 2 ||
11923     getAttributeSpellingListIndex() == 3; }
11924   bool isGeneric() const { return getAttributeSpellingListIndex() == 4 ||
11925     getAttributeSpellingListIndex() == 5 ||
11926     getAttributeSpellingListIndex() == 6 ||
11927     getAttributeSpellingListIndex() == 7; }
11928   typedef Expr ** args_iterator;
11929   args_iterator args_begin() const { return args_; }
11930   args_iterator args_end() const { return args_ + args_Size; }
11931   unsigned args_size() const { return args_Size; }
11932   llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }
11933 
11934 
11935 
11936 
11937   static bool classof(const Attr *A) { return A->getKind() == attr::ReleaseCapability; }
11938 };
11939 
11940 class CLANG_ABI ReleaseHandleAttr : public InheritableParamAttr {
11941 unsigned handleTypeLength;
11942 char *handleType;
11943 
11944 public:
11945   enum Spelling {
11946     GNU_release_handle = 0,
11947     CXX11_clang_release_handle = 1,
11948     C23_clang_release_handle = 2,
11949   SpellingNotCalculated = 15
11950 
11951   };
11952 
11953   // Factory methods
11954   static ReleaseHandleAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef HandleType, const AttributeCommonInfo &CommonInfo);
11955   static ReleaseHandleAttr *Create(ASTContext &Ctx, llvm::StringRef HandleType, const AttributeCommonInfo &CommonInfo);
11956   static ReleaseHandleAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef HandleType, SourceRange Range = {}, Spelling S = GNU_release_handle);
11957   static ReleaseHandleAttr *Create(ASTContext &Ctx, llvm::StringRef HandleType, SourceRange Range = {}, Spelling S = GNU_release_handle);
11958 
11959   // Constructors
11960   ReleaseHandleAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
11961               , llvm::StringRef HandleType
11962              );
11963 
11964   ReleaseHandleAttr *clone(ASTContext &C) const;
11965   void printPretty(raw_ostream &OS,
11966                    const PrintingPolicy &Policy) const;
11967   const char *getSpelling() const;
11968   llvm::StringRef getHandleType() const {
11969     return llvm::StringRef(handleType, handleTypeLength);
11970   }
11971   unsigned getHandleTypeLength() const {
11972     return handleTypeLength;
11973   }
11974   void setHandleType(ASTContext &C, llvm::StringRef S) {
11975     handleTypeLength = S.size();
11976     this->handleType = new (C, 1) char [handleTypeLength];
11977     if (!S.empty())
11978       std::memcpy(this->handleType, S.data(), handleTypeLength);
11979   }
11980 
11981 
11982 
11983   static bool classof(const Attr *A) { return A->getKind() == attr::ReleaseHandle; }
11984 };
11985 
11986 class CLANG_ABI ReqdWorkGroupSizeAttr : public InheritableAttr {
11987 unsigned xDim;
11988 
11989 unsigned yDim;
11990 
11991 unsigned zDim;
11992 
11993 public:
11994   // Factory methods
11995   static ReqdWorkGroupSizeAttr *CreateImplicit(ASTContext &Ctx, unsigned XDim, unsigned YDim, unsigned ZDim, const AttributeCommonInfo &CommonInfo);
11996   static ReqdWorkGroupSizeAttr *Create(ASTContext &Ctx, unsigned XDim, unsigned YDim, unsigned ZDim, const AttributeCommonInfo &CommonInfo);
11997   static ReqdWorkGroupSizeAttr *CreateImplicit(ASTContext &Ctx, unsigned XDim, unsigned YDim, unsigned ZDim, SourceRange Range = {});
11998   static ReqdWorkGroupSizeAttr *Create(ASTContext &Ctx, unsigned XDim, unsigned YDim, unsigned ZDim, SourceRange Range = {});
11999 
12000   // Constructors
12001   ReqdWorkGroupSizeAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
12002               , unsigned XDim
12003               , unsigned YDim
12004               , unsigned ZDim
12005              );
12006 
12007   ReqdWorkGroupSizeAttr *clone(ASTContext &C) const;
12008   void printPretty(raw_ostream &OS,
12009                    const PrintingPolicy &Policy) const;
12010   const char *getSpelling() const;
12011   unsigned getXDim() const {
12012     return xDim;
12013   }
12014 
12015   unsigned getYDim() const {
12016     return yDim;
12017   }
12018 
12019   unsigned getZDim() const {
12020     return zDim;
12021   }
12022 
12023 
12024 
12025   static bool classof(const Attr *A) { return A->getKind() == attr::ReqdWorkGroupSize; }
12026 };
12027 
12028 class CLANG_ABI RequiresCapabilityAttr : public InheritableAttr {
12029   unsigned args_Size;
12030   Expr * *args_;
12031 
12032 public:
12033   enum Spelling {
12034     GNU_requires_capability = 0,
12035     CXX11_clang_requires_capability = 1,
12036     GNU_exclusive_locks_required = 2,
12037     CXX11_clang_exclusive_locks_required = 3,
12038     GNU_requires_shared_capability = 4,
12039     CXX11_clang_requires_shared_capability = 5,
12040     GNU_shared_locks_required = 6,
12041     CXX11_clang_shared_locks_required = 7,
12042   SpellingNotCalculated = 15
12043 
12044   };
12045 
12046   // Factory methods
12047   static RequiresCapabilityAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo);
12048   static RequiresCapabilityAttr *Create(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo);
12049   static RequiresCapabilityAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Range = {}, Spelling S = GNU_requires_capability);
12050   static RequiresCapabilityAttr *Create(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Range = {}, Spelling S = GNU_requires_capability);
12051 
12052   // Constructors
12053   RequiresCapabilityAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
12054               , Expr * *Args, unsigned ArgsSize
12055              );
12056   RequiresCapabilityAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
12057              );
12058 
12059   RequiresCapabilityAttr *clone(ASTContext &C) const;
12060   void printPretty(raw_ostream &OS,
12061                    const PrintingPolicy &Policy) const;
12062   const char *getSpelling() const;
12063   Spelling getSemanticSpelling() const;
12064   bool isShared() const { return getAttributeSpellingListIndex() == 4 ||
12065     getAttributeSpellingListIndex() == 5 ||
12066     getAttributeSpellingListIndex() == 6 ||
12067     getAttributeSpellingListIndex() == 7; }
12068   typedef Expr ** args_iterator;
12069   args_iterator args_begin() const { return args_; }
12070   args_iterator args_end() const { return args_ + args_Size; }
12071   unsigned args_size() const { return args_Size; }
12072   llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }
12073 
12074 
12075 
12076 
12077   static bool classof(const Attr *A) { return A->getKind() == attr::RequiresCapability; }
12078 };
12079 
12080 class CLANG_ABI RestrictAttr : public InheritableAttr {
12081 public:
12082   enum Spelling {
12083     Declspec_restrict = 0,
12084     GNU_malloc = 1,
12085     CXX11_gnu_malloc = 2,
12086     C23_gnu_malloc = 3,
12087   SpellingNotCalculated = 15
12088 
12089   };
12090 
12091   // Factory methods
12092   static RestrictAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
12093   static RestrictAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
12094   static RestrictAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = Declspec_restrict);
12095   static RestrictAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = Declspec_restrict);
12096 
12097   // Constructors
12098   RestrictAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
12099              );
12100 
12101   RestrictAttr *clone(ASTContext &C) const;
12102   void printPretty(raw_ostream &OS,
12103                    const PrintingPolicy &Policy) const;
12104   const char *getSpelling() const;
12105   Spelling getSemanticSpelling() const;
12106 
12107 
12108   static bool classof(const Attr *A) { return A->getKind() == attr::Restrict; }
12109 };
12110 
12111 class CLANG_ABI RetainAttr : public InheritableAttr {
12112 public:
12113   enum Spelling {
12114     GNU_retain = 0,
12115     CXX11_gnu_retain = 1,
12116     C23_gnu_retain = 2,
12117   SpellingNotCalculated = 15
12118 
12119   };
12120 
12121   // Factory methods
12122   static RetainAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
12123   static RetainAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
12124   static RetainAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_retain);
12125   static RetainAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_retain);
12126 
12127   // Constructors
12128   RetainAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
12129              );
12130 
12131   RetainAttr *clone(ASTContext &C) const;
12132   void printPretty(raw_ostream &OS,
12133                    const PrintingPolicy &Policy) const;
12134   const char *getSpelling() const;
12135 
12136 
12137   static bool classof(const Attr *A) { return A->getKind() == attr::Retain; }
12138 };
12139 
12140 class CLANG_ABI ReturnTypestateAttr : public InheritableAttr {
12141 public:
12142   enum ConsumedState {
12143     Unknown,
12144     Consumed,
12145     Unconsumed
12146   };
12147 private:
12148   ReturnTypestateAttr::ConsumedState state;
12149 
12150 public:
12151   enum Spelling {
12152     GNU_return_typestate = 0,
12153     CXX11_clang_return_typestate = 1,
12154   SpellingNotCalculated = 15
12155 
12156   };
12157 
12158   // Factory methods
12159   static ReturnTypestateAttr *CreateImplicit(ASTContext &Ctx, ReturnTypestateAttr::ConsumedState State, const AttributeCommonInfo &CommonInfo);
12160   static ReturnTypestateAttr *Create(ASTContext &Ctx, ReturnTypestateAttr::ConsumedState State, const AttributeCommonInfo &CommonInfo);
12161   static ReturnTypestateAttr *CreateImplicit(ASTContext &Ctx, ReturnTypestateAttr::ConsumedState State, SourceRange Range = {}, Spelling S = GNU_return_typestate);
12162   static ReturnTypestateAttr *Create(ASTContext &Ctx, ReturnTypestateAttr::ConsumedState State, SourceRange Range = {}, Spelling S = GNU_return_typestate);
12163 
12164   // Constructors
12165   ReturnTypestateAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
12166               , ReturnTypestateAttr::ConsumedState State
12167              );
12168 
12169   ReturnTypestateAttr *clone(ASTContext &C) const;
12170   void printPretty(raw_ostream &OS,
12171                    const PrintingPolicy &Policy) const;
12172   const char *getSpelling() const;
12173   ReturnTypestateAttr::ConsumedState getState() const {
12174     return state;
12175   }
12176 
12177   static bool ConvertStrToConsumedState(StringRef Val, ReturnTypestateAttr::ConsumedState &Out);
12178   static const char *ConvertConsumedStateToStr(ReturnTypestateAttr::ConsumedState Val);
12179 
12180 
12181   static bool classof(const Attr *A) { return A->getKind() == attr::ReturnTypestate; }
12182 };
12183 
12184 class CLANG_ABI ReturnsNonNullAttr : public InheritableAttr {
12185 public:
12186   enum Spelling {
12187     GNU_returns_nonnull = 0,
12188     CXX11_gnu_returns_nonnull = 1,
12189     C23_gnu_returns_nonnull = 2,
12190   SpellingNotCalculated = 15
12191 
12192   };
12193 
12194   // Factory methods
12195   static ReturnsNonNullAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
12196   static ReturnsNonNullAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
12197   static ReturnsNonNullAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_returns_nonnull);
12198   static ReturnsNonNullAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_returns_nonnull);
12199 
12200   // Constructors
12201   ReturnsNonNullAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
12202              );
12203 
12204   ReturnsNonNullAttr *clone(ASTContext &C) const;
12205   void printPretty(raw_ostream &OS,
12206                    const PrintingPolicy &Policy) const;
12207   const char *getSpelling() const;
12208 
12209 
12210   static bool classof(const Attr *A) { return A->getKind() == attr::ReturnsNonNull; }
12211 };
12212 
12213 class CLANG_ABI ReturnsTwiceAttr : public InheritableAttr {
12214 public:
12215   enum Spelling {
12216     GNU_returns_twice = 0,
12217     CXX11_gnu_returns_twice = 1,
12218     C23_gnu_returns_twice = 2,
12219   SpellingNotCalculated = 15
12220 
12221   };
12222 
12223   // Factory methods
12224   static ReturnsTwiceAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
12225   static ReturnsTwiceAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
12226   static ReturnsTwiceAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_returns_twice);
12227   static ReturnsTwiceAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_returns_twice);
12228 
12229   // Constructors
12230   ReturnsTwiceAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
12231              );
12232 
12233   ReturnsTwiceAttr *clone(ASTContext &C) const;
12234   void printPretty(raw_ostream &OS,
12235                    const PrintingPolicy &Policy) const;
12236   const char *getSpelling() const;
12237 
12238 
12239   static bool classof(const Attr *A) { return A->getKind() == attr::ReturnsTwice; }
12240 };
12241 
12242 class CLANG_ABI SPtrAttr : public TypeAttr {
12243 public:
12244   // Factory methods
12245   static SPtrAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
12246   static SPtrAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
12247   static SPtrAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {});
12248   static SPtrAttr *Create(ASTContext &Ctx, SourceRange Range = {});
12249 
12250   // Constructors
12251   SPtrAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
12252              );
12253 
12254   SPtrAttr *clone(ASTContext &C) const;
12255   void printPretty(raw_ostream &OS,
12256                    const PrintingPolicy &Policy) const;
12257   const char *getSpelling() const;
12258 
12259 
12260   static bool classof(const Attr *A) { return A->getKind() == attr::SPtr; }
12261 };
12262 
12263 class CLANG_ABI SYCLKernelAttr : public InheritableAttr {
12264 public:
12265   enum Spelling {
12266     GNU_sycl_kernel = 0,
12267     CXX11_clang_sycl_kernel = 1,
12268     C23_clang_sycl_kernel = 2,
12269   SpellingNotCalculated = 15
12270 
12271   };
12272 
12273   // Factory methods
12274   static SYCLKernelAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
12275   static SYCLKernelAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
12276   static SYCLKernelAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_sycl_kernel);
12277   static SYCLKernelAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_sycl_kernel);
12278 
12279   // Constructors
12280   SYCLKernelAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
12281              );
12282 
12283   SYCLKernelAttr *clone(ASTContext &C) const;
12284   void printPretty(raw_ostream &OS,
12285                    const PrintingPolicy &Policy) const;
12286   const char *getSpelling() const;
12287 
12288 
12289   static bool classof(const Attr *A) { return A->getKind() == attr::SYCLKernel; }
12290 };
12291 
12292 class CLANG_ABI SYCLKernelEntryPointAttr : public InheritableAttr {
12293 TypeSourceInfo * kernelName;
12294 
12295 bool invalid;
12296 
12297 public:
12298   enum Spelling {
12299     GNU_sycl_kernel_entry_point = 0,
12300     CXX11_clang_sycl_kernel_entry_point = 1,
12301     C23_clang_sycl_kernel_entry_point = 2,
12302   SpellingNotCalculated = 15
12303 
12304   };
12305 
12306   // Factory methods
12307   static SYCLKernelEntryPointAttr *CreateImplicit(ASTContext &Ctx, TypeSourceInfo * KernelName, bool Invalid, const AttributeCommonInfo &CommonInfo);
12308   static SYCLKernelEntryPointAttr *Create(ASTContext &Ctx, TypeSourceInfo * KernelName, bool Invalid, const AttributeCommonInfo &CommonInfo);
12309   static SYCLKernelEntryPointAttr *CreateImplicit(ASTContext &Ctx, TypeSourceInfo * KernelName, bool Invalid, SourceRange Range = {}, Spelling S = GNU_sycl_kernel_entry_point);
12310   static SYCLKernelEntryPointAttr *Create(ASTContext &Ctx, TypeSourceInfo * KernelName, bool Invalid, SourceRange Range = {}, Spelling S = GNU_sycl_kernel_entry_point);
12311   static SYCLKernelEntryPointAttr *CreateImplicit(ASTContext &Ctx, TypeSourceInfo * KernelName, const AttributeCommonInfo &CommonInfo);
12312   static SYCLKernelEntryPointAttr *Create(ASTContext &Ctx, TypeSourceInfo * KernelName, const AttributeCommonInfo &CommonInfo);
12313   static SYCLKernelEntryPointAttr *CreateImplicit(ASTContext &Ctx, TypeSourceInfo * KernelName, SourceRange Range = {}, Spelling S = GNU_sycl_kernel_entry_point);
12314   static SYCLKernelEntryPointAttr *Create(ASTContext &Ctx, TypeSourceInfo * KernelName, SourceRange Range = {}, Spelling S = GNU_sycl_kernel_entry_point);
12315 
12316   // Constructors
12317   SYCLKernelEntryPointAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
12318               , TypeSourceInfo * KernelName
12319               , bool Invalid
12320              );
12321   SYCLKernelEntryPointAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
12322               , TypeSourceInfo * KernelName
12323              );
12324 
12325   SYCLKernelEntryPointAttr *clone(ASTContext &C) const;
12326   void printPretty(raw_ostream &OS,
12327                    const PrintingPolicy &Policy) const;
12328   const char *getSpelling() const;
12329   QualType getKernelName() const {
12330     return kernelName->getType();
12331   }  TypeSourceInfo * getKernelNameLoc() const {
12332     return kernelName;
12333   }
12334 
12335   bool getInvalid() const {
12336     return invalid;
12337   }
12338 
12339   static const bool DefaultInvalid = false;
12340 
12341 
12342     void setInvalidAttr() { invalid = true; }
12343     bool isInvalidAttr() const { return invalid; }
12344   
12345 
12346   static bool classof(const Attr *A) { return A->getKind() == attr::SYCLKernelEntryPoint; }
12347 };
12348 
12349 class CLANG_ABI SYCLSpecialClassAttr : public InheritableAttr {
12350 public:
12351   enum Spelling {
12352     GNU_sycl_special_class = 0,
12353     CXX11_clang_sycl_special_class = 1,
12354     C23_clang_sycl_special_class = 2,
12355   SpellingNotCalculated = 15
12356 
12357   };
12358 
12359   // Factory methods
12360   static SYCLSpecialClassAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
12361   static SYCLSpecialClassAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
12362   static SYCLSpecialClassAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_sycl_special_class);
12363   static SYCLSpecialClassAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_sycl_special_class);
12364 
12365   // Constructors
12366   SYCLSpecialClassAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
12367              );
12368 
12369   SYCLSpecialClassAttr *clone(ASTContext &C) const;
12370   void printPretty(raw_ostream &OS,
12371                    const PrintingPolicy &Policy) const;
12372   const char *getSpelling() const;
12373 
12374 
12375   static bool classof(const Attr *A) { return A->getKind() == attr::SYCLSpecialClass; }
12376 };
12377 
12378 class CLANG_ABI ScopedLockableAttr : public InheritableAttr {
12379 public:
12380   enum Spelling {
12381     GNU_scoped_lockable = 0,
12382     CXX11_clang_scoped_lockable = 1,
12383   SpellingNotCalculated = 15
12384 
12385   };
12386 
12387   // Factory methods
12388   static ScopedLockableAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
12389   static ScopedLockableAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
12390   static ScopedLockableAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_scoped_lockable);
12391   static ScopedLockableAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_scoped_lockable);
12392 
12393   // Constructors
12394   ScopedLockableAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
12395              );
12396 
12397   ScopedLockableAttr *clone(ASTContext &C) const;
12398   void printPretty(raw_ostream &OS,
12399                    const PrintingPolicy &Policy) const;
12400   const char *getSpelling() const;
12401 
12402 
12403   static bool classof(const Attr *A) { return A->getKind() == attr::ScopedLockable; }
12404 };
12405 
12406 class CLANG_ABI SectionAttr : public InheritableAttr {
12407 unsigned nameLength;
12408 char *name;
12409 
12410 public:
12411   enum Spelling {
12412     GNU_section = 0,
12413     CXX11_gnu_section = 1,
12414     C23_gnu_section = 2,
12415     Declspec_allocate = 3,
12416   SpellingNotCalculated = 15
12417 
12418   };
12419 
12420   // Factory methods
12421   static SectionAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Name, const AttributeCommonInfo &CommonInfo);
12422   static SectionAttr *Create(ASTContext &Ctx, llvm::StringRef Name, const AttributeCommonInfo &CommonInfo);
12423   static SectionAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Name, SourceRange Range = {}, Spelling S = GNU_section);
12424   static SectionAttr *Create(ASTContext &Ctx, llvm::StringRef Name, SourceRange Range = {}, Spelling S = GNU_section);
12425 
12426   // Constructors
12427   SectionAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
12428               , llvm::StringRef Name
12429              );
12430 
12431   SectionAttr *clone(ASTContext &C) const;
12432   void printPretty(raw_ostream &OS,
12433                    const PrintingPolicy &Policy) const;
12434   const char *getSpelling() const;
12435   Spelling getSemanticSpelling() const;
12436   llvm::StringRef getName() const {
12437     return llvm::StringRef(name, nameLength);
12438   }
12439   unsigned getNameLength() const {
12440     return nameLength;
12441   }
12442   void setName(ASTContext &C, llvm::StringRef S) {
12443     nameLength = S.size();
12444     this->name = new (C, 1) char [nameLength];
12445     if (!S.empty())
12446       std::memcpy(this->name, S.data(), nameLength);
12447   }
12448 
12449 
12450 
12451   static bool classof(const Attr *A) { return A->getKind() == attr::Section; }
12452 };
12453 
12454 class CLANG_ABI SelectAnyAttr : public InheritableAttr {
12455 public:
12456   enum Spelling {
12457     Declspec_selectany = 0,
12458     GNU_selectany = 1,
12459     CXX11_gnu_selectany = 2,
12460     C23_gnu_selectany = 3,
12461   SpellingNotCalculated = 15
12462 
12463   };
12464 
12465   // Factory methods
12466   static SelectAnyAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
12467   static SelectAnyAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
12468   static SelectAnyAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = Declspec_selectany);
12469   static SelectAnyAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = Declspec_selectany);
12470 
12471   // Constructors
12472   SelectAnyAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
12473              );
12474 
12475   SelectAnyAttr *clone(ASTContext &C) const;
12476   void printPretty(raw_ostream &OS,
12477                    const PrintingPolicy &Policy) const;
12478   const char *getSpelling() const;
12479 
12480 
12481   static bool classof(const Attr *A) { return A->getKind() == attr::SelectAny; }
12482 };
12483 
12484 class CLANG_ABI SentinelAttr : public InheritableAttr {
12485 int sentinel;
12486 
12487 int nullPos;
12488 
12489 public:
12490   enum Spelling {
12491     GNU_sentinel = 0,
12492     CXX11_gnu_sentinel = 1,
12493     C23_gnu_sentinel = 2,
12494   SpellingNotCalculated = 15
12495 
12496   };
12497 
12498   // Factory methods
12499   static SentinelAttr *CreateImplicit(ASTContext &Ctx, int Sentinel, int NullPos, const AttributeCommonInfo &CommonInfo);
12500   static SentinelAttr *Create(ASTContext &Ctx, int Sentinel, int NullPos, const AttributeCommonInfo &CommonInfo);
12501   static SentinelAttr *CreateImplicit(ASTContext &Ctx, int Sentinel, int NullPos, SourceRange Range = {}, Spelling S = GNU_sentinel);
12502   static SentinelAttr *Create(ASTContext &Ctx, int Sentinel, int NullPos, SourceRange Range = {}, Spelling S = GNU_sentinel);
12503 
12504   // Constructors
12505   SentinelAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
12506               , int Sentinel
12507               , int NullPos
12508              );
12509   SentinelAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
12510              );
12511 
12512   SentinelAttr *clone(ASTContext &C) const;
12513   void printPretty(raw_ostream &OS,
12514                    const PrintingPolicy &Policy) const;
12515   const char *getSpelling() const;
12516   int getSentinel() const {
12517     return sentinel;
12518   }
12519 
12520   static const int DefaultSentinel = 0;
12521 
12522   int getNullPos() const {
12523     return nullPos;
12524   }
12525 
12526   static const int DefaultNullPos = 0;
12527 
12528 
12529 
12530   static bool classof(const Attr *A) { return A->getKind() == attr::Sentinel; }
12531 };
12532 
12533 class CLANG_ABI SetTypestateAttr : public InheritableAttr {
12534 public:
12535   enum ConsumedState {
12536     Unknown,
12537     Consumed,
12538     Unconsumed
12539   };
12540 private:
12541   SetTypestateAttr::ConsumedState newState;
12542 
12543 public:
12544   enum Spelling {
12545     GNU_set_typestate = 0,
12546     CXX11_clang_set_typestate = 1,
12547   SpellingNotCalculated = 15
12548 
12549   };
12550 
12551   // Factory methods
12552   static SetTypestateAttr *CreateImplicit(ASTContext &Ctx, SetTypestateAttr::ConsumedState NewState, const AttributeCommonInfo &CommonInfo);
12553   static SetTypestateAttr *Create(ASTContext &Ctx, SetTypestateAttr::ConsumedState NewState, const AttributeCommonInfo &CommonInfo);
12554   static SetTypestateAttr *CreateImplicit(ASTContext &Ctx, SetTypestateAttr::ConsumedState NewState, SourceRange Range = {}, Spelling S = GNU_set_typestate);
12555   static SetTypestateAttr *Create(ASTContext &Ctx, SetTypestateAttr::ConsumedState NewState, SourceRange Range = {}, Spelling S = GNU_set_typestate);
12556 
12557   // Constructors
12558   SetTypestateAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
12559               , SetTypestateAttr::ConsumedState NewState
12560              );
12561 
12562   SetTypestateAttr *clone(ASTContext &C) const;
12563   void printPretty(raw_ostream &OS,
12564                    const PrintingPolicy &Policy) const;
12565   const char *getSpelling() const;
12566   SetTypestateAttr::ConsumedState getNewState() const {
12567     return newState;
12568   }
12569 
12570   static bool ConvertStrToConsumedState(StringRef Val, SetTypestateAttr::ConsumedState &Out);
12571   static const char *ConvertConsumedStateToStr(SetTypestateAttr::ConsumedState Val);
12572 
12573 
12574   static bool classof(const Attr *A) { return A->getKind() == attr::SetTypestate; }
12575 };
12576 
12577 class CLANG_ABI SharedTrylockFunctionAttr : public InheritableAttr {
12578 Expr * successValue;
12579 
12580   unsigned args_Size;
12581   Expr * *args_;
12582 
12583 public:
12584   // Factory methods
12585   static SharedTrylockFunctionAttr *CreateImplicit(ASTContext &Ctx, Expr * SuccessValue, Expr * *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo);
12586   static SharedTrylockFunctionAttr *Create(ASTContext &Ctx, Expr * SuccessValue, Expr * *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo);
12587   static SharedTrylockFunctionAttr *CreateImplicit(ASTContext &Ctx, Expr * SuccessValue, Expr * *Args, unsigned ArgsSize, SourceRange Range = {});
12588   static SharedTrylockFunctionAttr *Create(ASTContext &Ctx, Expr * SuccessValue, Expr * *Args, unsigned ArgsSize, SourceRange Range = {});
12589 
12590   // Constructors
12591   SharedTrylockFunctionAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
12592               , Expr * SuccessValue
12593               , Expr * *Args, unsigned ArgsSize
12594              );
12595   SharedTrylockFunctionAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
12596               , Expr * SuccessValue
12597              );
12598 
12599   SharedTrylockFunctionAttr *clone(ASTContext &C) const;
12600   void printPretty(raw_ostream &OS,
12601                    const PrintingPolicy &Policy) const;
12602   const char *getSpelling() const;
12603   Expr * getSuccessValue() const {
12604     return successValue;
12605   }
12606 
12607   typedef Expr ** args_iterator;
12608   args_iterator args_begin() const { return args_; }
12609   args_iterator args_end() const { return args_ + args_Size; }
12610   unsigned args_size() const { return args_Size; }
12611   llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }
12612 
12613 
12614 
12615 
12616   static bool classof(const Attr *A) { return A->getKind() == attr::SharedTrylockFunction; }
12617 };
12618 
12619 class CLANG_ABI SizedByAttr : public InheritableAttr {
12620 Expr * size;
12621 
12622 int nestedLevel;
12623 
12624 public:
12625   enum Spelling {
12626     GNU_sized_by = 0,
12627     CXX11_clang_sized_by = 1,
12628     C23_clang_sized_by = 2,
12629   SpellingNotCalculated = 15
12630 
12631   };
12632 
12633   // Factory methods
12634   static SizedByAttr *CreateImplicit(ASTContext &Ctx, Expr * Size, int NestedLevel, const AttributeCommonInfo &CommonInfo);
12635   static SizedByAttr *Create(ASTContext &Ctx, Expr * Size, int NestedLevel, const AttributeCommonInfo &CommonInfo);
12636   static SizedByAttr *CreateImplicit(ASTContext &Ctx, Expr * Size, int NestedLevel, SourceRange Range = {}, Spelling S = GNU_sized_by);
12637   static SizedByAttr *Create(ASTContext &Ctx, Expr * Size, int NestedLevel, SourceRange Range = {}, Spelling S = GNU_sized_by);
12638 
12639   // Constructors
12640   SizedByAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
12641               , Expr * Size
12642               , int NestedLevel
12643              );
12644   SizedByAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
12645               , Expr * Size
12646              );
12647 
12648   SizedByAttr *clone(ASTContext &C) const;
12649   void printPretty(raw_ostream &OS,
12650                    const PrintingPolicy &Policy) const;
12651   const char *getSpelling() const;
12652   Expr * getSize() const {
12653     return size;
12654   }
12655 
12656   int getNestedLevel() const {
12657     return nestedLevel;
12658   }
12659 
12660 
12661 
12662   static bool classof(const Attr *A) { return A->getKind() == attr::SizedBy; }
12663 };
12664 
12665 class CLANG_ABI SizedByOrNullAttr : public InheritableAttr {
12666 Expr * size;
12667 
12668 int nestedLevel;
12669 
12670 public:
12671   enum Spelling {
12672     GNU_sized_by_or_null = 0,
12673     CXX11_clang_sized_by_or_null = 1,
12674     C23_clang_sized_by_or_null = 2,
12675   SpellingNotCalculated = 15
12676 
12677   };
12678 
12679   // Factory methods
12680   static SizedByOrNullAttr *CreateImplicit(ASTContext &Ctx, Expr * Size, int NestedLevel, const AttributeCommonInfo &CommonInfo);
12681   static SizedByOrNullAttr *Create(ASTContext &Ctx, Expr * Size, int NestedLevel, const AttributeCommonInfo &CommonInfo);
12682   static SizedByOrNullAttr *CreateImplicit(ASTContext &Ctx, Expr * Size, int NestedLevel, SourceRange Range = {}, Spelling S = GNU_sized_by_or_null);
12683   static SizedByOrNullAttr *Create(ASTContext &Ctx, Expr * Size, int NestedLevel, SourceRange Range = {}, Spelling S = GNU_sized_by_or_null);
12684 
12685   // Constructors
12686   SizedByOrNullAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
12687               , Expr * Size
12688               , int NestedLevel
12689              );
12690   SizedByOrNullAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
12691               , Expr * Size
12692              );
12693 
12694   SizedByOrNullAttr *clone(ASTContext &C) const;
12695   void printPretty(raw_ostream &OS,
12696                    const PrintingPolicy &Policy) const;
12697   const char *getSpelling() const;
12698   Expr * getSize() const {
12699     return size;
12700   }
12701 
12702   int getNestedLevel() const {
12703     return nestedLevel;
12704   }
12705 
12706 
12707 
12708   static bool classof(const Attr *A) { return A->getKind() == attr::SizedByOrNull; }
12709 };
12710 
12711 class CLANG_ABI SpeculativeLoadHardeningAttr : public InheritableAttr {
12712 public:
12713   enum Spelling {
12714     GNU_speculative_load_hardening = 0,
12715     CXX11_clang_speculative_load_hardening = 1,
12716     C23_clang_speculative_load_hardening = 2,
12717   SpellingNotCalculated = 15
12718 
12719   };
12720 
12721   // Factory methods
12722   static SpeculativeLoadHardeningAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
12723   static SpeculativeLoadHardeningAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
12724   static SpeculativeLoadHardeningAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_speculative_load_hardening);
12725   static SpeculativeLoadHardeningAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_speculative_load_hardening);
12726 
12727   // Constructors
12728   SpeculativeLoadHardeningAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
12729              );
12730 
12731   SpeculativeLoadHardeningAttr *clone(ASTContext &C) const;
12732   void printPretty(raw_ostream &OS,
12733                    const PrintingPolicy &Policy) const;
12734   const char *getSpelling() const;
12735 
12736 
12737   static bool classof(const Attr *A) { return A->getKind() == attr::SpeculativeLoadHardening; }
12738 };
12739 
12740 class CLANG_ABI StandaloneDebugAttr : public InheritableAttr {
12741 public:
12742   enum Spelling {
12743     GNU_standalone_debug = 0,
12744     CXX11_clang_standalone_debug = 1,
12745   SpellingNotCalculated = 15
12746 
12747   };
12748 
12749   // Factory methods
12750   static StandaloneDebugAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
12751   static StandaloneDebugAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
12752   static StandaloneDebugAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_standalone_debug);
12753   static StandaloneDebugAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_standalone_debug);
12754 
12755   // Constructors
12756   StandaloneDebugAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
12757              );
12758 
12759   StandaloneDebugAttr *clone(ASTContext &C) const;
12760   void printPretty(raw_ostream &OS,
12761                    const PrintingPolicy &Policy) const;
12762   const char *getSpelling() const;
12763 
12764 
12765   static bool classof(const Attr *A) { return A->getKind() == attr::StandaloneDebug; }
12766 };
12767 
12768 class CLANG_ABI StdCallAttr : public InheritableAttr {
12769 public:
12770   enum Spelling {
12771     GNU_stdcall = 0,
12772     CXX11_gnu_stdcall = 1,
12773     C23_gnu_stdcall = 2,
12774     Keyword_stdcall = 3,
12775   SpellingNotCalculated = 15
12776 
12777   };
12778 
12779   // Factory methods
12780   static StdCallAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
12781   static StdCallAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
12782   static StdCallAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_stdcall);
12783   static StdCallAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_stdcall);
12784 
12785   // Constructors
12786   StdCallAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
12787              );
12788 
12789   StdCallAttr *clone(ASTContext &C) const;
12790   void printPretty(raw_ostream &OS,
12791                    const PrintingPolicy &Policy) const;
12792   const char *getSpelling() const;
12793 
12794 
12795   static bool classof(const Attr *A) { return A->getKind() == attr::StdCall; }
12796 };
12797 
12798 class CLANG_ABI StrictFPAttr : public InheritableAttr {
12799 public:
12800   // Factory methods
12801   static StrictFPAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
12802   static StrictFPAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
12803   static StrictFPAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {});
12804   static StrictFPAttr *Create(ASTContext &Ctx, SourceRange Range = {});
12805 
12806   // Constructors
12807   StrictFPAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
12808              );
12809 
12810   StrictFPAttr *clone(ASTContext &C) const;
12811   void printPretty(raw_ostream &OS,
12812                    const PrintingPolicy &Policy) const;
12813   const char *getSpelling() const;
12814 
12815 
12816   static bool classof(const Attr *A) { return A->getKind() == attr::StrictFP; }
12817 };
12818 
12819 class CLANG_ABI StrictGuardStackCheckAttr : public InheritableAttr {
12820 public:
12821   // Factory methods
12822   static StrictGuardStackCheckAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
12823   static StrictGuardStackCheckAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
12824   static StrictGuardStackCheckAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {});
12825   static StrictGuardStackCheckAttr *Create(ASTContext &Ctx, SourceRange Range = {});
12826 
12827   // Constructors
12828   StrictGuardStackCheckAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
12829              );
12830 
12831   StrictGuardStackCheckAttr *clone(ASTContext &C) const;
12832   void printPretty(raw_ostream &OS,
12833                    const PrintingPolicy &Policy) const;
12834   const char *getSpelling() const;
12835 
12836 
12837   static bool classof(const Attr *A) { return A->getKind() == attr::StrictGuardStackCheck; }
12838 };
12839 
12840 class CLANG_ABI SuppressAttr : public DeclOrStmtAttr {
12841   unsigned diagnosticIdentifiers_Size;
12842   StringRef *diagnosticIdentifiers_;
12843 
12844 public:
12845   enum Spelling {
12846     CXX11_gsl_suppress = 0,
12847     GNU_suppress = 1,
12848     CXX11_clang_suppress = 2,
12849     C23_clang_suppress = 3,
12850   SpellingNotCalculated = 15
12851 
12852   };
12853 
12854   // Factory methods
12855   static SuppressAttr *CreateImplicit(ASTContext &Ctx, StringRef *DiagnosticIdentifiers, unsigned DiagnosticIdentifiersSize, const AttributeCommonInfo &CommonInfo);
12856   static SuppressAttr *Create(ASTContext &Ctx, StringRef *DiagnosticIdentifiers, unsigned DiagnosticIdentifiersSize, const AttributeCommonInfo &CommonInfo);
12857   static SuppressAttr *CreateImplicit(ASTContext &Ctx, StringRef *DiagnosticIdentifiers, unsigned DiagnosticIdentifiersSize, SourceRange Range = {}, Spelling S = CXX11_gsl_suppress);
12858   static SuppressAttr *Create(ASTContext &Ctx, StringRef *DiagnosticIdentifiers, unsigned DiagnosticIdentifiersSize, SourceRange Range = {}, Spelling S = CXX11_gsl_suppress);
12859 
12860   // Constructors
12861   SuppressAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
12862               , StringRef *DiagnosticIdentifiers, unsigned DiagnosticIdentifiersSize
12863              );
12864   SuppressAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
12865              );
12866 
12867   SuppressAttr *clone(ASTContext &C) const;
12868   void printPretty(raw_ostream &OS,
12869                    const PrintingPolicy &Policy) const;
12870   const char *getSpelling() const;
12871   bool isGSL() const { return getAttributeSpellingListIndex() == 0; }
12872   typedef StringRef* diagnosticIdentifiers_iterator;
12873   diagnosticIdentifiers_iterator diagnosticIdentifiers_begin() const { return diagnosticIdentifiers_; }
12874   diagnosticIdentifiers_iterator diagnosticIdentifiers_end() const { return diagnosticIdentifiers_ + diagnosticIdentifiers_Size; }
12875   unsigned diagnosticIdentifiers_size() const { return diagnosticIdentifiers_Size; }
12876   llvm::iterator_range<diagnosticIdentifiers_iterator> diagnosticIdentifiers() const { return llvm::make_range(diagnosticIdentifiers_begin(), diagnosticIdentifiers_end()); }
12877 
12878 
12879 
12880 
12881   static bool classof(const Attr *A) { return A->getKind() == attr::Suppress; }
12882 };
12883 
12884 class CLANG_ABI SwiftAsyncAttr : public InheritableAttr {
12885 public:
12886   enum Kind {
12887     None,
12888     SwiftPrivate,
12889     NotSwiftPrivate
12890   };
12891 private:
12892   SwiftAsyncAttr::Kind kind;
12893 
12894 ParamIdx completionHandlerIndex;
12895 
12896 public:
12897   enum Spelling {
12898     GNU_swift_async = 0,
12899     CXX11_clang_swift_async = 1,
12900     C23_clang_swift_async = 2,
12901   SpellingNotCalculated = 15
12902 
12903   };
12904 
12905   // Factory methods
12906   static SwiftAsyncAttr *CreateImplicit(ASTContext &Ctx, SwiftAsyncAttr::Kind Kind, ParamIdx CompletionHandlerIndex, const AttributeCommonInfo &CommonInfo);
12907   static SwiftAsyncAttr *Create(ASTContext &Ctx, SwiftAsyncAttr::Kind Kind, ParamIdx CompletionHandlerIndex, const AttributeCommonInfo &CommonInfo);
12908   static SwiftAsyncAttr *CreateImplicit(ASTContext &Ctx, SwiftAsyncAttr::Kind Kind, ParamIdx CompletionHandlerIndex, SourceRange Range = {}, Spelling S = GNU_swift_async);
12909   static SwiftAsyncAttr *Create(ASTContext &Ctx, SwiftAsyncAttr::Kind Kind, ParamIdx CompletionHandlerIndex, SourceRange Range = {}, Spelling S = GNU_swift_async);
12910 
12911   // Constructors
12912   SwiftAsyncAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
12913               , SwiftAsyncAttr::Kind Kind
12914               , ParamIdx CompletionHandlerIndex
12915              );
12916   SwiftAsyncAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
12917               , SwiftAsyncAttr::Kind Kind
12918              );
12919 
12920   SwiftAsyncAttr *clone(ASTContext &C) const;
12921   void printPretty(raw_ostream &OS,
12922                    const PrintingPolicy &Policy) const;
12923   const char *getSpelling() const;
12924   SwiftAsyncAttr::Kind getKind() const {
12925     return kind;
12926   }
12927 
12928   static bool ConvertStrToKind(StringRef Val, SwiftAsyncAttr::Kind &Out);
12929   static const char *ConvertKindToStr(SwiftAsyncAttr::Kind Val);
12930   ParamIdx getCompletionHandlerIndex() const {
12931     return completionHandlerIndex;
12932   }
12933 
12934 
12935 
12936   static bool classof(const Attr *A) { return A->getKind() == attr::SwiftAsync; }
12937 };
12938 
12939 class CLANG_ABI SwiftAsyncCallAttr : public InheritableAttr {
12940 public:
12941   enum Spelling {
12942     GNU_swiftasynccall = 0,
12943     CXX11_clang_swiftasynccall = 1,
12944     C23_clang_swiftasynccall = 2,
12945   SpellingNotCalculated = 15
12946 
12947   };
12948 
12949   // Factory methods
12950   static SwiftAsyncCallAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
12951   static SwiftAsyncCallAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
12952   static SwiftAsyncCallAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_swiftasynccall);
12953   static SwiftAsyncCallAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_swiftasynccall);
12954 
12955   // Constructors
12956   SwiftAsyncCallAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
12957              );
12958 
12959   SwiftAsyncCallAttr *clone(ASTContext &C) const;
12960   void printPretty(raw_ostream &OS,
12961                    const PrintingPolicy &Policy) const;
12962   const char *getSpelling() const;
12963 
12964 
12965   static bool classof(const Attr *A) { return A->getKind() == attr::SwiftAsyncCall; }
12966 };
12967 
12968 class CLANG_ABI SwiftAsyncContextAttr : public ParameterABIAttr {
12969 public:
12970   enum Spelling {
12971     GNU_swift_async_context = 0,
12972     CXX11_clang_swift_async_context = 1,
12973     C23_clang_swift_async_context = 2,
12974   SpellingNotCalculated = 15
12975 
12976   };
12977 
12978   // Factory methods
12979   static SwiftAsyncContextAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
12980   static SwiftAsyncContextAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
12981   static SwiftAsyncContextAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_swift_async_context);
12982   static SwiftAsyncContextAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_swift_async_context);
12983 
12984   // Constructors
12985   SwiftAsyncContextAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
12986              );
12987 
12988   SwiftAsyncContextAttr *clone(ASTContext &C) const;
12989   void printPretty(raw_ostream &OS,
12990                    const PrintingPolicy &Policy) const;
12991   const char *getSpelling() const;
12992 
12993 
12994   static bool classof(const Attr *A) { return A->getKind() == attr::SwiftAsyncContext; }
12995 };
12996 
12997 class CLANG_ABI SwiftAsyncErrorAttr : public InheritableAttr {
12998 public:
12999   enum ConventionKind {
13000     None,
13001     NonNullError,
13002     ZeroArgument,
13003     NonZeroArgument
13004   };
13005 private:
13006   SwiftAsyncErrorAttr::ConventionKind convention;
13007 
13008 unsigned handlerParamIdx;
13009 
13010 public:
13011   enum Spelling {
13012     GNU_swift_async_error = 0,
13013     CXX11_clang_swift_async_error = 1,
13014     C23_clang_swift_async_error = 2,
13015   SpellingNotCalculated = 15
13016 
13017   };
13018 
13019   // Factory methods
13020   static SwiftAsyncErrorAttr *CreateImplicit(ASTContext &Ctx, SwiftAsyncErrorAttr::ConventionKind Convention, unsigned HandlerParamIdx, const AttributeCommonInfo &CommonInfo);
13021   static SwiftAsyncErrorAttr *Create(ASTContext &Ctx, SwiftAsyncErrorAttr::ConventionKind Convention, unsigned HandlerParamIdx, const AttributeCommonInfo &CommonInfo);
13022   static SwiftAsyncErrorAttr *CreateImplicit(ASTContext &Ctx, SwiftAsyncErrorAttr::ConventionKind Convention, unsigned HandlerParamIdx, SourceRange Range = {}, Spelling S = GNU_swift_async_error);
13023   static SwiftAsyncErrorAttr *Create(ASTContext &Ctx, SwiftAsyncErrorAttr::ConventionKind Convention, unsigned HandlerParamIdx, SourceRange Range = {}, Spelling S = GNU_swift_async_error);
13024 
13025   // Constructors
13026   SwiftAsyncErrorAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
13027               , SwiftAsyncErrorAttr::ConventionKind Convention
13028               , unsigned HandlerParamIdx
13029              );
13030   SwiftAsyncErrorAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
13031               , SwiftAsyncErrorAttr::ConventionKind Convention
13032              );
13033 
13034   SwiftAsyncErrorAttr *clone(ASTContext &C) const;
13035   void printPretty(raw_ostream &OS,
13036                    const PrintingPolicy &Policy) const;
13037   const char *getSpelling() const;
13038   SwiftAsyncErrorAttr::ConventionKind getConvention() const {
13039     return convention;
13040   }
13041 
13042   static bool ConvertStrToConventionKind(StringRef Val, SwiftAsyncErrorAttr::ConventionKind &Out);
13043   static const char *ConvertConventionKindToStr(SwiftAsyncErrorAttr::ConventionKind Val);
13044   unsigned getHandlerParamIdx() const {
13045     return handlerParamIdx;
13046   }
13047 
13048 
13049 
13050   static bool classof(const Attr *A) { return A->getKind() == attr::SwiftAsyncError; }
13051 };
13052 
13053 class CLANG_ABI SwiftAsyncNameAttr : public InheritableAttr {
13054 unsigned nameLength;
13055 char *name;
13056 
13057 public:
13058   // Factory methods
13059   static SwiftAsyncNameAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Name, const AttributeCommonInfo &CommonInfo);
13060   static SwiftAsyncNameAttr *Create(ASTContext &Ctx, llvm::StringRef Name, const AttributeCommonInfo &CommonInfo);
13061   static SwiftAsyncNameAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Name, SourceRange Range = {});
13062   static SwiftAsyncNameAttr *Create(ASTContext &Ctx, llvm::StringRef Name, SourceRange Range = {});
13063 
13064   // Constructors
13065   SwiftAsyncNameAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
13066               , llvm::StringRef Name
13067              );
13068 
13069   SwiftAsyncNameAttr *clone(ASTContext &C) const;
13070   void printPretty(raw_ostream &OS,
13071                    const PrintingPolicy &Policy) const;
13072   const char *getSpelling() const;
13073   llvm::StringRef getName() const {
13074     return llvm::StringRef(name, nameLength);
13075   }
13076   unsigned getNameLength() const {
13077     return nameLength;
13078   }
13079   void setName(ASTContext &C, llvm::StringRef S) {
13080     nameLength = S.size();
13081     this->name = new (C, 1) char [nameLength];
13082     if (!S.empty())
13083       std::memcpy(this->name, S.data(), nameLength);
13084   }
13085 
13086 
13087 
13088   static bool classof(const Attr *A) { return A->getKind() == attr::SwiftAsyncName; }
13089 };
13090 
13091 class CLANG_ABI SwiftAttrAttr : public InheritableAttr {
13092 unsigned attributeLength;
13093 char *attribute;
13094 
13095 public:
13096   // Factory methods
13097   static SwiftAttrAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Attribute, const AttributeCommonInfo &CommonInfo);
13098   static SwiftAttrAttr *Create(ASTContext &Ctx, llvm::StringRef Attribute, const AttributeCommonInfo &CommonInfo);
13099   static SwiftAttrAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Attribute, SourceRange Range = {});
13100   static SwiftAttrAttr *Create(ASTContext &Ctx, llvm::StringRef Attribute, SourceRange Range = {});
13101 
13102   // Constructors
13103   SwiftAttrAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
13104               , llvm::StringRef Attribute
13105              );
13106 
13107   SwiftAttrAttr *clone(ASTContext &C) const;
13108   void printPretty(raw_ostream &OS,
13109                    const PrintingPolicy &Policy) const;
13110   const char *getSpelling() const;
13111   llvm::StringRef getAttribute() const {
13112     return llvm::StringRef(attribute, attributeLength);
13113   }
13114   unsigned getAttributeLength() const {
13115     return attributeLength;
13116   }
13117   void setAttribute(ASTContext &C, llvm::StringRef S) {
13118     attributeLength = S.size();
13119     this->attribute = new (C, 1) char [attributeLength];
13120     if (!S.empty())
13121       std::memcpy(this->attribute, S.data(), attributeLength);
13122   }
13123 
13124 
13125 
13126   static bool classof(const Attr *A) { return A->getKind() == attr::SwiftAttr; }
13127 };
13128 
13129 class CLANG_ABI SwiftBridgeAttr : public InheritableAttr {
13130 unsigned swiftTypeLength;
13131 char *swiftType;
13132 
13133 public:
13134   // Factory methods
13135   static SwiftBridgeAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef SwiftType, const AttributeCommonInfo &CommonInfo);
13136   static SwiftBridgeAttr *Create(ASTContext &Ctx, llvm::StringRef SwiftType, const AttributeCommonInfo &CommonInfo);
13137   static SwiftBridgeAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef SwiftType, SourceRange Range = {});
13138   static SwiftBridgeAttr *Create(ASTContext &Ctx, llvm::StringRef SwiftType, SourceRange Range = {});
13139 
13140   // Constructors
13141   SwiftBridgeAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
13142               , llvm::StringRef SwiftType
13143              );
13144 
13145   SwiftBridgeAttr *clone(ASTContext &C) const;
13146   void printPretty(raw_ostream &OS,
13147                    const PrintingPolicy &Policy) const;
13148   const char *getSpelling() const;
13149   llvm::StringRef getSwiftType() const {
13150     return llvm::StringRef(swiftType, swiftTypeLength);
13151   }
13152   unsigned getSwiftTypeLength() const {
13153     return swiftTypeLength;
13154   }
13155   void setSwiftType(ASTContext &C, llvm::StringRef S) {
13156     swiftTypeLength = S.size();
13157     this->swiftType = new (C, 1) char [swiftTypeLength];
13158     if (!S.empty())
13159       std::memcpy(this->swiftType, S.data(), swiftTypeLength);
13160   }
13161 
13162 
13163 
13164   static bool classof(const Attr *A) { return A->getKind() == attr::SwiftBridge; }
13165 };
13166 
13167 class CLANG_ABI SwiftBridgedTypedefAttr : public InheritableAttr {
13168 public:
13169   // Factory methods
13170   static SwiftBridgedTypedefAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
13171   static SwiftBridgedTypedefAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
13172   static SwiftBridgedTypedefAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {});
13173   static SwiftBridgedTypedefAttr *Create(ASTContext &Ctx, SourceRange Range = {});
13174 
13175   // Constructors
13176   SwiftBridgedTypedefAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
13177              );
13178 
13179   SwiftBridgedTypedefAttr *clone(ASTContext &C) const;
13180   void printPretty(raw_ostream &OS,
13181                    const PrintingPolicy &Policy) const;
13182   const char *getSpelling() const;
13183 
13184 
13185   static bool classof(const Attr *A) { return A->getKind() == attr::SwiftBridgedTypedef; }
13186 };
13187 
13188 class CLANG_ABI SwiftCallAttr : public InheritableAttr {
13189 public:
13190   enum Spelling {
13191     GNU_swiftcall = 0,
13192     CXX11_clang_swiftcall = 1,
13193     C23_clang_swiftcall = 2,
13194   SpellingNotCalculated = 15
13195 
13196   };
13197 
13198   // Factory methods
13199   static SwiftCallAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
13200   static SwiftCallAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
13201   static SwiftCallAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_swiftcall);
13202   static SwiftCallAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_swiftcall);
13203 
13204   // Constructors
13205   SwiftCallAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
13206              );
13207 
13208   SwiftCallAttr *clone(ASTContext &C) const;
13209   void printPretty(raw_ostream &OS,
13210                    const PrintingPolicy &Policy) const;
13211   const char *getSpelling() const;
13212 
13213 
13214   static bool classof(const Attr *A) { return A->getKind() == attr::SwiftCall; }
13215 };
13216 
13217 class CLANG_ABI SwiftContextAttr : public ParameterABIAttr {
13218 public:
13219   enum Spelling {
13220     GNU_swift_context = 0,
13221     CXX11_clang_swift_context = 1,
13222     C23_clang_swift_context = 2,
13223   SpellingNotCalculated = 15
13224 
13225   };
13226 
13227   // Factory methods
13228   static SwiftContextAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
13229   static SwiftContextAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
13230   static SwiftContextAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_swift_context);
13231   static SwiftContextAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_swift_context);
13232 
13233   // Constructors
13234   SwiftContextAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
13235              );
13236 
13237   SwiftContextAttr *clone(ASTContext &C) const;
13238   void printPretty(raw_ostream &OS,
13239                    const PrintingPolicy &Policy) const;
13240   const char *getSpelling() const;
13241 
13242 
13243   static bool classof(const Attr *A) { return A->getKind() == attr::SwiftContext; }
13244 };
13245 
13246 class CLANG_ABI SwiftErrorAttr : public InheritableAttr {
13247 public:
13248   enum ConventionKind {
13249     None,
13250     NonNullError,
13251     NullResult,
13252     ZeroResult,
13253     NonZeroResult
13254   };
13255 private:
13256   SwiftErrorAttr::ConventionKind convention;
13257 
13258 public:
13259   // Factory methods
13260   static SwiftErrorAttr *CreateImplicit(ASTContext &Ctx, SwiftErrorAttr::ConventionKind Convention, const AttributeCommonInfo &CommonInfo);
13261   static SwiftErrorAttr *Create(ASTContext &Ctx, SwiftErrorAttr::ConventionKind Convention, const AttributeCommonInfo &CommonInfo);
13262   static SwiftErrorAttr *CreateImplicit(ASTContext &Ctx, SwiftErrorAttr::ConventionKind Convention, SourceRange Range = {});
13263   static SwiftErrorAttr *Create(ASTContext &Ctx, SwiftErrorAttr::ConventionKind Convention, SourceRange Range = {});
13264 
13265   // Constructors
13266   SwiftErrorAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
13267               , SwiftErrorAttr::ConventionKind Convention
13268              );
13269 
13270   SwiftErrorAttr *clone(ASTContext &C) const;
13271   void printPretty(raw_ostream &OS,
13272                    const PrintingPolicy &Policy) const;
13273   const char *getSpelling() const;
13274   SwiftErrorAttr::ConventionKind getConvention() const {
13275     return convention;
13276   }
13277 
13278   static bool ConvertStrToConventionKind(StringRef Val, SwiftErrorAttr::ConventionKind &Out);
13279   static const char *ConvertConventionKindToStr(SwiftErrorAttr::ConventionKind Val);
13280 
13281 
13282   static bool classof(const Attr *A) { return A->getKind() == attr::SwiftError; }
13283 };
13284 
13285 class CLANG_ABI SwiftErrorResultAttr : public ParameterABIAttr {
13286 public:
13287   enum Spelling {
13288     GNU_swift_error_result = 0,
13289     CXX11_clang_swift_error_result = 1,
13290     C23_clang_swift_error_result = 2,
13291   SpellingNotCalculated = 15
13292 
13293   };
13294 
13295   // Factory methods
13296   static SwiftErrorResultAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
13297   static SwiftErrorResultAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
13298   static SwiftErrorResultAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_swift_error_result);
13299   static SwiftErrorResultAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_swift_error_result);
13300 
13301   // Constructors
13302   SwiftErrorResultAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
13303              );
13304 
13305   SwiftErrorResultAttr *clone(ASTContext &C) const;
13306   void printPretty(raw_ostream &OS,
13307                    const PrintingPolicy &Policy) const;
13308   const char *getSpelling() const;
13309 
13310 
13311   static bool classof(const Attr *A) { return A->getKind() == attr::SwiftErrorResult; }
13312 };
13313 
13314 class CLANG_ABI SwiftImportAsNonGenericAttr : public InheritableAttr {
13315 public:
13316   // Factory methods
13317   static SwiftImportAsNonGenericAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
13318   static SwiftImportAsNonGenericAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
13319   static SwiftImportAsNonGenericAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {});
13320   static SwiftImportAsNonGenericAttr *Create(ASTContext &Ctx, SourceRange Range = {});
13321 
13322   // Constructors
13323   SwiftImportAsNonGenericAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
13324              );
13325 
13326   SwiftImportAsNonGenericAttr *clone(ASTContext &C) const;
13327   void printPretty(raw_ostream &OS,
13328                    const PrintingPolicy &Policy) const;
13329   const char *getSpelling() const;
13330 
13331 
13332   static bool classof(const Attr *A) { return A->getKind() == attr::SwiftImportAsNonGeneric; }
13333 };
13334 
13335 class CLANG_ABI SwiftImportPropertyAsAccessorsAttr : public InheritableAttr {
13336 public:
13337   // Factory methods
13338   static SwiftImportPropertyAsAccessorsAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
13339   static SwiftImportPropertyAsAccessorsAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
13340   static SwiftImportPropertyAsAccessorsAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {});
13341   static SwiftImportPropertyAsAccessorsAttr *Create(ASTContext &Ctx, SourceRange Range = {});
13342 
13343   // Constructors
13344   SwiftImportPropertyAsAccessorsAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
13345              );
13346 
13347   SwiftImportPropertyAsAccessorsAttr *clone(ASTContext &C) const;
13348   void printPretty(raw_ostream &OS,
13349                    const PrintingPolicy &Policy) const;
13350   const char *getSpelling() const;
13351 
13352 
13353   static bool classof(const Attr *A) { return A->getKind() == attr::SwiftImportPropertyAsAccessors; }
13354 };
13355 
13356 class CLANG_ABI SwiftIndirectResultAttr : public ParameterABIAttr {
13357 public:
13358   enum Spelling {
13359     GNU_swift_indirect_result = 0,
13360     CXX11_clang_swift_indirect_result = 1,
13361     C23_clang_swift_indirect_result = 2,
13362   SpellingNotCalculated = 15
13363 
13364   };
13365 
13366   // Factory methods
13367   static SwiftIndirectResultAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
13368   static SwiftIndirectResultAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
13369   static SwiftIndirectResultAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_swift_indirect_result);
13370   static SwiftIndirectResultAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_swift_indirect_result);
13371 
13372   // Constructors
13373   SwiftIndirectResultAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
13374              );
13375 
13376   SwiftIndirectResultAttr *clone(ASTContext &C) const;
13377   void printPretty(raw_ostream &OS,
13378                    const PrintingPolicy &Policy) const;
13379   const char *getSpelling() const;
13380 
13381 
13382   static bool classof(const Attr *A) { return A->getKind() == attr::SwiftIndirectResult; }
13383 };
13384 
13385 class CLANG_ABI SwiftNameAttr : public InheritableAttr {
13386 unsigned nameLength;
13387 char *name;
13388 
13389 public:
13390   // Factory methods
13391   static SwiftNameAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Name, const AttributeCommonInfo &CommonInfo);
13392   static SwiftNameAttr *Create(ASTContext &Ctx, llvm::StringRef Name, const AttributeCommonInfo &CommonInfo);
13393   static SwiftNameAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Name, SourceRange Range = {});
13394   static SwiftNameAttr *Create(ASTContext &Ctx, llvm::StringRef Name, SourceRange Range = {});
13395 
13396   // Constructors
13397   SwiftNameAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
13398               , llvm::StringRef Name
13399              );
13400 
13401   SwiftNameAttr *clone(ASTContext &C) const;
13402   void printPretty(raw_ostream &OS,
13403                    const PrintingPolicy &Policy) const;
13404   const char *getSpelling() const;
13405   llvm::StringRef getName() const {
13406     return llvm::StringRef(name, nameLength);
13407   }
13408   unsigned getNameLength() const {
13409     return nameLength;
13410   }
13411   void setName(ASTContext &C, llvm::StringRef S) {
13412     nameLength = S.size();
13413     this->name = new (C, 1) char [nameLength];
13414     if (!S.empty())
13415       std::memcpy(this->name, S.data(), nameLength);
13416   }
13417 
13418 
13419 
13420   static bool classof(const Attr *A) { return A->getKind() == attr::SwiftName; }
13421 };
13422 
13423 class CLANG_ABI SwiftNewTypeAttr : public InheritableAttr {
13424 public:
13425   enum NewtypeKind {
13426     NK_Struct,
13427     NK_Enum
13428   };
13429 private:
13430   SwiftNewTypeAttr::NewtypeKind newtypeKind;
13431 
13432 public:
13433   enum Spelling {
13434     GNU_swift_newtype = 0,
13435     GNU_swift_wrapper = 1,
13436   SpellingNotCalculated = 15
13437 
13438   };
13439 
13440   // Factory methods
13441   static SwiftNewTypeAttr *CreateImplicit(ASTContext &Ctx, SwiftNewTypeAttr::NewtypeKind NewtypeKind, const AttributeCommonInfo &CommonInfo);
13442   static SwiftNewTypeAttr *Create(ASTContext &Ctx, SwiftNewTypeAttr::NewtypeKind NewtypeKind, const AttributeCommonInfo &CommonInfo);
13443   static SwiftNewTypeAttr *CreateImplicit(ASTContext &Ctx, SwiftNewTypeAttr::NewtypeKind NewtypeKind, SourceRange Range = {}, Spelling S = GNU_swift_newtype);
13444   static SwiftNewTypeAttr *Create(ASTContext &Ctx, SwiftNewTypeAttr::NewtypeKind NewtypeKind, SourceRange Range = {}, Spelling S = GNU_swift_newtype);
13445 
13446   // Constructors
13447   SwiftNewTypeAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
13448               , SwiftNewTypeAttr::NewtypeKind NewtypeKind
13449              );
13450 
13451   SwiftNewTypeAttr *clone(ASTContext &C) const;
13452   void printPretty(raw_ostream &OS,
13453                    const PrintingPolicy &Policy) const;
13454   const char *getSpelling() const;
13455   Spelling getSemanticSpelling() const;
13456   SwiftNewTypeAttr::NewtypeKind getNewtypeKind() const {
13457     return newtypeKind;
13458   }
13459 
13460   static bool ConvertStrToNewtypeKind(StringRef Val, SwiftNewTypeAttr::NewtypeKind &Out);
13461   static const char *ConvertNewtypeKindToStr(SwiftNewTypeAttr::NewtypeKind Val);
13462 
13463 
13464   static bool classof(const Attr *A) { return A->getKind() == attr::SwiftNewType; }
13465 };
13466 
13467 class CLANG_ABI SwiftObjCMembersAttr : public Attr {
13468 public:
13469   // Factory methods
13470   static SwiftObjCMembersAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
13471   static SwiftObjCMembersAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
13472   static SwiftObjCMembersAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {});
13473   static SwiftObjCMembersAttr *Create(ASTContext &Ctx, SourceRange Range = {});
13474 
13475   // Constructors
13476   SwiftObjCMembersAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
13477              );
13478 
13479   SwiftObjCMembersAttr *clone(ASTContext &C) const;
13480   void printPretty(raw_ostream &OS,
13481                    const PrintingPolicy &Policy) const;
13482   const char *getSpelling() const;
13483 
13484 
13485   static bool classof(const Attr *A) { return A->getKind() == attr::SwiftObjCMembers; }
13486 };
13487 
13488 class CLANG_ABI SwiftPrivateAttr : public InheritableAttr {
13489 public:
13490   // Factory methods
13491   static SwiftPrivateAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
13492   static SwiftPrivateAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
13493   static SwiftPrivateAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {});
13494   static SwiftPrivateAttr *Create(ASTContext &Ctx, SourceRange Range = {});
13495 
13496   // Constructors
13497   SwiftPrivateAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
13498              );
13499 
13500   SwiftPrivateAttr *clone(ASTContext &C) const;
13501   void printPretty(raw_ostream &OS,
13502                    const PrintingPolicy &Policy) const;
13503   const char *getSpelling() const;
13504 
13505 
13506   static bool classof(const Attr *A) { return A->getKind() == attr::SwiftPrivate; }
13507 };
13508 
13509 class CLANG_ABI SwiftVersionedAdditionAttr : public Attr {
13510 VersionTuple version;
13511 
13512 
13513 Attr * additionalAttr;
13514 
13515 bool isReplacedByActive;
13516 
13517 public:
13518   // Factory methods
13519   static SwiftVersionedAdditionAttr *CreateImplicit(ASTContext &Ctx, VersionTuple Version, Attr * AdditionalAttr, bool IsReplacedByActive, const AttributeCommonInfo &CommonInfo);
13520   static SwiftVersionedAdditionAttr *Create(ASTContext &Ctx, VersionTuple Version, Attr * AdditionalAttr, bool IsReplacedByActive, const AttributeCommonInfo &CommonInfo);
13521   static SwiftVersionedAdditionAttr *CreateImplicit(ASTContext &Ctx, VersionTuple Version, Attr * AdditionalAttr, bool IsReplacedByActive, SourceRange Range = {});
13522   static SwiftVersionedAdditionAttr *Create(ASTContext &Ctx, VersionTuple Version, Attr * AdditionalAttr, bool IsReplacedByActive, SourceRange Range = {});
13523 
13524   // Constructors
13525   SwiftVersionedAdditionAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
13526               , VersionTuple Version
13527               , Attr * AdditionalAttr
13528               , bool IsReplacedByActive
13529              );
13530 
13531   SwiftVersionedAdditionAttr *clone(ASTContext &C) const;
13532   void printPretty(raw_ostream &OS,
13533                    const PrintingPolicy &Policy) const;
13534   const char *getSpelling() const;
13535   VersionTuple getVersion() const {
13536     return version;
13537   }
13538   void setVersion(ASTContext &C, VersionTuple V) {
13539     version = V;
13540   }
13541 
13542   Attr * getAdditionalAttr() const {
13543     return additionalAttr;
13544   }
13545 
13546   bool getIsReplacedByActive() const {
13547     return isReplacedByActive;
13548   }
13549 
13550 
13551 
13552   static bool classof(const Attr *A) { return A->getKind() == attr::SwiftVersionedAddition; }
13553 };
13554 
13555 class CLANG_ABI SwiftVersionedRemovalAttr : public Attr {
13556 VersionTuple version;
13557 
13558 
13559 unsigned rawKind;
13560 
13561 bool isReplacedByActive;
13562 
13563 public:
13564   // Factory methods
13565   static SwiftVersionedRemovalAttr *CreateImplicit(ASTContext &Ctx, VersionTuple Version, unsigned RawKind, bool IsReplacedByActive, const AttributeCommonInfo &CommonInfo);
13566   static SwiftVersionedRemovalAttr *Create(ASTContext &Ctx, VersionTuple Version, unsigned RawKind, bool IsReplacedByActive, const AttributeCommonInfo &CommonInfo);
13567   static SwiftVersionedRemovalAttr *CreateImplicit(ASTContext &Ctx, VersionTuple Version, unsigned RawKind, bool IsReplacedByActive, SourceRange Range = {});
13568   static SwiftVersionedRemovalAttr *Create(ASTContext &Ctx, VersionTuple Version, unsigned RawKind, bool IsReplacedByActive, SourceRange Range = {});
13569 
13570   // Constructors
13571   SwiftVersionedRemovalAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
13572               , VersionTuple Version
13573               , unsigned RawKind
13574               , bool IsReplacedByActive
13575              );
13576 
13577   SwiftVersionedRemovalAttr *clone(ASTContext &C) const;
13578   void printPretty(raw_ostream &OS,
13579                    const PrintingPolicy &Policy) const;
13580   const char *getSpelling() const;
13581   VersionTuple getVersion() const {
13582     return version;
13583   }
13584   void setVersion(ASTContext &C, VersionTuple V) {
13585     version = V;
13586   }
13587 
13588   unsigned getRawKind() const {
13589     return rawKind;
13590   }
13591 
13592   bool getIsReplacedByActive() const {
13593     return isReplacedByActive;
13594   }
13595 
13596 
13597     attr::Kind getAttrKindToRemove() const {
13598       return static_cast<attr::Kind>(getRawKind());
13599     }
13600   
13601 
13602   static bool classof(const Attr *A) { return A->getKind() == attr::SwiftVersionedRemoval; }
13603 };
13604 
13605 class CLANG_ABI SysVABIAttr : public InheritableAttr {
13606 public:
13607   enum Spelling {
13608     GNU_sysv_abi = 0,
13609     CXX11_gnu_sysv_abi = 1,
13610     C23_gnu_sysv_abi = 2,
13611   SpellingNotCalculated = 15
13612 
13613   };
13614 
13615   // Factory methods
13616   static SysVABIAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
13617   static SysVABIAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
13618   static SysVABIAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_sysv_abi);
13619   static SysVABIAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_sysv_abi);
13620 
13621   // Constructors
13622   SysVABIAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
13623              );
13624 
13625   SysVABIAttr *clone(ASTContext &C) const;
13626   void printPretty(raw_ostream &OS,
13627                    const PrintingPolicy &Policy) const;
13628   const char *getSpelling() const;
13629 
13630 
13631   static bool classof(const Attr *A) { return A->getKind() == attr::SysVABI; }
13632 };
13633 
13634 class CLANG_ABI TLSModelAttr : public InheritableAttr {
13635 unsigned modelLength;
13636 char *model;
13637 
13638 public:
13639   enum Spelling {
13640     GNU_tls_model = 0,
13641     CXX11_gnu_tls_model = 1,
13642     C23_gnu_tls_model = 2,
13643   SpellingNotCalculated = 15
13644 
13645   };
13646 
13647   // Factory methods
13648   static TLSModelAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Model, const AttributeCommonInfo &CommonInfo);
13649   static TLSModelAttr *Create(ASTContext &Ctx, llvm::StringRef Model, const AttributeCommonInfo &CommonInfo);
13650   static TLSModelAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Model, SourceRange Range = {}, Spelling S = GNU_tls_model);
13651   static TLSModelAttr *Create(ASTContext &Ctx, llvm::StringRef Model, SourceRange Range = {}, Spelling S = GNU_tls_model);
13652 
13653   // Constructors
13654   TLSModelAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
13655               , llvm::StringRef Model
13656              );
13657 
13658   TLSModelAttr *clone(ASTContext &C) const;
13659   void printPretty(raw_ostream &OS,
13660                    const PrintingPolicy &Policy) const;
13661   const char *getSpelling() const;
13662   llvm::StringRef getModel() const {
13663     return llvm::StringRef(model, modelLength);
13664   }
13665   unsigned getModelLength() const {
13666     return modelLength;
13667   }
13668   void setModel(ASTContext &C, llvm::StringRef S) {
13669     modelLength = S.size();
13670     this->model = new (C, 1) char [modelLength];
13671     if (!S.empty())
13672       std::memcpy(this->model, S.data(), modelLength);
13673   }
13674 
13675 
13676 
13677   static bool classof(const Attr *A) { return A->getKind() == attr::TLSModel; }
13678 };
13679 
13680 class CLANG_ABI TargetAttr : public InheritableAttr {
13681 unsigned featuresStrLength;
13682 char *featuresStr;
13683 
13684 public:
13685   enum Spelling {
13686     GNU_target = 0,
13687     CXX11_gnu_target = 1,
13688     C23_gnu_target = 2,
13689   SpellingNotCalculated = 15
13690 
13691   };
13692 
13693   // Factory methods
13694   static TargetAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef FeaturesStr, const AttributeCommonInfo &CommonInfo);
13695   static TargetAttr *Create(ASTContext &Ctx, llvm::StringRef FeaturesStr, const AttributeCommonInfo &CommonInfo);
13696   static TargetAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef FeaturesStr, SourceRange Range = {}, Spelling S = GNU_target);
13697   static TargetAttr *Create(ASTContext &Ctx, llvm::StringRef FeaturesStr, SourceRange Range = {}, Spelling S = GNU_target);
13698 
13699   // Constructors
13700   TargetAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
13701               , llvm::StringRef FeaturesStr
13702              );
13703 
13704   TargetAttr *clone(ASTContext &C) const;
13705   void printPretty(raw_ostream &OS,
13706                    const PrintingPolicy &Policy) const;
13707   const char *getSpelling() const;
13708   llvm::StringRef getFeaturesStr() const {
13709     return llvm::StringRef(featuresStr, featuresStrLength);
13710   }
13711   unsigned getFeaturesStrLength() const {
13712     return featuresStrLength;
13713   }
13714   void setFeaturesStr(ASTContext &C, llvm::StringRef S) {
13715     featuresStrLength = S.size();
13716     this->featuresStr = new (C, 1) char [featuresStrLength];
13717     if (!S.empty())
13718       std::memcpy(this->featuresStr, S.data(), featuresStrLength);
13719   }
13720 
13721 
13722     std::optional<StringRef> getX86Architecture() const {
13723       StringRef Features = getFeaturesStr();
13724       SmallVector<StringRef, 4> AttrFeatures;
13725       Features.split(AttrFeatures, ',');
13726       for (StringRef Feature : AttrFeatures) {
13727         Feature = Feature.trim();
13728         if (Feature.starts_with("arch="))
13729           return Feature.drop_front(sizeof("arch=") - 1);
13730       }
13731       return std::nullopt;
13732     }
13733 
13734     // Gets the list of features as simple string-refs with no +/- or 'no-'.
13735     // Only adds the items to 'Out' that are additions.
13736     void getX86AddedFeatures(llvm::SmallVectorImpl<StringRef> &Out) const {
13737       if (isDefaultVersion())
13738         return;
13739       StringRef Features = getFeaturesStr();
13740       SmallVector<StringRef, 4> AttrFeatures;
13741       Features.split(AttrFeatures, ',');
13742       for (auto &Feature : AttrFeatures) {
13743         Feature = Feature.trim();
13744         if (!Feature.starts_with("no-") && !Feature.starts_with("arch=") &&
13745             !Feature.starts_with("fpmath=") && !Feature.starts_with("tune="))
13746           Out.push_back(Feature);
13747       }
13748     }
13749 
13750     bool isDefaultVersion() const { return getFeaturesStr() == "default"; }
13751   
13752 
13753   static bool classof(const Attr *A) { return A->getKind() == attr::Target; }
13754 };
13755 
13756 class CLANG_ABI TargetClonesAttr : public InheritableAttr {
13757   unsigned featuresStrs_Size;
13758   StringRef *featuresStrs_;
13759 
13760 public:
13761   enum Spelling {
13762     GNU_target_clones = 0,
13763     CXX11_gnu_target_clones = 1,
13764     C23_gnu_target_clones = 2,
13765   SpellingNotCalculated = 15
13766 
13767   };
13768 
13769   // Factory methods
13770   static TargetClonesAttr *CreateImplicit(ASTContext &Ctx, StringRef *FeaturesStrs, unsigned FeaturesStrsSize, const AttributeCommonInfo &CommonInfo);
13771   static TargetClonesAttr *Create(ASTContext &Ctx, StringRef *FeaturesStrs, unsigned FeaturesStrsSize, const AttributeCommonInfo &CommonInfo);
13772   static TargetClonesAttr *CreateImplicit(ASTContext &Ctx, StringRef *FeaturesStrs, unsigned FeaturesStrsSize, SourceRange Range = {}, Spelling S = GNU_target_clones);
13773   static TargetClonesAttr *Create(ASTContext &Ctx, StringRef *FeaturesStrs, unsigned FeaturesStrsSize, SourceRange Range = {}, Spelling S = GNU_target_clones);
13774 
13775   // Constructors
13776   TargetClonesAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
13777               , StringRef *FeaturesStrs, unsigned FeaturesStrsSize
13778              );
13779   TargetClonesAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
13780              );
13781 
13782   TargetClonesAttr *clone(ASTContext &C) const;
13783   void printPretty(raw_ostream &OS,
13784                    const PrintingPolicy &Policy) const;
13785   const char *getSpelling() const;
13786   typedef StringRef* featuresStrs_iterator;
13787   featuresStrs_iterator featuresStrs_begin() const { return featuresStrs_; }
13788   featuresStrs_iterator featuresStrs_end() const { return featuresStrs_ + featuresStrs_Size; }
13789   unsigned featuresStrs_size() const { return featuresStrs_Size; }
13790   llvm::iterator_range<featuresStrs_iterator> featuresStrs() const { return llvm::make_range(featuresStrs_begin(), featuresStrs_end()); }
13791 
13792 
13793 
13794     StringRef getFeatureStr(unsigned Index) const {
13795       return *(featuresStrs_begin() + Index);
13796     }
13797 
13798     bool isDefaultVersion(unsigned Index) const {
13799       return getFeatureStr(Index) == "default";
13800     }
13801 
13802     void getFeatures(llvm::SmallVectorImpl<StringRef> &Out,
13803                      unsigned Index, char Delim = '+') const {
13804       if (isDefaultVersion(Index))
13805         return;
13806       StringRef Features = getFeatureStr(Index);
13807       SmallVector<StringRef, 4> AttrFeatures;
13808       Features.split(AttrFeatures, Delim);
13809       for (StringRef Feature : AttrFeatures) {
13810         Feature = Feature.trim();
13811         Out.push_back(Feature);
13812       }
13813     }
13814 
13815     std::optional<StringRef> getX86Architecture(unsigned Index) const {
13816       StringRef Feature = getFeatureStr(Index);
13817       if (Feature.starts_with("arch="))
13818         return Feature.drop_front(sizeof("arch=") - 1);
13819       return std::nullopt;
13820     }
13821 
13822     void getX86Feature(llvm::SmallVectorImpl<StringRef> &Out,
13823                        unsigned Index) const {
13824       if (isDefaultVersion(Index))
13825         return;
13826       if (getX86Architecture(Index))
13827         return;
13828       Out.push_back(getFeatureStr(Index));
13829     }
13830 
13831     // Given an index into the 'featuresStrs' sequence, compute a unique
13832     // ID to be used with function name mangling for the associated variant.
13833     // This mapping is necessary due to a requirement that the mangling ID
13834     // used for the "default" variant be the largest mangling ID in the
13835     // variant set. Duplicate variants present in 'featuresStrs' are also
13836     // assigned their own unique ID (the mapping is bijective).
13837     unsigned getMangledIndex(unsigned Index) const {
13838       if (getFeatureStr(Index) == "default")
13839         return std::count_if(featuresStrs_begin(), featuresStrs_end(),
13840                               [](StringRef S) { return S != "default"; });
13841 
13842       return std::count_if(featuresStrs_begin(), featuresStrs_begin() + Index,
13843                            [](StringRef S) { return S != "default"; });
13844     }
13845 
13846     // Given an index into the 'featuresStrs' sequence, determine if the
13847     // index corresponds to the first instance of the named variant. This
13848     // is used to skip over duplicate variant instances when iterating over
13849     // 'featuresStrs'.
13850     bool isFirstOfVersion(unsigned Index) const {
13851       StringRef FeatureStr(getFeatureStr(Index));
13852       return 0 == std::count_if(
13853                       featuresStrs_begin(), featuresStrs_begin() + Index,
13854                       [FeatureStr](StringRef S) { return S == FeatureStr; });
13855 
13856     }
13857   
13858 
13859   static bool classof(const Attr *A) { return A->getKind() == attr::TargetClones; }
13860 };
13861 
13862 class CLANG_ABI TargetVersionAttr : public InheritableAttr {
13863 unsigned namesStrLength;
13864 char *namesStr;
13865 
13866 public:
13867   enum Spelling {
13868     GNU_target_version = 0,
13869     CXX11_gnu_target_version = 1,
13870     C23_gnu_target_version = 2,
13871   SpellingNotCalculated = 15
13872 
13873   };
13874 
13875   // Factory methods
13876   static TargetVersionAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef NamesStr, const AttributeCommonInfo &CommonInfo);
13877   static TargetVersionAttr *Create(ASTContext &Ctx, llvm::StringRef NamesStr, const AttributeCommonInfo &CommonInfo);
13878   static TargetVersionAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef NamesStr, SourceRange Range = {}, Spelling S = GNU_target_version);
13879   static TargetVersionAttr *Create(ASTContext &Ctx, llvm::StringRef NamesStr, SourceRange Range = {}, Spelling S = GNU_target_version);
13880 
13881   // Constructors
13882   TargetVersionAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
13883               , llvm::StringRef NamesStr
13884              );
13885 
13886   TargetVersionAttr *clone(ASTContext &C) const;
13887   void printPretty(raw_ostream &OS,
13888                    const PrintingPolicy &Policy) const;
13889   const char *getSpelling() const;
13890   llvm::StringRef getNamesStr() const {
13891     return llvm::StringRef(namesStr, namesStrLength);
13892   }
13893   unsigned getNamesStrLength() const {
13894     return namesStrLength;
13895   }
13896   void setNamesStr(ASTContext &C, llvm::StringRef S) {
13897     namesStrLength = S.size();
13898     this->namesStr = new (C, 1) char [namesStrLength];
13899     if (!S.empty())
13900       std::memcpy(this->namesStr, S.data(), namesStrLength);
13901   }
13902 
13903 
13904     StringRef getName() const { return getNamesStr().trim(); }
13905 
13906     bool isDefaultVersion() const { return getName() == "default"; }
13907 
13908     void getFeatures(llvm::SmallVectorImpl<StringRef> &Out,
13909                      char Delim = '+') const {
13910       if (isDefaultVersion())
13911         return;
13912       StringRef Features = getName();
13913       SmallVector<StringRef, 4> AttrFeatures;
13914       Features.split(AttrFeatures, Delim);
13915       for (StringRef Feature : AttrFeatures) {
13916         Feature = Feature.trim();
13917         Out.push_back(Feature);
13918       }
13919     }
13920   
13921 
13922   static bool classof(const Attr *A) { return A->getKind() == attr::TargetVersion; }
13923 };
13924 
13925 class CLANG_ABI TestTypestateAttr : public InheritableAttr {
13926 public:
13927   enum ConsumedState {
13928     Consumed,
13929     Unconsumed
13930   };
13931 private:
13932   TestTypestateAttr::ConsumedState testState;
13933 
13934 public:
13935   enum Spelling {
13936     GNU_test_typestate = 0,
13937     CXX11_clang_test_typestate = 1,
13938   SpellingNotCalculated = 15
13939 
13940   };
13941 
13942   // Factory methods
13943   static TestTypestateAttr *CreateImplicit(ASTContext &Ctx, TestTypestateAttr::ConsumedState TestState, const AttributeCommonInfo &CommonInfo);
13944   static TestTypestateAttr *Create(ASTContext &Ctx, TestTypestateAttr::ConsumedState TestState, const AttributeCommonInfo &CommonInfo);
13945   static TestTypestateAttr *CreateImplicit(ASTContext &Ctx, TestTypestateAttr::ConsumedState TestState, SourceRange Range = {}, Spelling S = GNU_test_typestate);
13946   static TestTypestateAttr *Create(ASTContext &Ctx, TestTypestateAttr::ConsumedState TestState, SourceRange Range = {}, Spelling S = GNU_test_typestate);
13947 
13948   // Constructors
13949   TestTypestateAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
13950               , TestTypestateAttr::ConsumedState TestState
13951              );
13952 
13953   TestTypestateAttr *clone(ASTContext &C) const;
13954   void printPretty(raw_ostream &OS,
13955                    const PrintingPolicy &Policy) const;
13956   const char *getSpelling() const;
13957   TestTypestateAttr::ConsumedState getTestState() const {
13958     return testState;
13959   }
13960 
13961   static bool ConvertStrToConsumedState(StringRef Val, TestTypestateAttr::ConsumedState &Out);
13962   static const char *ConvertConsumedStateToStr(TestTypestateAttr::ConsumedState Val);
13963 
13964 
13965   static bool classof(const Attr *A) { return A->getKind() == attr::TestTypestate; }
13966 };
13967 
13968 class CLANG_ABI ThisCallAttr : public InheritableAttr {
13969 public:
13970   enum Spelling {
13971     GNU_thiscall = 0,
13972     CXX11_gnu_thiscall = 1,
13973     C23_gnu_thiscall = 2,
13974     Keyword_thiscall = 3,
13975   SpellingNotCalculated = 15
13976 
13977   };
13978 
13979   // Factory methods
13980   static ThisCallAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
13981   static ThisCallAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
13982   static ThisCallAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_thiscall);
13983   static ThisCallAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_thiscall);
13984 
13985   // Constructors
13986   ThisCallAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
13987              );
13988 
13989   ThisCallAttr *clone(ASTContext &C) const;
13990   void printPretty(raw_ostream &OS,
13991                    const PrintingPolicy &Policy) const;
13992   const char *getSpelling() const;
13993 
13994 
13995   static bool classof(const Attr *A) { return A->getKind() == attr::ThisCall; }
13996 };
13997 
13998 class CLANG_ABI ThreadAttr : public Attr {
13999 public:
14000   // Factory methods
14001   static ThreadAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
14002   static ThreadAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
14003   static ThreadAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {});
14004   static ThreadAttr *Create(ASTContext &Ctx, SourceRange Range = {});
14005 
14006   // Constructors
14007   ThreadAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
14008              );
14009 
14010   ThreadAttr *clone(ASTContext &C) const;
14011   void printPretty(raw_ostream &OS,
14012                    const PrintingPolicy &Policy) const;
14013   const char *getSpelling() const;
14014 
14015 
14016   static bool classof(const Attr *A) { return A->getKind() == attr::Thread; }
14017 };
14018 
14019 class CLANG_ABI TransparentUnionAttr : public InheritableAttr {
14020 public:
14021   enum Spelling {
14022     GNU_transparent_union = 0,
14023     CXX11_gnu_transparent_union = 1,
14024     C23_gnu_transparent_union = 2,
14025   SpellingNotCalculated = 15
14026 
14027   };
14028 
14029   // Factory methods
14030   static TransparentUnionAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
14031   static TransparentUnionAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
14032   static TransparentUnionAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_transparent_union);
14033   static TransparentUnionAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_transparent_union);
14034 
14035   // Constructors
14036   TransparentUnionAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
14037              );
14038 
14039   TransparentUnionAttr *clone(ASTContext &C) const;
14040   void printPretty(raw_ostream &OS,
14041                    const PrintingPolicy &Policy) const;
14042   const char *getSpelling() const;
14043 
14044 
14045   static bool classof(const Attr *A) { return A->getKind() == attr::TransparentUnion; }
14046 };
14047 
14048 class CLANG_ABI TrivialABIAttr : public InheritableAttr {
14049 public:
14050   enum Spelling {
14051     GNU_trivial_abi = 0,
14052     CXX11_clang_trivial_abi = 1,
14053   SpellingNotCalculated = 15
14054 
14055   };
14056 
14057   // Factory methods
14058   static TrivialABIAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
14059   static TrivialABIAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
14060   static TrivialABIAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_trivial_abi);
14061   static TrivialABIAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_trivial_abi);
14062 
14063   // Constructors
14064   TrivialABIAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
14065              );
14066 
14067   TrivialABIAttr *clone(ASTContext &C) const;
14068   void printPretty(raw_ostream &OS,
14069                    const PrintingPolicy &Policy) const;
14070   const char *getSpelling() const;
14071 
14072 
14073   static bool classof(const Attr *A) { return A->getKind() == attr::TrivialABI; }
14074 };
14075 
14076 class CLANG_ABI TryAcquireCapabilityAttr : public InheritableAttr {
14077 Expr * successValue;
14078 
14079   unsigned args_Size;
14080   Expr * *args_;
14081 
14082 public:
14083   enum Spelling {
14084     GNU_try_acquire_capability = 0,
14085     CXX11_clang_try_acquire_capability = 1,
14086     GNU_try_acquire_shared_capability = 2,
14087     CXX11_clang_try_acquire_shared_capability = 3,
14088   SpellingNotCalculated = 15
14089 
14090   };
14091 
14092   // Factory methods
14093   static TryAcquireCapabilityAttr *CreateImplicit(ASTContext &Ctx, Expr * SuccessValue, Expr * *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo);
14094   static TryAcquireCapabilityAttr *Create(ASTContext &Ctx, Expr * SuccessValue, Expr * *Args, unsigned ArgsSize, const AttributeCommonInfo &CommonInfo);
14095   static TryAcquireCapabilityAttr *CreateImplicit(ASTContext &Ctx, Expr * SuccessValue, Expr * *Args, unsigned ArgsSize, SourceRange Range = {}, Spelling S = GNU_try_acquire_capability);
14096   static TryAcquireCapabilityAttr *Create(ASTContext &Ctx, Expr * SuccessValue, Expr * *Args, unsigned ArgsSize, SourceRange Range = {}, Spelling S = GNU_try_acquire_capability);
14097 
14098   // Constructors
14099   TryAcquireCapabilityAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
14100               , Expr * SuccessValue
14101               , Expr * *Args, unsigned ArgsSize
14102              );
14103   TryAcquireCapabilityAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
14104               , Expr * SuccessValue
14105              );
14106 
14107   TryAcquireCapabilityAttr *clone(ASTContext &C) const;
14108   void printPretty(raw_ostream &OS,
14109                    const PrintingPolicy &Policy) const;
14110   const char *getSpelling() const;
14111   Spelling getSemanticSpelling() const;
14112   bool isShared() const { return getAttributeSpellingListIndex() == 2 ||
14113     getAttributeSpellingListIndex() == 3; }
14114   Expr * getSuccessValue() const {
14115     return successValue;
14116   }
14117 
14118   typedef Expr ** args_iterator;
14119   args_iterator args_begin() const { return args_; }
14120   args_iterator args_end() const { return args_ + args_Size; }
14121   unsigned args_size() const { return args_Size; }
14122   llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }
14123 
14124 
14125 
14126 
14127   static bool classof(const Attr *A) { return A->getKind() == attr::TryAcquireCapability; }
14128 };
14129 
14130 class CLANG_ABI TypeNonNullAttr : public TypeAttr {
14131 public:
14132   // Factory methods
14133   static TypeNonNullAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
14134   static TypeNonNullAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
14135   static TypeNonNullAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {});
14136   static TypeNonNullAttr *Create(ASTContext &Ctx, SourceRange Range = {});
14137 
14138   // Constructors
14139   TypeNonNullAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
14140              );
14141 
14142   TypeNonNullAttr *clone(ASTContext &C) const;
14143   void printPretty(raw_ostream &OS,
14144                    const PrintingPolicy &Policy) const;
14145   const char *getSpelling() const;
14146 
14147 
14148   static bool classof(const Attr *A) { return A->getKind() == attr::TypeNonNull; }
14149 };
14150 
14151 class CLANG_ABI TypeNullUnspecifiedAttr : public TypeAttr {
14152 public:
14153   // Factory methods
14154   static TypeNullUnspecifiedAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
14155   static TypeNullUnspecifiedAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
14156   static TypeNullUnspecifiedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {});
14157   static TypeNullUnspecifiedAttr *Create(ASTContext &Ctx, SourceRange Range = {});
14158 
14159   // Constructors
14160   TypeNullUnspecifiedAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
14161              );
14162 
14163   TypeNullUnspecifiedAttr *clone(ASTContext &C) const;
14164   void printPretty(raw_ostream &OS,
14165                    const PrintingPolicy &Policy) const;
14166   const char *getSpelling() const;
14167 
14168 
14169   static bool classof(const Attr *A) { return A->getKind() == attr::TypeNullUnspecified; }
14170 };
14171 
14172 class CLANG_ABI TypeNullableAttr : public InheritableAttr {
14173 public:
14174   // Factory methods
14175   static TypeNullableAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
14176   static TypeNullableAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
14177   static TypeNullableAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {});
14178   static TypeNullableAttr *Create(ASTContext &Ctx, SourceRange Range = {});
14179 
14180   // Constructors
14181   TypeNullableAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
14182              );
14183 
14184   TypeNullableAttr *clone(ASTContext &C) const;
14185   void printPretty(raw_ostream &OS,
14186                    const PrintingPolicy &Policy) const;
14187   const char *getSpelling() const;
14188 
14189 
14190   static bool classof(const Attr *A) { return A->getKind() == attr::TypeNullable; }
14191 };
14192 
14193 class CLANG_ABI TypeNullableResultAttr : public TypeAttr {
14194 public:
14195   // Factory methods
14196   static TypeNullableResultAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
14197   static TypeNullableResultAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
14198   static TypeNullableResultAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {});
14199   static TypeNullableResultAttr *Create(ASTContext &Ctx, SourceRange Range = {});
14200 
14201   // Constructors
14202   TypeNullableResultAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
14203              );
14204 
14205   TypeNullableResultAttr *clone(ASTContext &C) const;
14206   void printPretty(raw_ostream &OS,
14207                    const PrintingPolicy &Policy) const;
14208   const char *getSpelling() const;
14209 
14210 
14211   static bool classof(const Attr *A) { return A->getKind() == attr::TypeNullableResult; }
14212 };
14213 
14214 class CLANG_ABI TypeTagForDatatypeAttr : public InheritableAttr {
14215 IdentifierInfo * argumentKind;
14216 
14217 TypeSourceInfo * matchingCType;
14218 
14219 bool layoutCompatible;
14220 
14221 bool mustBeNull;
14222 
14223 public:
14224   enum Spelling {
14225     GNU_type_tag_for_datatype = 0,
14226     CXX11_clang_type_tag_for_datatype = 1,
14227     C23_clang_type_tag_for_datatype = 2,
14228   SpellingNotCalculated = 15
14229 
14230   };
14231 
14232   // Factory methods
14233   static TypeTagForDatatypeAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * ArgumentKind, TypeSourceInfo * MatchingCType, bool LayoutCompatible, bool MustBeNull, const AttributeCommonInfo &CommonInfo);
14234   static TypeTagForDatatypeAttr *Create(ASTContext &Ctx, IdentifierInfo * ArgumentKind, TypeSourceInfo * MatchingCType, bool LayoutCompatible, bool MustBeNull, const AttributeCommonInfo &CommonInfo);
14235   static TypeTagForDatatypeAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * ArgumentKind, TypeSourceInfo * MatchingCType, bool LayoutCompatible, bool MustBeNull, SourceRange Range = {}, Spelling S = GNU_type_tag_for_datatype);
14236   static TypeTagForDatatypeAttr *Create(ASTContext &Ctx, IdentifierInfo * ArgumentKind, TypeSourceInfo * MatchingCType, bool LayoutCompatible, bool MustBeNull, SourceRange Range = {}, Spelling S = GNU_type_tag_for_datatype);
14237 
14238   // Constructors
14239   TypeTagForDatatypeAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
14240               , IdentifierInfo * ArgumentKind
14241               , TypeSourceInfo * MatchingCType
14242               , bool LayoutCompatible
14243               , bool MustBeNull
14244              );
14245 
14246   TypeTagForDatatypeAttr *clone(ASTContext &C) const;
14247   void printPretty(raw_ostream &OS,
14248                    const PrintingPolicy &Policy) const;
14249   const char *getSpelling() const;
14250   IdentifierInfo * getArgumentKind() const {
14251     return argumentKind;
14252   }
14253 
14254   QualType getMatchingCType() const {
14255     return matchingCType->getType();
14256   }  TypeSourceInfo * getMatchingCTypeLoc() const {
14257     return matchingCType;
14258   }
14259 
14260   bool getLayoutCompatible() const {
14261     return layoutCompatible;
14262   }
14263 
14264   bool getMustBeNull() const {
14265     return mustBeNull;
14266   }
14267 
14268 
14269 
14270   static bool classof(const Attr *A) { return A->getKind() == attr::TypeTagForDatatype; }
14271 };
14272 
14273 class CLANG_ABI TypeVisibilityAttr : public InheritableAttr {
14274 public:
14275   enum VisibilityType {
14276     Default,
14277     Hidden,
14278     Protected
14279   };
14280 private:
14281   TypeVisibilityAttr::VisibilityType visibility;
14282 
14283 public:
14284   enum Spelling {
14285     GNU_type_visibility = 0,
14286     CXX11_clang_type_visibility = 1,
14287     C23_clang_type_visibility = 2,
14288   SpellingNotCalculated = 15
14289 
14290   };
14291 
14292   // Factory methods
14293   static TypeVisibilityAttr *CreateImplicit(ASTContext &Ctx, TypeVisibilityAttr::VisibilityType Visibility, const AttributeCommonInfo &CommonInfo);
14294   static TypeVisibilityAttr *Create(ASTContext &Ctx, TypeVisibilityAttr::VisibilityType Visibility, const AttributeCommonInfo &CommonInfo);
14295   static TypeVisibilityAttr *CreateImplicit(ASTContext &Ctx, TypeVisibilityAttr::VisibilityType Visibility, SourceRange Range = {}, Spelling S = GNU_type_visibility);
14296   static TypeVisibilityAttr *Create(ASTContext &Ctx, TypeVisibilityAttr::VisibilityType Visibility, SourceRange Range = {}, Spelling S = GNU_type_visibility);
14297 
14298   // Constructors
14299   TypeVisibilityAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
14300               , TypeVisibilityAttr::VisibilityType Visibility
14301              );
14302 
14303   TypeVisibilityAttr *clone(ASTContext &C) const;
14304   void printPretty(raw_ostream &OS,
14305                    const PrintingPolicy &Policy) const;
14306   const char *getSpelling() const;
14307   TypeVisibilityAttr::VisibilityType getVisibility() const {
14308     return visibility;
14309   }
14310 
14311   static bool ConvertStrToVisibilityType(StringRef Val, TypeVisibilityAttr::VisibilityType &Out);
14312   static const char *ConvertVisibilityTypeToStr(TypeVisibilityAttr::VisibilityType Val);
14313 
14314 
14315   static bool classof(const Attr *A) { return A->getKind() == attr::TypeVisibility; }
14316 };
14317 
14318 class CLANG_ABI UPtrAttr : public TypeAttr {
14319 public:
14320   // Factory methods
14321   static UPtrAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
14322   static UPtrAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
14323   static UPtrAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {});
14324   static UPtrAttr *Create(ASTContext &Ctx, SourceRange Range = {});
14325 
14326   // Constructors
14327   UPtrAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
14328              );
14329 
14330   UPtrAttr *clone(ASTContext &C) const;
14331   void printPretty(raw_ostream &OS,
14332                    const PrintingPolicy &Policy) const;
14333   const char *getSpelling() const;
14334 
14335 
14336   static bool classof(const Attr *A) { return A->getKind() == attr::UPtr; }
14337 };
14338 
14339 class CLANG_ABI UnavailableAttr : public InheritableAttr {
14340 unsigned messageLength;
14341 char *message;
14342 
14343 public:
14344   enum ImplicitReason {
14345     IR_None,
14346     IR_ARCForbiddenType,
14347     IR_ForbiddenWeak,
14348     IR_ARCForbiddenConversion,
14349     IR_ARCInitReturnsUnrelated,
14350     IR_ARCFieldWithOwnership
14351   };
14352 private:
14353   UnavailableAttr::ImplicitReason implicitReason;
14354 
14355 public:
14356   enum Spelling {
14357     GNU_unavailable = 0,
14358     CXX11_clang_unavailable = 1,
14359     C23_clang_unavailable = 2,
14360   SpellingNotCalculated = 15
14361 
14362   };
14363 
14364   // Factory methods
14365   static UnavailableAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Message, UnavailableAttr::ImplicitReason ImplicitReason, const AttributeCommonInfo &CommonInfo);
14366   static UnavailableAttr *Create(ASTContext &Ctx, llvm::StringRef Message, UnavailableAttr::ImplicitReason ImplicitReason, const AttributeCommonInfo &CommonInfo);
14367   static UnavailableAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Message, UnavailableAttr::ImplicitReason ImplicitReason, SourceRange Range = {}, Spelling S = GNU_unavailable);
14368   static UnavailableAttr *Create(ASTContext &Ctx, llvm::StringRef Message, UnavailableAttr::ImplicitReason ImplicitReason, SourceRange Range = {}, Spelling S = GNU_unavailable);
14369   static UnavailableAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Message, const AttributeCommonInfo &CommonInfo);
14370   static UnavailableAttr *Create(ASTContext &Ctx, llvm::StringRef Message, const AttributeCommonInfo &CommonInfo);
14371   static UnavailableAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Message, SourceRange Range = {}, Spelling S = GNU_unavailable);
14372   static UnavailableAttr *Create(ASTContext &Ctx, llvm::StringRef Message, SourceRange Range = {}, Spelling S = GNU_unavailable);
14373 
14374   // Constructors
14375   UnavailableAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
14376               , llvm::StringRef Message
14377               , UnavailableAttr::ImplicitReason ImplicitReason
14378              );
14379   UnavailableAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
14380               , llvm::StringRef Message
14381              );
14382   UnavailableAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
14383              );
14384 
14385   UnavailableAttr *clone(ASTContext &C) const;
14386   void printPretty(raw_ostream &OS,
14387                    const PrintingPolicy &Policy) const;
14388   const char *getSpelling() const;
14389   llvm::StringRef getMessage() const {
14390     return llvm::StringRef(message, messageLength);
14391   }
14392   unsigned getMessageLength() const {
14393     return messageLength;
14394   }
14395   void setMessage(ASTContext &C, llvm::StringRef S) {
14396     messageLength = S.size();
14397     this->message = new (C, 1) char [messageLength];
14398     if (!S.empty())
14399       std::memcpy(this->message, S.data(), messageLength);
14400   }
14401 
14402   UnavailableAttr::ImplicitReason getImplicitReason() const {
14403     return implicitReason;
14404   }
14405 
14406 
14407 
14408   static bool classof(const Attr *A) { return A->getKind() == attr::Unavailable; }
14409 };
14410 
14411 class CLANG_ABI UninitializedAttr : public InheritableAttr {
14412 public:
14413   enum Spelling {
14414     GNU_uninitialized = 0,
14415     CXX11_clang_uninitialized = 1,
14416   SpellingNotCalculated = 15
14417 
14418   };
14419 
14420   // Factory methods
14421   static UninitializedAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
14422   static UninitializedAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
14423   static UninitializedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_uninitialized);
14424   static UninitializedAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_uninitialized);
14425 
14426   // Constructors
14427   UninitializedAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
14428              );
14429 
14430   UninitializedAttr *clone(ASTContext &C) const;
14431   void printPretty(raw_ostream &OS,
14432                    const PrintingPolicy &Policy) const;
14433   const char *getSpelling() const;
14434 
14435 
14436   static bool classof(const Attr *A) { return A->getKind() == attr::Uninitialized; }
14437 };
14438 
14439 class CLANG_ABI UnlikelyAttr : public StmtAttr {
14440 public:
14441   enum Spelling {
14442     CXX11_unlikely = 0,
14443     C23_clang_unlikely = 1,
14444   SpellingNotCalculated = 15
14445 
14446   };
14447 
14448   // Factory methods
14449   static UnlikelyAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
14450   static UnlikelyAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
14451   static UnlikelyAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = CXX11_unlikely);
14452   static UnlikelyAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = CXX11_unlikely);
14453 
14454   // Constructors
14455   UnlikelyAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
14456              );
14457 
14458   UnlikelyAttr *clone(ASTContext &C) const;
14459   void printPretty(raw_ostream &OS,
14460                    const PrintingPolicy &Policy) const;
14461   const char *getSpelling() const;
14462 
14463 
14464   static bool classof(const Attr *A) { return A->getKind() == attr::Unlikely; }
14465 };
14466 
14467 class CLANG_ABI UnsafeBufferUsageAttr : public InheritableAttr {
14468 public:
14469   enum Spelling {
14470     GNU_unsafe_buffer_usage = 0,
14471     CXX11_clang_unsafe_buffer_usage = 1,
14472     C23_clang_unsafe_buffer_usage = 2,
14473   SpellingNotCalculated = 15
14474 
14475   };
14476 
14477   // Factory methods
14478   static UnsafeBufferUsageAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
14479   static UnsafeBufferUsageAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
14480   static UnsafeBufferUsageAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_unsafe_buffer_usage);
14481   static UnsafeBufferUsageAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_unsafe_buffer_usage);
14482 
14483   // Constructors
14484   UnsafeBufferUsageAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
14485              );
14486 
14487   UnsafeBufferUsageAttr *clone(ASTContext &C) const;
14488   void printPretty(raw_ostream &OS,
14489                    const PrintingPolicy &Policy) const;
14490   const char *getSpelling() const;
14491 
14492 
14493   static bool classof(const Attr *A) { return A->getKind() == attr::UnsafeBufferUsage; }
14494 };
14495 
14496 class CLANG_ABI UnusedAttr : public InheritableAttr {
14497 public:
14498   enum Spelling {
14499     CXX11_maybe_unused = 0,
14500     GNU_unused = 1,
14501     CXX11_gnu_unused = 2,
14502     C23_gnu_unused = 3,
14503     C23_maybe_unused = 4,
14504   SpellingNotCalculated = 15
14505 
14506   };
14507 
14508   // Factory methods
14509   static UnusedAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
14510   static UnusedAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
14511   static UnusedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = CXX11_maybe_unused);
14512   static UnusedAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = CXX11_maybe_unused);
14513 
14514   // Constructors
14515   UnusedAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
14516              );
14517 
14518   UnusedAttr *clone(ASTContext &C) const;
14519   void printPretty(raw_ostream &OS,
14520                    const PrintingPolicy &Policy) const;
14521   const char *getSpelling() const;
14522   Spelling getSemanticSpelling() const;
14523 
14524 
14525   static bool classof(const Attr *A) { return A->getKind() == attr::Unused; }
14526 };
14527 
14528 class CLANG_ABI UseHandleAttr : public InheritableParamAttr {
14529 unsigned handleTypeLength;
14530 char *handleType;
14531 
14532 public:
14533   enum Spelling {
14534     GNU_use_handle = 0,
14535     CXX11_clang_use_handle = 1,
14536     C23_clang_use_handle = 2,
14537   SpellingNotCalculated = 15
14538 
14539   };
14540 
14541   // Factory methods
14542   static UseHandleAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef HandleType, const AttributeCommonInfo &CommonInfo);
14543   static UseHandleAttr *Create(ASTContext &Ctx, llvm::StringRef HandleType, const AttributeCommonInfo &CommonInfo);
14544   static UseHandleAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef HandleType, SourceRange Range = {}, Spelling S = GNU_use_handle);
14545   static UseHandleAttr *Create(ASTContext &Ctx, llvm::StringRef HandleType, SourceRange Range = {}, Spelling S = GNU_use_handle);
14546 
14547   // Constructors
14548   UseHandleAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
14549               , llvm::StringRef HandleType
14550              );
14551 
14552   UseHandleAttr *clone(ASTContext &C) const;
14553   void printPretty(raw_ostream &OS,
14554                    const PrintingPolicy &Policy) const;
14555   const char *getSpelling() const;
14556   llvm::StringRef getHandleType() const {
14557     return llvm::StringRef(handleType, handleTypeLength);
14558   }
14559   unsigned getHandleTypeLength() const {
14560     return handleTypeLength;
14561   }
14562   void setHandleType(ASTContext &C, llvm::StringRef S) {
14563     handleTypeLength = S.size();
14564     this->handleType = new (C, 1) char [handleTypeLength];
14565     if (!S.empty())
14566       std::memcpy(this->handleType, S.data(), handleTypeLength);
14567   }
14568 
14569 
14570 
14571   static bool classof(const Attr *A) { return A->getKind() == attr::UseHandle; }
14572 };
14573 
14574 class CLANG_ABI UsedAttr : public InheritableAttr {
14575 public:
14576   enum Spelling {
14577     GNU_used = 0,
14578     CXX11_gnu_used = 1,
14579     C23_gnu_used = 2,
14580   SpellingNotCalculated = 15
14581 
14582   };
14583 
14584   // Factory methods
14585   static UsedAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
14586   static UsedAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
14587   static UsedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_used);
14588   static UsedAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_used);
14589 
14590   // Constructors
14591   UsedAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
14592              );
14593 
14594   UsedAttr *clone(ASTContext &C) const;
14595   void printPretty(raw_ostream &OS,
14596                    const PrintingPolicy &Policy) const;
14597   const char *getSpelling() const;
14598 
14599 
14600   static bool classof(const Attr *A) { return A->getKind() == attr::Used; }
14601 };
14602 
14603 class CLANG_ABI UsingIfExistsAttr : public InheritableAttr {
14604 public:
14605   enum Spelling {
14606     GNU_using_if_exists = 0,
14607     CXX11_clang_using_if_exists = 1,
14608   SpellingNotCalculated = 15
14609 
14610   };
14611 
14612   // Factory methods
14613   static UsingIfExistsAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
14614   static UsingIfExistsAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
14615   static UsingIfExistsAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_using_if_exists);
14616   static UsingIfExistsAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_using_if_exists);
14617 
14618   // Constructors
14619   UsingIfExistsAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
14620              );
14621 
14622   UsingIfExistsAttr *clone(ASTContext &C) const;
14623   void printPretty(raw_ostream &OS,
14624                    const PrintingPolicy &Policy) const;
14625   const char *getSpelling() const;
14626 
14627 
14628   static bool classof(const Attr *A) { return A->getKind() == attr::UsingIfExists; }
14629 };
14630 
14631 class CLANG_ABI UuidAttr : public InheritableAttr {
14632 unsigned guidLength;
14633 char *guid;
14634 
14635 MSGuidDecl * guidDecl;
14636 
14637 public:
14638   enum Spelling {
14639     Declspec_uuid = 0,
14640     Microsoft_uuid = 1,
14641   SpellingNotCalculated = 15
14642 
14643   };
14644 
14645   // Factory methods
14646   static UuidAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Guid, MSGuidDecl * GuidDecl, const AttributeCommonInfo &CommonInfo);
14647   static UuidAttr *Create(ASTContext &Ctx, llvm::StringRef Guid, MSGuidDecl * GuidDecl, const AttributeCommonInfo &CommonInfo);
14648   static UuidAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Guid, MSGuidDecl * GuidDecl, SourceRange Range = {}, Spelling S = Declspec_uuid);
14649   static UuidAttr *Create(ASTContext &Ctx, llvm::StringRef Guid, MSGuidDecl * GuidDecl, SourceRange Range = {}, Spelling S = Declspec_uuid);
14650   static UuidAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Guid, const AttributeCommonInfo &CommonInfo);
14651   static UuidAttr *Create(ASTContext &Ctx, llvm::StringRef Guid, const AttributeCommonInfo &CommonInfo);
14652   static UuidAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Guid, SourceRange Range = {}, Spelling S = Declspec_uuid);
14653   static UuidAttr *Create(ASTContext &Ctx, llvm::StringRef Guid, SourceRange Range = {}, Spelling S = Declspec_uuid);
14654 
14655   // Constructors
14656   UuidAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
14657               , llvm::StringRef Guid
14658               , MSGuidDecl * GuidDecl
14659              );
14660   UuidAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
14661               , llvm::StringRef Guid
14662              );
14663 
14664   UuidAttr *clone(ASTContext &C) const;
14665   void printPretty(raw_ostream &OS,
14666                    const PrintingPolicy &Policy) const;
14667   const char *getSpelling() const;
14668   llvm::StringRef getGuid() const {
14669     return llvm::StringRef(guid, guidLength);
14670   }
14671   unsigned getGuidLength() const {
14672     return guidLength;
14673   }
14674   void setGuid(ASTContext &C, llvm::StringRef S) {
14675     guidLength = S.size();
14676     this->guid = new (C, 1) char [guidLength];
14677     if (!S.empty())
14678       std::memcpy(this->guid, S.data(), guidLength);
14679   }
14680 
14681   MSGuidDecl * getGuidDecl() const {
14682     return guidDecl;
14683   }
14684 
14685 
14686 
14687   static bool classof(const Attr *A) { return A->getKind() == attr::Uuid; }
14688 };
14689 
14690 class CLANG_ABI VTablePointerAuthenticationAttr : public InheritableAttr {
14691 public:
14692   enum VPtrAuthKeyType {
14693     DefaultKey,
14694     NoKey,
14695     ProcessDependent,
14696     ProcessIndependent
14697   };
14698 private:
14699   VTablePointerAuthenticationAttr::VPtrAuthKeyType key;
14700 
14701 public:
14702   enum AddressDiscriminationMode {
14703     DefaultAddressDiscrimination,
14704     NoAddressDiscrimination,
14705     AddressDiscrimination
14706   };
14707 private:
14708   VTablePointerAuthenticationAttr::AddressDiscriminationMode addressDiscrimination;
14709 
14710 public:
14711   enum ExtraDiscrimination {
14712     DefaultExtraDiscrimination,
14713     NoExtraDiscrimination,
14714     TypeDiscrimination,
14715     CustomDiscrimination
14716   };
14717 private:
14718   VTablePointerAuthenticationAttr::ExtraDiscrimination extraDiscrimination;
14719 
14720 int customDiscriminationValue;
14721 
14722 public:
14723   enum Spelling {
14724     GNU_ptrauth_vtable_pointer = 0,
14725     CXX11_clang_ptrauth_vtable_pointer = 1,
14726     C23_clang_ptrauth_vtable_pointer = 2,
14727   SpellingNotCalculated = 15
14728 
14729   };
14730 
14731   // Factory methods
14732   static VTablePointerAuthenticationAttr *CreateImplicit(ASTContext &Ctx, VTablePointerAuthenticationAttr::VPtrAuthKeyType Key, VTablePointerAuthenticationAttr::AddressDiscriminationMode AddressDiscrimination, VTablePointerAuthenticationAttr::ExtraDiscrimination ExtraDiscrimination, int CustomDiscriminationValue, const AttributeCommonInfo &CommonInfo);
14733   static VTablePointerAuthenticationAttr *Create(ASTContext &Ctx, VTablePointerAuthenticationAttr::VPtrAuthKeyType Key, VTablePointerAuthenticationAttr::AddressDiscriminationMode AddressDiscrimination, VTablePointerAuthenticationAttr::ExtraDiscrimination ExtraDiscrimination, int CustomDiscriminationValue, const AttributeCommonInfo &CommonInfo);
14734   static VTablePointerAuthenticationAttr *CreateImplicit(ASTContext &Ctx, VTablePointerAuthenticationAttr::VPtrAuthKeyType Key, VTablePointerAuthenticationAttr::AddressDiscriminationMode AddressDiscrimination, VTablePointerAuthenticationAttr::ExtraDiscrimination ExtraDiscrimination, int CustomDiscriminationValue, SourceRange Range = {}, Spelling S = GNU_ptrauth_vtable_pointer);
14735   static VTablePointerAuthenticationAttr *Create(ASTContext &Ctx, VTablePointerAuthenticationAttr::VPtrAuthKeyType Key, VTablePointerAuthenticationAttr::AddressDiscriminationMode AddressDiscrimination, VTablePointerAuthenticationAttr::ExtraDiscrimination ExtraDiscrimination, int CustomDiscriminationValue, SourceRange Range = {}, Spelling S = GNU_ptrauth_vtable_pointer);
14736 
14737   // Constructors
14738   VTablePointerAuthenticationAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
14739               , VTablePointerAuthenticationAttr::VPtrAuthKeyType Key
14740               , VTablePointerAuthenticationAttr::AddressDiscriminationMode AddressDiscrimination
14741               , VTablePointerAuthenticationAttr::ExtraDiscrimination ExtraDiscrimination
14742               , int CustomDiscriminationValue
14743              );
14744   VTablePointerAuthenticationAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
14745               , VTablePointerAuthenticationAttr::VPtrAuthKeyType Key
14746               , VTablePointerAuthenticationAttr::AddressDiscriminationMode AddressDiscrimination
14747               , VTablePointerAuthenticationAttr::ExtraDiscrimination ExtraDiscrimination
14748              );
14749 
14750   VTablePointerAuthenticationAttr *clone(ASTContext &C) const;
14751   void printPretty(raw_ostream &OS,
14752                    const PrintingPolicy &Policy) const;
14753   const char *getSpelling() const;
14754   VTablePointerAuthenticationAttr::VPtrAuthKeyType getKey() const {
14755     return key;
14756   }
14757 
14758   static bool ConvertStrToVPtrAuthKeyType(StringRef Val, VTablePointerAuthenticationAttr::VPtrAuthKeyType &Out);
14759   static const char *ConvertVPtrAuthKeyTypeToStr(VTablePointerAuthenticationAttr::VPtrAuthKeyType Val);
14760   VTablePointerAuthenticationAttr::AddressDiscriminationMode getAddressDiscrimination() const {
14761     return addressDiscrimination;
14762   }
14763 
14764   static bool ConvertStrToAddressDiscriminationMode(StringRef Val, VTablePointerAuthenticationAttr::AddressDiscriminationMode &Out);
14765   static const char *ConvertAddressDiscriminationModeToStr(VTablePointerAuthenticationAttr::AddressDiscriminationMode Val);
14766   VTablePointerAuthenticationAttr::ExtraDiscrimination getExtraDiscrimination() const {
14767     return extraDiscrimination;
14768   }
14769 
14770   static bool ConvertStrToExtraDiscrimination(StringRef Val, VTablePointerAuthenticationAttr::ExtraDiscrimination &Out);
14771   static const char *ConvertExtraDiscriminationToStr(VTablePointerAuthenticationAttr::ExtraDiscrimination Val);
14772   int getCustomDiscriminationValue() const {
14773     return customDiscriminationValue;
14774   }
14775 
14776 
14777 
14778   static bool classof(const Attr *A) { return A->getKind() == attr::VTablePointerAuthentication; }
14779 };
14780 
14781 class CLANG_ABI VecReturnAttr : public InheritableAttr {
14782 public:
14783   enum Spelling {
14784     GNU_vecreturn = 0,
14785     CXX11_clang_vecreturn = 1,
14786   SpellingNotCalculated = 15
14787 
14788   };
14789 
14790   // Factory methods
14791   static VecReturnAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
14792   static VecReturnAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
14793   static VecReturnAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_vecreturn);
14794   static VecReturnAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_vecreturn);
14795 
14796   // Constructors
14797   VecReturnAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
14798              );
14799 
14800   VecReturnAttr *clone(ASTContext &C) const;
14801   void printPretty(raw_ostream &OS,
14802                    const PrintingPolicy &Policy) const;
14803   const char *getSpelling() const;
14804 
14805 
14806   static bool classof(const Attr *A) { return A->getKind() == attr::VecReturn; }
14807 };
14808 
14809 class CLANG_ABI VecTypeHintAttr : public InheritableAttr {
14810 TypeSourceInfo * typeHint;
14811 
14812 public:
14813   // Factory methods
14814   static VecTypeHintAttr *CreateImplicit(ASTContext &Ctx, TypeSourceInfo * TypeHint, const AttributeCommonInfo &CommonInfo);
14815   static VecTypeHintAttr *Create(ASTContext &Ctx, TypeSourceInfo * TypeHint, const AttributeCommonInfo &CommonInfo);
14816   static VecTypeHintAttr *CreateImplicit(ASTContext &Ctx, TypeSourceInfo * TypeHint, SourceRange Range = {});
14817   static VecTypeHintAttr *Create(ASTContext &Ctx, TypeSourceInfo * TypeHint, SourceRange Range = {});
14818 
14819   // Constructors
14820   VecTypeHintAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
14821               , TypeSourceInfo * TypeHint
14822              );
14823 
14824   VecTypeHintAttr *clone(ASTContext &C) const;
14825   void printPretty(raw_ostream &OS,
14826                    const PrintingPolicy &Policy) const;
14827   const char *getSpelling() const;
14828   QualType getTypeHint() const {
14829     return typeHint->getType();
14830   }  TypeSourceInfo * getTypeHintLoc() const {
14831     return typeHint;
14832   }
14833 
14834 
14835 
14836   static bool classof(const Attr *A) { return A->getKind() == attr::VecTypeHint; }
14837 };
14838 
14839 class CLANG_ABI VectorCallAttr : public InheritableAttr {
14840 public:
14841   enum Spelling {
14842     GNU_vectorcall = 0,
14843     CXX11_clang_vectorcall = 1,
14844     C23_clang_vectorcall = 2,
14845     Keyword_vectorcall = 3,
14846   SpellingNotCalculated = 15
14847 
14848   };
14849 
14850   // Factory methods
14851   static VectorCallAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
14852   static VectorCallAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
14853   static VectorCallAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_vectorcall);
14854   static VectorCallAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_vectorcall);
14855 
14856   // Constructors
14857   VectorCallAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
14858              );
14859 
14860   VectorCallAttr *clone(ASTContext &C) const;
14861   void printPretty(raw_ostream &OS,
14862                    const PrintingPolicy &Policy) const;
14863   const char *getSpelling() const;
14864 
14865 
14866   static bool classof(const Attr *A) { return A->getKind() == attr::VectorCall; }
14867 };
14868 
14869 class CLANG_ABI VisibilityAttr : public InheritableAttr {
14870 public:
14871   enum VisibilityType {
14872     Default,
14873     Hidden,
14874     Protected
14875   };
14876 private:
14877   VisibilityAttr::VisibilityType visibility;
14878 
14879 public:
14880   enum Spelling {
14881     GNU_visibility = 0,
14882     CXX11_gnu_visibility = 1,
14883     C23_gnu_visibility = 2,
14884   SpellingNotCalculated = 15
14885 
14886   };
14887 
14888   // Factory methods
14889   static VisibilityAttr *CreateImplicit(ASTContext &Ctx, VisibilityAttr::VisibilityType Visibility, const AttributeCommonInfo &CommonInfo);
14890   static VisibilityAttr *Create(ASTContext &Ctx, VisibilityAttr::VisibilityType Visibility, const AttributeCommonInfo &CommonInfo);
14891   static VisibilityAttr *CreateImplicit(ASTContext &Ctx, VisibilityAttr::VisibilityType Visibility, SourceRange Range = {}, Spelling S = GNU_visibility);
14892   static VisibilityAttr *Create(ASTContext &Ctx, VisibilityAttr::VisibilityType Visibility, SourceRange Range = {}, Spelling S = GNU_visibility);
14893 
14894   // Constructors
14895   VisibilityAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
14896               , VisibilityAttr::VisibilityType Visibility
14897              );
14898 
14899   VisibilityAttr *clone(ASTContext &C) const;
14900   void printPretty(raw_ostream &OS,
14901                    const PrintingPolicy &Policy) const;
14902   const char *getSpelling() const;
14903   VisibilityAttr::VisibilityType getVisibility() const {
14904     return visibility;
14905   }
14906 
14907   static bool ConvertStrToVisibilityType(StringRef Val, VisibilityAttr::VisibilityType &Out);
14908   static const char *ConvertVisibilityTypeToStr(VisibilityAttr::VisibilityType Val);
14909 
14910 
14911   static bool classof(const Attr *A) { return A->getKind() == attr::Visibility; }
14912 };
14913 
14914 class CLANG_ABI WarnUnusedAttr : public InheritableAttr {
14915 public:
14916   enum Spelling {
14917     GNU_warn_unused = 0,
14918     CXX11_gnu_warn_unused = 1,
14919     C23_gnu_warn_unused = 2,
14920   SpellingNotCalculated = 15
14921 
14922   };
14923 
14924   // Factory methods
14925   static WarnUnusedAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
14926   static WarnUnusedAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
14927   static WarnUnusedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_warn_unused);
14928   static WarnUnusedAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_warn_unused);
14929 
14930   // Constructors
14931   WarnUnusedAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
14932              );
14933 
14934   WarnUnusedAttr *clone(ASTContext &C) const;
14935   void printPretty(raw_ostream &OS,
14936                    const PrintingPolicy &Policy) const;
14937   const char *getSpelling() const;
14938 
14939 
14940   static bool classof(const Attr *A) { return A->getKind() == attr::WarnUnused; }
14941 };
14942 
14943 class CLANG_ABI WarnUnusedResultAttr : public InheritableAttr {
14944 unsigned messageLength;
14945 char *message;
14946 
14947 public:
14948   enum Spelling {
14949     CXX11_nodiscard = 0,
14950     C23_nodiscard = 1,
14951     CXX11_clang_warn_unused_result = 2,
14952     GNU_warn_unused_result = 3,
14953     CXX11_gnu_warn_unused_result = 4,
14954     C23_gnu_warn_unused_result = 5,
14955   SpellingNotCalculated = 15
14956 
14957   };
14958 
14959   // Factory methods
14960   static WarnUnusedResultAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Message, const AttributeCommonInfo &CommonInfo);
14961   static WarnUnusedResultAttr *Create(ASTContext &Ctx, llvm::StringRef Message, const AttributeCommonInfo &CommonInfo);
14962   static WarnUnusedResultAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Message, SourceRange Range = {}, Spelling S = CXX11_nodiscard);
14963   static WarnUnusedResultAttr *Create(ASTContext &Ctx, llvm::StringRef Message, SourceRange Range = {}, Spelling S = CXX11_nodiscard);
14964 
14965   // Constructors
14966   WarnUnusedResultAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
14967               , llvm::StringRef Message
14968              );
14969   WarnUnusedResultAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
14970              );
14971 
14972   WarnUnusedResultAttr *clone(ASTContext &C) const;
14973   void printPretty(raw_ostream &OS,
14974                    const PrintingPolicy &Policy) const;
14975   const char *getSpelling() const;
14976   Spelling getSemanticSpelling() const;
14977   llvm::StringRef getMessage() const {
14978     return llvm::StringRef(message, messageLength);
14979   }
14980   unsigned getMessageLength() const {
14981     return messageLength;
14982   }
14983   void setMessage(ASTContext &C, llvm::StringRef S) {
14984     messageLength = S.size();
14985     this->message = new (C, 1) char [messageLength];
14986     if (!S.empty())
14987       std::memcpy(this->message, S.data(), messageLength);
14988   }
14989 
14990 
14991     // Check whether this the C++11 nodiscard version, even in non C++11
14992     // spellings.
14993     bool IsCXX11NoDiscard() const {
14994       return this->getSemanticSpelling() == CXX11_nodiscard;
14995     }
14996   
14997 
14998   static bool classof(const Attr *A) { return A->getKind() == attr::WarnUnusedResult; }
14999 };
15000 
15001 class CLANG_ABI WeakAttr : public InheritableAttr {
15002 public:
15003   enum Spelling {
15004     GNU_weak = 0,
15005     CXX11_gnu_weak = 1,
15006     C23_gnu_weak = 2,
15007   SpellingNotCalculated = 15
15008 
15009   };
15010 
15011   // Factory methods
15012   static WeakAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
15013   static WeakAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
15014   static WeakAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_weak);
15015   static WeakAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_weak);
15016 
15017   // Constructors
15018   WeakAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
15019              );
15020 
15021   WeakAttr *clone(ASTContext &C) const;
15022   void printPretty(raw_ostream &OS,
15023                    const PrintingPolicy &Policy) const;
15024   const char *getSpelling() const;
15025 
15026 
15027   static bool classof(const Attr *A) { return A->getKind() == attr::Weak; }
15028 };
15029 
15030 class CLANG_ABI WeakImportAttr : public InheritableAttr {
15031 public:
15032   enum Spelling {
15033     GNU_weak_import = 0,
15034     CXX11_clang_weak_import = 1,
15035     C23_clang_weak_import = 2,
15036   SpellingNotCalculated = 15
15037 
15038   };
15039 
15040   // Factory methods
15041   static WeakImportAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
15042   static WeakImportAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
15043   static WeakImportAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_weak_import);
15044   static WeakImportAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_weak_import);
15045 
15046   // Constructors
15047   WeakImportAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
15048              );
15049 
15050   WeakImportAttr *clone(ASTContext &C) const;
15051   void printPretty(raw_ostream &OS,
15052                    const PrintingPolicy &Policy) const;
15053   const char *getSpelling() const;
15054 
15055 
15056   static bool classof(const Attr *A) { return A->getKind() == attr::WeakImport; }
15057 };
15058 
15059 class CLANG_ABI WeakRefAttr : public InheritableAttr {
15060 unsigned aliaseeLength;
15061 char *aliasee;
15062 
15063 public:
15064   enum Spelling {
15065     GNU_weakref = 0,
15066     CXX11_gnu_weakref = 1,
15067     C23_gnu_weakref = 2,
15068   SpellingNotCalculated = 15
15069 
15070   };
15071 
15072   // Factory methods
15073   static WeakRefAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Aliasee, const AttributeCommonInfo &CommonInfo);
15074   static WeakRefAttr *Create(ASTContext &Ctx, llvm::StringRef Aliasee, const AttributeCommonInfo &CommonInfo);
15075   static WeakRefAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Aliasee, SourceRange Range = {}, Spelling S = GNU_weakref);
15076   static WeakRefAttr *Create(ASTContext &Ctx, llvm::StringRef Aliasee, SourceRange Range = {}, Spelling S = GNU_weakref);
15077 
15078   // Constructors
15079   WeakRefAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
15080               , llvm::StringRef Aliasee
15081              );
15082   WeakRefAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
15083              );
15084 
15085   WeakRefAttr *clone(ASTContext &C) const;
15086   void printPretty(raw_ostream &OS,
15087                    const PrintingPolicy &Policy) const;
15088   const char *getSpelling() const;
15089   llvm::StringRef getAliasee() const {
15090     return llvm::StringRef(aliasee, aliaseeLength);
15091   }
15092   unsigned getAliaseeLength() const {
15093     return aliaseeLength;
15094   }
15095   void setAliasee(ASTContext &C, llvm::StringRef S) {
15096     aliaseeLength = S.size();
15097     this->aliasee = new (C, 1) char [aliaseeLength];
15098     if (!S.empty())
15099       std::memcpy(this->aliasee, S.data(), aliaseeLength);
15100   }
15101 
15102 
15103 
15104   static bool classof(const Attr *A) { return A->getKind() == attr::WeakRef; }
15105 };
15106 
15107 class CLANG_ABI WebAssemblyExportNameAttr : public InheritableAttr {
15108 unsigned exportNameLength;
15109 char *exportName;
15110 
15111 public:
15112   enum Spelling {
15113     GNU_export_name = 0,
15114     CXX11_clang_export_name = 1,
15115     C23_clang_export_name = 2,
15116   SpellingNotCalculated = 15
15117 
15118   };
15119 
15120   // Factory methods
15121   static WebAssemblyExportNameAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef ExportName, const AttributeCommonInfo &CommonInfo);
15122   static WebAssemblyExportNameAttr *Create(ASTContext &Ctx, llvm::StringRef ExportName, const AttributeCommonInfo &CommonInfo);
15123   static WebAssemblyExportNameAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef ExportName, SourceRange Range = {}, Spelling S = GNU_export_name);
15124   static WebAssemblyExportNameAttr *Create(ASTContext &Ctx, llvm::StringRef ExportName, SourceRange Range = {}, Spelling S = GNU_export_name);
15125 
15126   // Constructors
15127   WebAssemblyExportNameAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
15128               , llvm::StringRef ExportName
15129              );
15130 
15131   WebAssemblyExportNameAttr *clone(ASTContext &C) const;
15132   void printPretty(raw_ostream &OS,
15133                    const PrintingPolicy &Policy) const;
15134   const char *getSpelling() const;
15135   llvm::StringRef getExportName() const {
15136     return llvm::StringRef(exportName, exportNameLength);
15137   }
15138   unsigned getExportNameLength() const {
15139     return exportNameLength;
15140   }
15141   void setExportName(ASTContext &C, llvm::StringRef S) {
15142     exportNameLength = S.size();
15143     this->exportName = new (C, 1) char [exportNameLength];
15144     if (!S.empty())
15145       std::memcpy(this->exportName, S.data(), exportNameLength);
15146   }
15147 
15148 
15149 
15150   static bool classof(const Attr *A) { return A->getKind() == attr::WebAssemblyExportName; }
15151 };
15152 
15153 class CLANG_ABI WebAssemblyFuncrefAttr : public TypeAttr {
15154 public:
15155   // Factory methods
15156   static WebAssemblyFuncrefAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
15157   static WebAssemblyFuncrefAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
15158   static WebAssemblyFuncrefAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {});
15159   static WebAssemblyFuncrefAttr *Create(ASTContext &Ctx, SourceRange Range = {});
15160 
15161   // Constructors
15162   WebAssemblyFuncrefAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
15163              );
15164 
15165   WebAssemblyFuncrefAttr *clone(ASTContext &C) const;
15166   void printPretty(raw_ostream &OS,
15167                    const PrintingPolicy &Policy) const;
15168   const char *getSpelling() const;
15169 
15170 
15171   static bool classof(const Attr *A) { return A->getKind() == attr::WebAssemblyFuncref; }
15172 };
15173 
15174 class CLANG_ABI WebAssemblyImportModuleAttr : public InheritableAttr {
15175 unsigned importModuleLength;
15176 char *importModule;
15177 
15178 public:
15179   enum Spelling {
15180     GNU_import_module = 0,
15181     CXX11_clang_import_module = 1,
15182     C23_clang_import_module = 2,
15183   SpellingNotCalculated = 15
15184 
15185   };
15186 
15187   // Factory methods
15188   static WebAssemblyImportModuleAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef ImportModule, const AttributeCommonInfo &CommonInfo);
15189   static WebAssemblyImportModuleAttr *Create(ASTContext &Ctx, llvm::StringRef ImportModule, const AttributeCommonInfo &CommonInfo);
15190   static WebAssemblyImportModuleAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef ImportModule, SourceRange Range = {}, Spelling S = GNU_import_module);
15191   static WebAssemblyImportModuleAttr *Create(ASTContext &Ctx, llvm::StringRef ImportModule, SourceRange Range = {}, Spelling S = GNU_import_module);
15192 
15193   // Constructors
15194   WebAssemblyImportModuleAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
15195               , llvm::StringRef ImportModule
15196              );
15197 
15198   WebAssemblyImportModuleAttr *clone(ASTContext &C) const;
15199   void printPretty(raw_ostream &OS,
15200                    const PrintingPolicy &Policy) const;
15201   const char *getSpelling() const;
15202   llvm::StringRef getImportModule() const {
15203     return llvm::StringRef(importModule, importModuleLength);
15204   }
15205   unsigned getImportModuleLength() const {
15206     return importModuleLength;
15207   }
15208   void setImportModule(ASTContext &C, llvm::StringRef S) {
15209     importModuleLength = S.size();
15210     this->importModule = new (C, 1) char [importModuleLength];
15211     if (!S.empty())
15212       std::memcpy(this->importModule, S.data(), importModuleLength);
15213   }
15214 
15215 
15216 
15217   static bool classof(const Attr *A) { return A->getKind() == attr::WebAssemblyImportModule; }
15218 };
15219 
15220 class CLANG_ABI WebAssemblyImportNameAttr : public InheritableAttr {
15221 unsigned importNameLength;
15222 char *importName;
15223 
15224 public:
15225   enum Spelling {
15226     GNU_import_name = 0,
15227     CXX11_clang_import_name = 1,
15228     C23_clang_import_name = 2,
15229   SpellingNotCalculated = 15
15230 
15231   };
15232 
15233   // Factory methods
15234   static WebAssemblyImportNameAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef ImportName, const AttributeCommonInfo &CommonInfo);
15235   static WebAssemblyImportNameAttr *Create(ASTContext &Ctx, llvm::StringRef ImportName, const AttributeCommonInfo &CommonInfo);
15236   static WebAssemblyImportNameAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef ImportName, SourceRange Range = {}, Spelling S = GNU_import_name);
15237   static WebAssemblyImportNameAttr *Create(ASTContext &Ctx, llvm::StringRef ImportName, SourceRange Range = {}, Spelling S = GNU_import_name);
15238 
15239   // Constructors
15240   WebAssemblyImportNameAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
15241               , llvm::StringRef ImportName
15242              );
15243 
15244   WebAssemblyImportNameAttr *clone(ASTContext &C) const;
15245   void printPretty(raw_ostream &OS,
15246                    const PrintingPolicy &Policy) const;
15247   const char *getSpelling() const;
15248   llvm::StringRef getImportName() const {
15249     return llvm::StringRef(importName, importNameLength);
15250   }
15251   unsigned getImportNameLength() const {
15252     return importNameLength;
15253   }
15254   void setImportName(ASTContext &C, llvm::StringRef S) {
15255     importNameLength = S.size();
15256     this->importName = new (C, 1) char [importNameLength];
15257     if (!S.empty())
15258       std::memcpy(this->importName, S.data(), importNameLength);
15259   }
15260 
15261 
15262 
15263   static bool classof(const Attr *A) { return A->getKind() == attr::WebAssemblyImportName; }
15264 };
15265 
15266 class CLANG_ABI WorkGroupSizeHintAttr : public InheritableAttr {
15267 unsigned xDim;
15268 
15269 unsigned yDim;
15270 
15271 unsigned zDim;
15272 
15273 public:
15274   // Factory methods
15275   static WorkGroupSizeHintAttr *CreateImplicit(ASTContext &Ctx, unsigned XDim, unsigned YDim, unsigned ZDim, const AttributeCommonInfo &CommonInfo);
15276   static WorkGroupSizeHintAttr *Create(ASTContext &Ctx, unsigned XDim, unsigned YDim, unsigned ZDim, const AttributeCommonInfo &CommonInfo);
15277   static WorkGroupSizeHintAttr *CreateImplicit(ASTContext &Ctx, unsigned XDim, unsigned YDim, unsigned ZDim, SourceRange Range = {});
15278   static WorkGroupSizeHintAttr *Create(ASTContext &Ctx, unsigned XDim, unsigned YDim, unsigned ZDim, SourceRange Range = {});
15279 
15280   // Constructors
15281   WorkGroupSizeHintAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
15282               , unsigned XDim
15283               , unsigned YDim
15284               , unsigned ZDim
15285              );
15286 
15287   WorkGroupSizeHintAttr *clone(ASTContext &C) const;
15288   void printPretty(raw_ostream &OS,
15289                    const PrintingPolicy &Policy) const;
15290   const char *getSpelling() const;
15291   unsigned getXDim() const {
15292     return xDim;
15293   }
15294 
15295   unsigned getYDim() const {
15296     return yDim;
15297   }
15298 
15299   unsigned getZDim() const {
15300     return zDim;
15301   }
15302 
15303 
15304 
15305   static bool classof(const Attr *A) { return A->getKind() == attr::WorkGroupSizeHint; }
15306 };
15307 
15308 class CLANG_ABI X86ForceAlignArgPointerAttr : public InheritableAttr {
15309 public:
15310   enum Spelling {
15311     GNU_force_align_arg_pointer = 0,
15312     CXX11_gnu_force_align_arg_pointer = 1,
15313     C23_gnu_force_align_arg_pointer = 2,
15314   SpellingNotCalculated = 15
15315 
15316   };
15317 
15318   // Factory methods
15319   static X86ForceAlignArgPointerAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
15320   static X86ForceAlignArgPointerAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
15321   static X86ForceAlignArgPointerAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_force_align_arg_pointer);
15322   static X86ForceAlignArgPointerAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_force_align_arg_pointer);
15323 
15324   // Constructors
15325   X86ForceAlignArgPointerAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
15326              );
15327 
15328   X86ForceAlignArgPointerAttr *clone(ASTContext &C) const;
15329   void printPretty(raw_ostream &OS,
15330                    const PrintingPolicy &Policy) const;
15331   const char *getSpelling() const;
15332 
15333 
15334   static bool classof(const Attr *A) { return A->getKind() == attr::X86ForceAlignArgPointer; }
15335 };
15336 
15337 class CLANG_ABI XRayInstrumentAttr : public InheritableAttr {
15338 public:
15339   enum Spelling {
15340     GNU_xray_always_instrument = 0,
15341     CXX11_clang_xray_always_instrument = 1,
15342     C23_clang_xray_always_instrument = 2,
15343     GNU_xray_never_instrument = 3,
15344     CXX11_clang_xray_never_instrument = 4,
15345     C23_clang_xray_never_instrument = 5,
15346   SpellingNotCalculated = 15
15347 
15348   };
15349 
15350   // Factory methods
15351   static XRayInstrumentAttr *CreateImplicit(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
15352   static XRayInstrumentAttr *Create(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo);
15353   static XRayInstrumentAttr *CreateImplicit(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_xray_always_instrument);
15354   static XRayInstrumentAttr *Create(ASTContext &Ctx, SourceRange Range = {}, Spelling S = GNU_xray_always_instrument);
15355 
15356   // Constructors
15357   XRayInstrumentAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
15358              );
15359 
15360   XRayInstrumentAttr *clone(ASTContext &C) const;
15361   void printPretty(raw_ostream &OS,
15362                    const PrintingPolicy &Policy) const;
15363   const char *getSpelling() const;
15364   Spelling getSemanticSpelling() const;
15365   bool alwaysXRayInstrument() const { return getAttributeSpellingListIndex() == 0 ||
15366     getAttributeSpellingListIndex() == 1 ||
15367     getAttributeSpellingListIndex() == 2; }
15368   bool neverXRayInstrument() const { return getAttributeSpellingListIndex() == 3 ||
15369     getAttributeSpellingListIndex() == 4 ||
15370     getAttributeSpellingListIndex() == 5; }
15371 
15372 
15373   static bool classof(const Attr *A) { return A->getKind() == attr::XRayInstrument; }
15374 };
15375 
15376 class CLANG_ABI XRayLogArgsAttr : public InheritableAttr {
15377 unsigned argumentCount;
15378 
15379 public:
15380   enum Spelling {
15381     GNU_xray_log_args = 0,
15382     CXX11_clang_xray_log_args = 1,
15383     C23_clang_xray_log_args = 2,
15384   SpellingNotCalculated = 15
15385 
15386   };
15387 
15388   // Factory methods
15389   static XRayLogArgsAttr *CreateImplicit(ASTContext &Ctx, unsigned ArgumentCount, const AttributeCommonInfo &CommonInfo);
15390   static XRayLogArgsAttr *Create(ASTContext &Ctx, unsigned ArgumentCount, const AttributeCommonInfo &CommonInfo);
15391   static XRayLogArgsAttr *CreateImplicit(ASTContext &Ctx, unsigned ArgumentCount, SourceRange Range = {}, Spelling S = GNU_xray_log_args);
15392   static XRayLogArgsAttr *Create(ASTContext &Ctx, unsigned ArgumentCount, SourceRange Range = {}, Spelling S = GNU_xray_log_args);
15393 
15394   // Constructors
15395   XRayLogArgsAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
15396               , unsigned ArgumentCount
15397              );
15398 
15399   XRayLogArgsAttr *clone(ASTContext &C) const;
15400   void printPretty(raw_ostream &OS,
15401                    const PrintingPolicy &Policy) const;
15402   const char *getSpelling() const;
15403   unsigned getArgumentCount() const {
15404     return argumentCount;
15405   }
15406 
15407 
15408 
15409   static bool classof(const Attr *A) { return A->getKind() == attr::XRayLogArgs; }
15410 };
15411 
15412 class CLANG_ABI ZeroCallUsedRegsAttr : public InheritableAttr {
15413 public:
15414   enum ZeroCallUsedRegsKind {
15415     Skip,
15416     UsedGPRArg,
15417     UsedGPR,
15418     UsedArg,
15419     Used,
15420     AllGPRArg,
15421     AllGPR,
15422     AllArg,
15423     All
15424   };
15425 private:
15426   ZeroCallUsedRegsAttr::ZeroCallUsedRegsKind zeroCallUsedRegs;
15427 
15428 public:
15429   enum Spelling {
15430     GNU_zero_call_used_regs = 0,
15431     CXX11_gnu_zero_call_used_regs = 1,
15432     C23_gnu_zero_call_used_regs = 2,
15433   SpellingNotCalculated = 15
15434 
15435   };
15436 
15437   // Factory methods
15438   static ZeroCallUsedRegsAttr *CreateImplicit(ASTContext &Ctx, ZeroCallUsedRegsAttr::ZeroCallUsedRegsKind ZeroCallUsedRegs, const AttributeCommonInfo &CommonInfo);
15439   static ZeroCallUsedRegsAttr *Create(ASTContext &Ctx, ZeroCallUsedRegsAttr::ZeroCallUsedRegsKind ZeroCallUsedRegs, const AttributeCommonInfo &CommonInfo);
15440   static ZeroCallUsedRegsAttr *CreateImplicit(ASTContext &Ctx, ZeroCallUsedRegsAttr::ZeroCallUsedRegsKind ZeroCallUsedRegs, SourceRange Range = {}, Spelling S = GNU_zero_call_used_regs);
15441   static ZeroCallUsedRegsAttr *Create(ASTContext &Ctx, ZeroCallUsedRegsAttr::ZeroCallUsedRegsKind ZeroCallUsedRegs, SourceRange Range = {}, Spelling S = GNU_zero_call_used_regs);
15442 
15443   // Constructors
15444   ZeroCallUsedRegsAttr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo
15445               , ZeroCallUsedRegsAttr::ZeroCallUsedRegsKind ZeroCallUsedRegs
15446              );
15447 
15448   ZeroCallUsedRegsAttr *clone(ASTContext &C) const;
15449   void printPretty(raw_ostream &OS,
15450                    const PrintingPolicy &Policy) const;
15451   const char *getSpelling() const;
15452   ZeroCallUsedRegsAttr::ZeroCallUsedRegsKind getZeroCallUsedRegs() const {
15453     return zeroCallUsedRegs;
15454   }
15455 
15456   static bool ConvertStrToZeroCallUsedRegsKind(StringRef Val, ZeroCallUsedRegsAttr::ZeroCallUsedRegsKind &Out);
15457   static const char *ConvertZeroCallUsedRegsKindToStr(ZeroCallUsedRegsAttr::ZeroCallUsedRegsKind Val);
15458 
15459 
15460   static bool classof(const Attr *A) { return A->getKind() == attr::ZeroCallUsedRegs; }
15461 };
15462 
15463 #endif // LLVM_CLANG_ATTR_CLASSES_INC
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.3.7 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!