LCOV - code coverage report
Current view: top level - build-llvm/tools/clang/include/clang/AST - AttrImpl.inc (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 1243 6298 19.7 %
Date: 2017-09-14 15:23:50 Functions: 170 677 25.1 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
       2             : |*                                                                            *|
       3             : |* Attribute classes' member function definitions                             *|
       4             : |*                                                                            *|
       5             : |* Automatically generated file, do not edit!                                 *|
       6             : |*                                                                            *|
       7             : \*===----------------------------------------------------------------------===*/
       8             : 
       9           0 : AMDGPUFlatWorkGroupSizeAttr *AMDGPUFlatWorkGroupSizeAttr::clone(ASTContext &C) const {
      10           0 :   auto *A = new (C) AMDGPUFlatWorkGroupSizeAttr(getLocation(), C, min, max, getSpellingListIndex());
      11           0 :   A->Inherited = Inherited;
      12           0 :   A->IsPackExpansion = IsPackExpansion;
      13           0 :   A->Implicit = Implicit;
      14           0 :   return A;
      15             : }
      16             : 
      17           0 : void AMDGPUFlatWorkGroupSizeAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
      18           0 :   switch (SpellingListIndex) {
      19           0 :   default:
      20           0 :     llvm_unreachable("Unknown attribute spelling!");
      21             :     break;
      22           0 :   case 0 : {
      23           0 :     OS << " __attribute__((amdgpu_flat_work_group_size(" << getMin() << ", " << getMax() << ")))";
      24             :     break;
      25             :   }
      26             : }
      27           0 : }
      28             : 
      29          12 : const char *AMDGPUFlatWorkGroupSizeAttr::getSpelling() const {
      30          12 :   switch (SpellingListIndex) {
      31           0 :   default:
      32           0 :     llvm_unreachable("Unknown attribute spelling!");
      33             :     return "(No spelling)";
      34          12 :   case 0:
      35             :     return "amdgpu_flat_work_group_size";
      36             :   }
      37             : }
      38             : 
      39           0 : AMDGPUNumSGPRAttr *AMDGPUNumSGPRAttr::clone(ASTContext &C) const {
      40           0 :   auto *A = new (C) AMDGPUNumSGPRAttr(getLocation(), C, numSGPR, getSpellingListIndex());
      41           0 :   A->Inherited = Inherited;
      42           0 :   A->IsPackExpansion = IsPackExpansion;
      43           0 :   A->Implicit = Implicit;
      44           0 :   return A;
      45             : }
      46             : 
      47           0 : void AMDGPUNumSGPRAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
      48           0 :   switch (SpellingListIndex) {
      49           0 :   default:
      50           0 :     llvm_unreachable("Unknown attribute spelling!");
      51             :     break;
      52           0 :   case 0 : {
      53           0 :     OS << " __attribute__((amdgpu_num_sgpr(" << getNumSGPR() << ")))";
      54             :     break;
      55             :   }
      56             : }
      57           0 : }
      58             : 
      59           3 : const char *AMDGPUNumSGPRAttr::getSpelling() const {
      60           3 :   switch (SpellingListIndex) {
      61           0 :   default:
      62           0 :     llvm_unreachable("Unknown attribute spelling!");
      63             :     return "(No spelling)";
      64           3 :   case 0:
      65             :     return "amdgpu_num_sgpr";
      66             :   }
      67             : }
      68             : 
      69           0 : AMDGPUNumVGPRAttr *AMDGPUNumVGPRAttr::clone(ASTContext &C) const {
      70           0 :   auto *A = new (C) AMDGPUNumVGPRAttr(getLocation(), C, numVGPR, getSpellingListIndex());
      71           0 :   A->Inherited = Inherited;
      72           0 :   A->IsPackExpansion = IsPackExpansion;
      73           0 :   A->Implicit = Implicit;
      74           0 :   return A;
      75             : }
      76             : 
      77           0 : void AMDGPUNumVGPRAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
      78           0 :   switch (SpellingListIndex) {
      79           0 :   default:
      80           0 :     llvm_unreachable("Unknown attribute spelling!");
      81             :     break;
      82           0 :   case 0 : {
      83           0 :     OS << " __attribute__((amdgpu_num_vgpr(" << getNumVGPR() << ")))";
      84             :     break;
      85             :   }
      86             : }
      87           0 : }
      88             : 
      89           2 : const char *AMDGPUNumVGPRAttr::getSpelling() const {
      90           2 :   switch (SpellingListIndex) {
      91           0 :   default:
      92           0 :     llvm_unreachable("Unknown attribute spelling!");
      93             :     return "(No spelling)";
      94           2 :   case 0:
      95             :     return "amdgpu_num_vgpr";
      96             :   }
      97             : }
      98             : 
      99           0 : AMDGPUWavesPerEUAttr *AMDGPUWavesPerEUAttr::clone(ASTContext &C) const {
     100           0 :   auto *A = new (C) AMDGPUWavesPerEUAttr(getLocation(), C, min, max, getSpellingListIndex());
     101           0 :   A->Inherited = Inherited;
     102           0 :   A->IsPackExpansion = IsPackExpansion;
     103           0 :   A->Implicit = Implicit;
     104           0 :   return A;
     105             : }
     106             : 
     107           0 : void AMDGPUWavesPerEUAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
     108           0 :   switch (SpellingListIndex) {
     109           0 :   default:
     110           0 :     llvm_unreachable("Unknown attribute spelling!");
     111             :     break;
     112           0 :   case 0 : {
     113           0 :     OS << " __attribute__((amdgpu_waves_per_eu(" << getMin() << ", " << getMax() << ")))";
     114             :     break;
     115             :   }
     116             : }
     117           0 : }
     118             : 
     119           8 : const char *AMDGPUWavesPerEUAttr::getSpelling() const {
     120           8 :   switch (SpellingListIndex) {
     121           0 :   default:
     122           0 :     llvm_unreachable("Unknown attribute spelling!");
     123             :     return "(No spelling)";
     124           8 :   case 0:
     125             :     return "amdgpu_waves_per_eu";
     126             :   }
     127             : }
     128             : 
     129           0 : ARMInterruptAttr *ARMInterruptAttr::clone(ASTContext &C) const {
     130           0 :   auto *A = new (C) ARMInterruptAttr(getLocation(), C, interrupt, getSpellingListIndex());
     131           0 :   A->Inherited = Inherited;
     132           0 :   A->IsPackExpansion = IsPackExpansion;
     133           0 :   A->Implicit = Implicit;
     134           0 :   return A;
     135             : }
     136             : 
     137           0 : void ARMInterruptAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
     138           0 :   switch (SpellingListIndex) {
     139           0 :   default:
     140           0 :     llvm_unreachable("Unknown attribute spelling!");
     141             :     break;
     142           0 :   case 0 : {
     143           0 :     OS << " __attribute__((interrupt(\"" << ARMInterruptAttr::ConvertInterruptTypeToStr(getInterrupt()) << "\")))";
     144             :     break;
     145             :   }
     146             : }
     147           0 : }
     148             : 
     149           0 : const char *ARMInterruptAttr::getSpelling() const {
     150           0 :   switch (SpellingListIndex) {
     151           0 :   default:
     152           0 :     llvm_unreachable("Unknown attribute spelling!");
     153             :     return "(No spelling)";
     154           0 :   case 0:
     155             :     return "interrupt";
     156             :   }
     157             : }
     158             : 
     159           0 : AVRInterruptAttr *AVRInterruptAttr::clone(ASTContext &C) const {
     160           0 :   auto *A = new (C) AVRInterruptAttr(getLocation(), C, getSpellingListIndex());
     161           0 :   A->Inherited = Inherited;
     162           0 :   A->IsPackExpansion = IsPackExpansion;
     163           0 :   A->Implicit = Implicit;
     164           0 :   return A;
     165             : }
     166             : 
     167           0 : void AVRInterruptAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
     168           0 :   switch (SpellingListIndex) {
     169           0 :   default:
     170           0 :     llvm_unreachable("Unknown attribute spelling!");
     171             :     break;
     172           0 :   case 0 : {
     173           0 :     OS << " __attribute__((interrupt))";
     174             :     break;
     175             :   }
     176             : }
     177           0 : }
     178             : 
     179           0 : const char *AVRInterruptAttr::getSpelling() const {
     180           0 :   switch (SpellingListIndex) {
     181           0 :   default:
     182           0 :     llvm_unreachable("Unknown attribute spelling!");
     183             :     return "(No spelling)";
     184           0 :   case 0:
     185             :     return "interrupt";
     186             :   }
     187             : }
     188             : 
     189           0 : AVRSignalAttr *AVRSignalAttr::clone(ASTContext &C) const {
     190           0 :   auto *A = new (C) AVRSignalAttr(getLocation(), C, getSpellingListIndex());
     191           0 :   A->Inherited = Inherited;
     192           0 :   A->IsPackExpansion = IsPackExpansion;
     193           0 :   A->Implicit = Implicit;
     194           0 :   return A;
     195             : }
     196             : 
     197           0 : void AVRSignalAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
     198           0 :   switch (SpellingListIndex) {
     199           0 :   default:
     200           0 :     llvm_unreachable("Unknown attribute spelling!");
     201             :     break;
     202           0 :   case 0 : {
     203           0 :     OS << " __attribute__((signal))";
     204             :     break;
     205             :   }
     206             : }
     207           0 : }
     208             : 
     209           0 : const char *AVRSignalAttr::getSpelling() const {
     210           0 :   switch (SpellingListIndex) {
     211           0 :   default:
     212           0 :     llvm_unreachable("Unknown attribute spelling!");
     213             :     return "(No spelling)";
     214           0 :   case 0:
     215             :     return "signal";
     216             :   }
     217             : }
     218             : 
     219         819 : AbiTagAttr *AbiTagAttr::clone(ASTContext &C) const {
     220        4095 :   auto *A = new (C) AbiTagAttr(getLocation(), C, tags_, tags_Size, getSpellingListIndex());
     221         819 :   A->Inherited = Inherited;
     222         819 :   A->IsPackExpansion = IsPackExpansion;
     223         819 :   A->Implicit = Implicit;
     224         819 :   return A;
     225             : }
     226             : 
     227           0 : void AbiTagAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
     228           0 :   switch (SpellingListIndex) {
     229           0 :   default:
     230           0 :     llvm_unreachable("Unknown attribute spelling!");
     231             :     break;
     232           0 :   case 0 : {
     233           0 :     OS << " __attribute__((abi_tag(";
     234           0 :   bool isFirst = true;
     235           0 :   for (const auto &Val : tags()) {
     236           0 :     if (isFirst) isFirst = false;
     237           0 :     else OS << ", ";
     238           0 :     OS << "\"" << Val << "\"";
     239             :   }
     240           0 :   OS << ")))";
     241           0 :     break;
     242             :   }
     243           0 :   case 1 : {
     244           0 :     OS << " [[gnu::abi_tag(";
     245           0 :   bool isFirst = true;
     246           0 :   for (const auto &Val : tags()) {
     247           0 :     if (isFirst) isFirst = false;
     248           0 :     else OS << ", ";
     249           0 :     OS << "\"" << Val << "\"";
     250             :   }
     251           0 :   OS << ")]]";
     252           0 :     break;
     253             :   }
     254             : }
     255           0 : }
     256             : 
     257           0 : const char *AbiTagAttr::getSpelling() const {
     258           0 :   switch (SpellingListIndex) {
     259           0 :   default:
     260           0 :     llvm_unreachable("Unknown attribute spelling!");
     261             :     return "(No spelling)";
     262             :   case 0:
     263             :     return "abi_tag";
     264             :   case 1:
     265             :     return "abi_tag";
     266             :   }
     267             : }
     268             : 
     269          28 : AcquireCapabilityAttr *AcquireCapabilityAttr::clone(ASTContext &C) const {
     270         140 :   auto *A = new (C) AcquireCapabilityAttr(getLocation(), C, args_, args_Size, getSpellingListIndex());
     271          28 :   A->Inherited = Inherited;
     272          28 :   A->IsPackExpansion = IsPackExpansion;
     273          28 :   A->Implicit = Implicit;
     274          28 :   return A;
     275             : }
     276             : 
     277           0 : void AcquireCapabilityAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
     278           0 :   switch (SpellingListIndex) {
     279           0 :   default:
     280           0 :     llvm_unreachable("Unknown attribute spelling!");
     281             :     break;
     282           0 :   case 0 : {
     283           0 :     OS << " __attribute__((acquire_capability(";
     284           0 :   bool isFirst = true;
     285           0 :   for (const auto &Val : args()) {
     286           0 :     if (isFirst) isFirst = false;
     287           0 :     else OS << ", ";
     288           0 :     OS << Val;
     289             :   }
     290           0 :   OS << ")))";
     291           0 :     break;
     292             :   }
     293           0 :   case 1 : {
     294           0 :     OS << " [[clang::acquire_capability(";
     295           0 :   bool isFirst = true;
     296           0 :   for (const auto &Val : args()) {
     297           0 :     if (isFirst) isFirst = false;
     298           0 :     else OS << ", ";
     299           0 :     OS << Val;
     300             :   }
     301           0 :   OS << ")]]";
     302           0 :     break;
     303             :   }
     304           0 :   case 2 : {
     305           0 :     OS << " __attribute__((acquire_shared_capability(";
     306           0 :   bool isFirst = true;
     307           0 :   for (const auto &Val : args()) {
     308           0 :     if (isFirst) isFirst = false;
     309           0 :     else OS << ", ";
     310           0 :     OS << Val;
     311             :   }
     312           0 :   OS << ")))";
     313           0 :     break;
     314             :   }
     315           0 :   case 3 : {
     316           0 :     OS << " [[clang::acquire_shared_capability(";
     317           0 :   bool isFirst = true;
     318           0 :   for (const auto &Val : args()) {
     319           0 :     if (isFirst) isFirst = false;
     320           0 :     else OS << ", ";
     321           0 :     OS << Val;
     322             :   }
     323           0 :   OS << ")]]";
     324           0 :     break;
     325             :   }
     326           0 :   case 4 : {
     327           0 :     OS << " __attribute__((exclusive_lock_function(";
     328           0 :   bool isFirst = true;
     329           0 :   for (const auto &Val : args()) {
     330           0 :     if (isFirst) isFirst = false;
     331           0 :     else OS << ", ";
     332           0 :     OS << Val;
     333             :   }
     334           0 :   OS << ")))";
     335           0 :     break;
     336             :   }
     337           0 :   case 5 : {
     338           0 :     OS << " __attribute__((shared_lock_function(";
     339           0 :   bool isFirst = true;
     340           0 :   for (const auto &Val : args()) {
     341           0 :     if (isFirst) isFirst = false;
     342           0 :     else OS << ", ";
     343           0 :     OS << Val;
     344             :   }
     345           0 :   OS << ")))";
     346           0 :     break;
     347             :   }
     348             : }
     349           0 : }
     350             : 
     351           0 : const char *AcquireCapabilityAttr::getSpelling() const {
     352           0 :   switch (SpellingListIndex) {
     353           0 :   default:
     354           0 :     llvm_unreachable("Unknown attribute spelling!");
     355             :     return "(No spelling)";
     356             :   case 0:
     357             :     return "acquire_capability";
     358             :   case 1:
     359             :     return "acquire_capability";
     360           0 :   case 2:
     361           0 :     return "acquire_shared_capability";
     362           0 :   case 3:
     363           0 :     return "acquire_shared_capability";
     364           0 :   case 4:
     365           0 :     return "exclusive_lock_function";
     366           0 :   case 5:
     367           0 :     return "shared_lock_function";
     368             :   }
     369             : }
     370             : 
     371           0 : AcquiredAfterAttr *AcquiredAfterAttr::clone(ASTContext &C) const {
     372           0 :   auto *A = new (C) AcquiredAfterAttr(getLocation(), C, args_, args_Size, getSpellingListIndex());
     373           0 :   A->Inherited = Inherited;
     374           0 :   A->IsPackExpansion = IsPackExpansion;
     375           0 :   A->Implicit = Implicit;
     376           0 :   return A;
     377             : }
     378             : 
     379           0 : void AcquiredAfterAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
     380           0 :   switch (SpellingListIndex) {
     381           0 :   default:
     382           0 :     llvm_unreachable("Unknown attribute spelling!");
     383             :     break;
     384           0 :   case 0 : {
     385           0 :     OS << " __attribute__((acquired_after(";
     386           0 :   bool isFirst = true;
     387           0 :   for (const auto &Val : args()) {
     388           0 :     if (isFirst) isFirst = false;
     389           0 :     else OS << ", ";
     390           0 :     OS << Val;
     391             :   }
     392           0 :   OS << ")))";
     393             :     break;
     394             :   }
     395             : }
     396           0 : }
     397             : 
     398           0 : const char *AcquiredAfterAttr::getSpelling() const {
     399           0 :   switch (SpellingListIndex) {
     400           0 :   default:
     401           0 :     llvm_unreachable("Unknown attribute spelling!");
     402             :     return "(No spelling)";
     403           0 :   case 0:
     404             :     return "acquired_after";
     405             :   }
     406             : }
     407             : 
     408           0 : AcquiredBeforeAttr *AcquiredBeforeAttr::clone(ASTContext &C) const {
     409           0 :   auto *A = new (C) AcquiredBeforeAttr(getLocation(), C, args_, args_Size, getSpellingListIndex());
     410           0 :   A->Inherited = Inherited;
     411           0 :   A->IsPackExpansion = IsPackExpansion;
     412           0 :   A->Implicit = Implicit;
     413           0 :   return A;
     414             : }
     415             : 
     416           0 : void AcquiredBeforeAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
     417           0 :   switch (SpellingListIndex) {
     418           0 :   default:
     419           0 :     llvm_unreachable("Unknown attribute spelling!");
     420             :     break;
     421           0 :   case 0 : {
     422           0 :     OS << " __attribute__((acquired_before(";
     423           0 :   bool isFirst = true;
     424           0 :   for (const auto &Val : args()) {
     425           0 :     if (isFirst) isFirst = false;
     426           0 :     else OS << ", ";
     427           0 :     OS << Val;
     428             :   }
     429           0 :   OS << ")))";
     430             :     break;
     431             :   }
     432             : }
     433           0 : }
     434             : 
     435           0 : const char *AcquiredBeforeAttr::getSpelling() const {
     436           0 :   switch (SpellingListIndex) {
     437           0 :   default:
     438           0 :     llvm_unreachable("Unknown attribute spelling!");
     439             :     return "(No spelling)";
     440           0 :   case 0:
     441             :     return "acquired_before";
     442             :   }
     443             : }
     444             : 
     445           0 : AliasAttr *AliasAttr::clone(ASTContext &C) const {
     446           0 :   auto *A = new (C) AliasAttr(getLocation(), C, getAliasee(), getSpellingListIndex());
     447           0 :   A->Inherited = Inherited;
     448           0 :   A->IsPackExpansion = IsPackExpansion;
     449           0 :   A->Implicit = Implicit;
     450           0 :   return A;
     451             : }
     452             : 
     453           0 : void AliasAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
     454           0 :   switch (SpellingListIndex) {
     455           0 :   default:
     456           0 :     llvm_unreachable("Unknown attribute spelling!");
     457             :     break;
     458           0 :   case 0 : {
     459           0 :     OS << " __attribute__((alias(\"" << getAliasee() << "\")))";
     460           0 :     break;
     461             :   }
     462           0 :   case 1 : {
     463           0 :     OS << " [[gnu::alias(\"" << getAliasee() << "\")]]";
     464           0 :     break;
     465             :   }
     466             : }
     467           0 : }
     468             : 
     469           0 : const char *AliasAttr::getSpelling() const {
     470           0 :   switch (SpellingListIndex) {
     471           0 :   default:
     472           0 :     llvm_unreachable("Unknown attribute spelling!");
     473             :     return "(No spelling)";
     474             :   case 0:
     475             :     return "alias";
     476             :   case 1:
     477             :     return "alias";
     478             :   }
     479             : }
     480             : 
     481           0 : AlignMac68kAttr *AlignMac68kAttr::clone(ASTContext &C) const {
     482           0 :   auto *A = new (C) AlignMac68kAttr(getLocation(), C, getSpellingListIndex());
     483           0 :   A->Inherited = Inherited;
     484           0 :   A->IsPackExpansion = IsPackExpansion;
     485           0 :   A->Implicit = Implicit;
     486           0 :   return A;
     487             : }
     488             : 
     489           0 : void AlignMac68kAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
     490           0 : }
     491             : 
     492           0 : const char *AlignMac68kAttr::getSpelling() const {
     493           0 :   return "(No spelling)";
     494             : }
     495             : 
     496           0 : AlignValueAttr *AlignValueAttr::clone(ASTContext &C) const {
     497           0 :   auto *A = new (C) AlignValueAttr(getLocation(), C, alignment, getSpellingListIndex());
     498           0 :   A->Inherited = Inherited;
     499           0 :   A->IsPackExpansion = IsPackExpansion;
     500           0 :   A->Implicit = Implicit;
     501           0 :   return A;
     502             : }
     503             : 
     504           0 : void AlignValueAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
     505           0 :   switch (SpellingListIndex) {
     506           0 :   default:
     507           0 :     llvm_unreachable("Unknown attribute spelling!");
     508             :     break;
     509           0 :   case 0 : {
     510           0 :     OS << " __attribute__((align_value(" << getAlignment() << ")))";
     511             :     break;
     512             :   }
     513             : }
     514           0 : }
     515             : 
     516           1 : const char *AlignValueAttr::getSpelling() const {
     517           1 :   switch (SpellingListIndex) {
     518           0 :   default:
     519           0 :     llvm_unreachable("Unknown attribute spelling!");
     520             :     return "(No spelling)";
     521           1 :   case 0:
     522             :     return "align_value";
     523             :   }
     524             : }
     525             : 
     526        1995 : bool AlignedAttr::isAlignmentDependent() const {
     527        1995 :   if (isalignmentExpr)
     528        5698 :     return alignmentExpr && (alignmentExpr->isValueDependent() || alignmentExpr->isTypeDependent());
     529             :   else
     530           0 :     return alignmentType->getType()->isDependentType();
     531             : }
     532        3610 : unsigned AlignedAttr::getAlignment(ASTContext &Ctx) const {
     533             :   assert(!isAlignmentDependent());
     534        3610 :   if (isalignmentExpr)
     535       14414 :     return alignmentExpr ? alignmentExpr->EvaluateKnownConstInt(Ctx).getZExtValue() * Ctx.getCharWidth() : Ctx.getTargetDefaultAlignForAttributeAligned();
     536             :   else
     537             :     return 0; // FIXME
     538             : }
     539         143 : AlignedAttr *AlignedAttr::clone(ASTContext &C) const {
     540         715 :   auto *A = new (C) AlignedAttr(getLocation(), C, isalignmentExpr, isalignmentExpr ? static_cast<void*>(alignmentExpr) : alignmentType, getSpellingListIndex());
     541         143 :   A->Inherited = Inherited;
     542         143 :   A->IsPackExpansion = IsPackExpansion;
     543         143 :   A->Implicit = Implicit;
     544         143 :   return A;
     545             : }
     546             : 
     547          20 : void AlignedAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
     548          20 :   switch (SpellingListIndex) {
     549           0 :   default:
     550           0 :     llvm_unreachable("Unknown attribute spelling!");
     551             :     break;
     552          12 :   case 0 : {
     553          12 :     OS << " __attribute__((aligned(";
     554          12 :     if (isalignmentExpr && alignmentExpr)
     555          10 :       alignmentExpr->printPretty(OS, nullptr, Policy);
     556          12 :     OS << ")))";
     557          12 :     break;
     558             :   }
     559           1 :   case 1 : {
     560           1 :     OS << " [[gnu::aligned(";
     561           1 :     if (isalignmentExpr && alignmentExpr)
     562           1 :       alignmentExpr->printPretty(OS, nullptr, Policy);
     563           1 :     OS << ")]]";
     564           1 :     break;
     565             :   }
     566           3 :   case 2 : {
     567           3 :     OS << " __declspec(align(";
     568           3 :     if (isalignmentExpr && alignmentExpr)
     569           3 :       alignmentExpr->printPretty(OS, nullptr, Policy);
     570           3 :     OS << "))";
     571           3 :     break;
     572             :   }
     573           3 :   case 3 : {
     574           3 :     OS << " alignas(";
     575           3 :     if (isalignmentExpr && alignmentExpr)
     576           3 :       alignmentExpr->printPretty(OS, nullptr, Policy);
     577           3 :     OS << ")";
     578           3 :     break;
     579             :   }
     580           1 :   case 4 : {
     581           1 :     OS << " _Alignas(";
     582           1 :     if (isalignmentExpr && alignmentExpr)
     583           1 :       alignmentExpr->printPretty(OS, nullptr, Policy);
     584           1 :     OS << ")";
     585           1 :     break;
     586             :   }
     587             : }
     588          20 : }
     589             : 
     590          37 : const char *AlignedAttr::getSpelling() const {
     591          37 :   switch (SpellingListIndex) {
     592           0 :   default:
     593           0 :     llvm_unreachable("Unknown attribute spelling!");
     594             :     return "(No spelling)";
     595             :   case 0:
     596             :     return "aligned";
     597             :   case 1:
     598             :     return "aligned";
     599           0 :   case 2:
     600           0 :     return "align";
     601          23 :   case 3:
     602          23 :     return "alignas";
     603           8 :   case 4:
     604           8 :     return "_Alignas";
     605             :   }
     606             : }
     607             : 
     608           0 : AllocAlignAttr *AllocAlignAttr::clone(ASTContext &C) const {
     609           0 :   auto *A = new (C) AllocAlignAttr(getLocation(), C, paramIndex, getSpellingListIndex());
     610           0 :   A->Inherited = Inherited;
     611           0 :   A->IsPackExpansion = IsPackExpansion;
     612           0 :   A->Implicit = Implicit;
     613           0 :   return A;
     614             : }
     615             : 
     616           0 : void AllocAlignAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
     617           0 :   switch (SpellingListIndex) {
     618           0 :   default:
     619           0 :     llvm_unreachable("Unknown attribute spelling!");
     620             :     break;
     621           0 :   case 0 : {
     622           0 :     OS << " __attribute__((alloc_align(" << getParamIndex() << ")))";
     623           0 :     break;
     624             :   }
     625           0 :   case 1 : {
     626           0 :     OS << " [[gnu::alloc_align(" << getParamIndex() << ")]]";
     627           0 :     break;
     628             :   }
     629             : }
     630           0 : }
     631             : 
     632          10 : const char *AllocAlignAttr::getSpelling() const {
     633          10 :   switch (SpellingListIndex) {
     634           0 :   default:
     635           0 :     llvm_unreachable("Unknown attribute spelling!");
     636             :     return "(No spelling)";
     637             :   case 0:
     638             :     return "alloc_align";
     639             :   case 1:
     640             :     return "alloc_align";
     641             :   }
     642             : }
     643             : 
     644           0 : AllocSizeAttr *AllocSizeAttr::clone(ASTContext &C) const {
     645           0 :   auto *A = new (C) AllocSizeAttr(getLocation(), C, elemSizeParam, numElemsParam, getSpellingListIndex());
     646           0 :   A->Inherited = Inherited;
     647           0 :   A->IsPackExpansion = IsPackExpansion;
     648           0 :   A->Implicit = Implicit;
     649           0 :   return A;
     650             : }
     651             : 
     652           0 : void AllocSizeAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
     653           0 :   switch (SpellingListIndex) {
     654           0 :   default:
     655           0 :     llvm_unreachable("Unknown attribute spelling!");
     656             :     break;
     657           0 :   case 0 : {
     658           0 :     OS << " __attribute__((alloc_size(" << getElemSizeParam() << ", " << getNumElemsParam() << ")))";
     659           0 :     break;
     660             :   }
     661           0 :   case 1 : {
     662           0 :     OS << " [[gnu::alloc_size(" << getElemSizeParam() << ", " << getNumElemsParam() << ")]]";
     663           0 :     break;
     664             :   }
     665             : }
     666           0 : }
     667             : 
     668           0 : const char *AllocSizeAttr::getSpelling() const {
     669           0 :   switch (SpellingListIndex) {
     670           0 :   default:
     671           0 :     llvm_unreachable("Unknown attribute spelling!");
     672             :     return "(No spelling)";
     673             :   case 0:
     674             :     return "alloc_size";
     675             :   case 1:
     676             :     return "alloc_size";
     677             :   }
     678             : }
     679             : 
     680          13 : AlwaysInlineAttr *AlwaysInlineAttr::clone(ASTContext &C) const {
     681          65 :   auto *A = new (C) AlwaysInlineAttr(getLocation(), C, getSpellingListIndex());
     682          13 :   A->Inherited = Inherited;
     683          13 :   A->IsPackExpansion = IsPackExpansion;
     684          13 :   A->Implicit = Implicit;
     685          13 :   return A;
     686             : }
     687             : 
     688           0 : void AlwaysInlineAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
     689           0 :   switch (SpellingListIndex) {
     690           0 :   default:
     691           0 :     llvm_unreachable("Unknown attribute spelling!");
     692             :     break;
     693           0 :   case 0 : {
     694           0 :     OS << " __attribute__((always_inline))";
     695           0 :     break;
     696             :   }
     697           0 :   case 1 : {
     698           0 :     OS << " [[gnu::always_inline]]";
     699           0 :     break;
     700             :   }
     701           0 :   case 2 : {
     702           0 :     OS << " __forceinline";
     703           0 :     break;
     704             :   }
     705             : }
     706           0 : }
     707             : 
     708         677 : const char *AlwaysInlineAttr::getSpelling() const {
     709         677 :   switch (SpellingListIndex) {
     710           0 :   default:
     711           0 :     llvm_unreachable("Unknown attribute spelling!");
     712             :     return "(No spelling)";
     713             :   case 0:
     714             :     return "always_inline";
     715             :   case 1:
     716             :     return "always_inline";
     717           5 :   case 2:
     718           5 :     return "__forceinline";
     719             :   }
     720             : }
     721             : 
     722           0 : AnalyzerNoReturnAttr *AnalyzerNoReturnAttr::clone(ASTContext &C) const {
     723           0 :   auto *A = new (C) AnalyzerNoReturnAttr(getLocation(), C, getSpellingListIndex());
     724           0 :   A->Inherited = Inherited;
     725           0 :   A->IsPackExpansion = IsPackExpansion;
     726           0 :   A->Implicit = Implicit;
     727           0 :   return A;
     728             : }
     729             : 
     730           0 : void AnalyzerNoReturnAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
     731           0 :   switch (SpellingListIndex) {
     732           0 :   default:
     733           0 :     llvm_unreachable("Unknown attribute spelling!");
     734             :     break;
     735           0 :   case 0 : {
     736           0 :     OS << " __attribute__((analyzer_noreturn))";
     737             :     break;
     738             :   }
     739             : }
     740           0 : }
     741             : 
     742           0 : const char *AnalyzerNoReturnAttr::getSpelling() const {
     743           0 :   switch (SpellingListIndex) {
     744           0 :   default:
     745           0 :     llvm_unreachable("Unknown attribute spelling!");
     746             :     return "(No spelling)";
     747           0 :   case 0:
     748             :     return "analyzer_noreturn";
     749             :   }
     750             : }
     751             : 
     752          42 : AnnotateAttr *AnnotateAttr::clone(ASTContext &C) const {
     753         252 :   auto *A = new (C) AnnotateAttr(getLocation(), C, getAnnotation(), getSpellingListIndex());
     754          42 :   A->Inherited = Inherited;
     755          42 :   A->IsPackExpansion = IsPackExpansion;
     756          42 :   A->Implicit = Implicit;
     757          42 :   return A;
     758             : }
     759             : 
     760           0 : void AnnotateAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
     761           0 :   switch (SpellingListIndex) {
     762           0 :   default:
     763           0 :     llvm_unreachable("Unknown attribute spelling!");
     764             :     break;
     765           0 :   case 0 : {
     766           0 :     OS << " __attribute__((annotate(\"" << getAnnotation() << "\")))";
     767             :     break;
     768             :   }
     769             : }
     770           0 : }
     771             : 
     772           0 : const char *AnnotateAttr::getSpelling() const {
     773           0 :   switch (SpellingListIndex) {
     774           0 :   default:
     775           0 :     llvm_unreachable("Unknown attribute spelling!");
     776             :     return "(No spelling)";
     777           0 :   case 0:
     778             :     return "annotate";
     779             :   }
     780             : }
     781             : 
     782           5 : AnyX86InterruptAttr *AnyX86InterruptAttr::clone(ASTContext &C) const {
     783          25 :   auto *A = new (C) AnyX86InterruptAttr(getLocation(), C, getSpellingListIndex());
     784           5 :   A->Inherited = Inherited;
     785           5 :   A->IsPackExpansion = IsPackExpansion;
     786           5 :   A->Implicit = Implicit;
     787           5 :   return A;
     788             : }
     789             : 
     790           0 : void AnyX86InterruptAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
     791           0 :   switch (SpellingListIndex) {
     792           0 :   default:
     793           0 :     llvm_unreachable("Unknown attribute spelling!");
     794             :     break;
     795           0 :   case 0 : {
     796           0 :     OS << " __attribute__((interrupt))";
     797             :     break;
     798             :   }
     799             : }
     800           0 : }
     801             : 
     802           0 : const char *AnyX86InterruptAttr::getSpelling() const {
     803           0 :   switch (SpellingListIndex) {
     804           0 :   default:
     805           0 :     llvm_unreachable("Unknown attribute spelling!");
     806             :     return "(No spelling)";
     807           0 :   case 0:
     808             :     return "interrupt";
     809             :   }
     810             : }
     811             : 
     812           0 : AnyX86NoCallerSavedRegistersAttr *AnyX86NoCallerSavedRegistersAttr::clone(ASTContext &C) const {
     813           0 :   auto *A = new (C) AnyX86NoCallerSavedRegistersAttr(getLocation(), C, getSpellingListIndex());
     814           0 :   A->Inherited = Inherited;
     815           0 :   A->IsPackExpansion = IsPackExpansion;
     816           0 :   A->Implicit = Implicit;
     817           0 :   return A;
     818             : }
     819             : 
     820           0 : void AnyX86NoCallerSavedRegistersAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
     821           0 :   switch (SpellingListIndex) {
     822           0 :   default:
     823           0 :     llvm_unreachable("Unknown attribute spelling!");
     824             :     break;
     825           0 :   case 0 : {
     826           0 :     OS << " __attribute__((no_caller_saved_registers))";
     827           0 :     break;
     828             :   }
     829           0 :   case 1 : {
     830           0 :     OS << " [[gnu::no_caller_saved_registers]]";
     831           0 :     break;
     832             :   }
     833             : }
     834           0 : }
     835             : 
     836           2 : const char *AnyX86NoCallerSavedRegistersAttr::getSpelling() const {
     837           2 :   switch (SpellingListIndex) {
     838           0 :   default:
     839           0 :     llvm_unreachable("Unknown attribute spelling!");
     840             :     return "(No spelling)";
     841             :   case 0:
     842             :     return "no_caller_saved_registers";
     843             :   case 1:
     844             :     return "no_caller_saved_registers";
     845             :   }
     846             : }
     847             : 
     848           0 : ArcWeakrefUnavailableAttr *ArcWeakrefUnavailableAttr::clone(ASTContext &C) const {
     849           0 :   auto *A = new (C) ArcWeakrefUnavailableAttr(getLocation(), C, getSpellingListIndex());
     850           0 :   A->Inherited = Inherited;
     851           0 :   A->IsPackExpansion = IsPackExpansion;
     852           0 :   A->Implicit = Implicit;
     853           0 :   return A;
     854             : }
     855             : 
     856           0 : void ArcWeakrefUnavailableAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
     857           0 :   switch (SpellingListIndex) {
     858           0 :   default:
     859           0 :     llvm_unreachable("Unknown attribute spelling!");
     860             :     break;
     861           0 :   case 0 : {
     862           0 :     OS << " __attribute__((objc_arc_weak_reference_unavailable))";
     863             :     break;
     864             :   }
     865             : }
     866           0 : }
     867             : 
     868           0 : const char *ArcWeakrefUnavailableAttr::getSpelling() const {
     869           0 :   switch (SpellingListIndex) {
     870           0 :   default:
     871           0 :     llvm_unreachable("Unknown attribute spelling!");
     872             :     return "(No spelling)";
     873           0 :   case 0:
     874             :     return "objc_arc_weak_reference_unavailable";
     875             :   }
     876             : }
     877             : 
     878           0 : ArgumentWithTypeTagAttr *ArgumentWithTypeTagAttr::clone(ASTContext &C) const {
     879           0 :   auto *A = new (C) ArgumentWithTypeTagAttr(getLocation(), C, argumentKind, argumentIdx, typeTagIdx, isPointer, getSpellingListIndex());
     880           0 :   A->Inherited = Inherited;
     881           0 :   A->IsPackExpansion = IsPackExpansion;
     882           0 :   A->Implicit = Implicit;
     883           0 :   return A;
     884             : }
     885             : 
     886           0 : void ArgumentWithTypeTagAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
     887           0 :   switch (SpellingListIndex) {
     888           0 :   default:
     889           0 :     llvm_unreachable("Unknown attribute spelling!");
     890             :     break;
     891           0 :   case 0 : {
     892           0 :     OS << " __attribute__((argument_with_type_tag(";
     893           0 :     OS << getArgumentKind()->getName();
     894           0 :     OS << ", " << getArgumentIdx() << ", " << getTypeTagIdx() << ", " << getIsPointer() << ")))";
     895           0 :     break;
     896             :   }
     897           0 :   case 1 : {
     898           0 :     OS << " __attribute__((pointer_with_type_tag(";
     899           0 :     OS << getArgumentKind()->getName();
     900           0 :     OS << ", " << getArgumentIdx() << ", " << getTypeTagIdx() << ", " << getIsPointer() << ")))";
     901           0 :     break;
     902             :   }
     903             : }
     904           0 : }
     905             : 
     906           3 : const char *ArgumentWithTypeTagAttr::getSpelling() const {
     907           3 :   switch (SpellingListIndex) {
     908           0 :   default:
     909           0 :     llvm_unreachable("Unknown attribute spelling!");
     910             :     return "(No spelling)";
     911             :   case 0:
     912             :     return "argument_with_type_tag";
     913           3 :   case 1:
     914           3 :     return "pointer_with_type_tag";
     915             :   }
     916             : }
     917             : 
     918          14 : AsmLabelAttr *AsmLabelAttr::clone(ASTContext &C) const {
     919          84 :   auto *A = new (C) AsmLabelAttr(getLocation(), C, getLabel(), getSpellingListIndex());
     920          14 :   A->Inherited = Inherited;
     921          14 :   A->IsPackExpansion = IsPackExpansion;
     922          14 :   A->Implicit = Implicit;
     923          14 :   return A;
     924             : }
     925             : 
     926           0 : void AsmLabelAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
     927           0 :   switch (SpellingListIndex) {
     928           0 :   default:
     929           0 :     llvm_unreachable("Unknown attribute spelling!");
     930             :     break;
     931           0 :   case 0 : {
     932           0 :     OS << " asm(\"" << getLabel() << "\")";
     933           0 :     break;
     934             :   }
     935           0 :   case 1 : {
     936           0 :     OS << " __asm__(\"" << getLabel() << "\")";
     937           0 :     break;
     938             :   }
     939             : }
     940           0 : }
     941             : 
     942           0 : const char *AsmLabelAttr::getSpelling() const {
     943           0 :   switch (SpellingListIndex) {
     944           0 :   default:
     945           0 :     llvm_unreachable("Unknown attribute spelling!");
     946             :     return "(No spelling)";
     947             :   case 0:
     948             :     return "asm";
     949           0 :   case 1:
     950           0 :     return "__asm__";
     951             :   }
     952             : }
     953             : 
     954           6 : AssertCapabilityAttr *AssertCapabilityAttr::clone(ASTContext &C) const {
     955          30 :   auto *A = new (C) AssertCapabilityAttr(getLocation(), C, args_, args_Size, getSpellingListIndex());
     956           6 :   A->Inherited = Inherited;
     957           6 :   A->IsPackExpansion = IsPackExpansion;
     958           6 :   A->Implicit = Implicit;
     959           6 :   return A;
     960             : }
     961             : 
     962           0 : void AssertCapabilityAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
     963           0 :   switch (SpellingListIndex) {
     964           0 :   default:
     965           0 :     llvm_unreachable("Unknown attribute spelling!");
     966             :     break;
     967           0 :   case 0 : {
     968           0 :     OS << " __attribute__((assert_capability(";
     969           0 :   bool isFirst = true;
     970           0 :   for (const auto &Val : args()) {
     971           0 :     if (isFirst) isFirst = false;
     972           0 :     else OS << ", ";
     973           0 :     OS << Val;
     974             :   }
     975           0 :   OS << ")))";
     976           0 :     break;
     977             :   }
     978           0 :   case 1 : {
     979           0 :     OS << " [[clang::assert_capability(";
     980           0 :   bool isFirst = true;
     981           0 :   for (const auto &Val : args()) {
     982           0 :     if (isFirst) isFirst = false;
     983           0 :     else OS << ", ";
     984           0 :     OS << Val;
     985             :   }
     986           0 :   OS << ")]]";
     987           0 :     break;
     988             :   }
     989           0 :   case 2 : {
     990           0 :     OS << " __attribute__((assert_shared_capability(";
     991           0 :   bool isFirst = true;
     992           0 :   for (const auto &Val : args()) {
     993           0 :     if (isFirst) isFirst = false;
     994           0 :     else OS << ", ";
     995           0 :     OS << Val;
     996             :   }
     997           0 :   OS << ")))";
     998           0 :     break;
     999             :   }
    1000           0 :   case 3 : {
    1001           0 :     OS << " [[clang::assert_shared_capability(";
    1002           0 :   bool isFirst = true;
    1003           0 :   for (const auto &Val : args()) {
    1004           0 :     if (isFirst) isFirst = false;
    1005           0 :     else OS << ", ";
    1006           0 :     OS << Val;
    1007             :   }
    1008           0 :   OS << ")]]";
    1009           0 :     break;
    1010             :   }
    1011             : }
    1012           0 : }
    1013             : 
    1014           0 : const char *AssertCapabilityAttr::getSpelling() const {
    1015           0 :   switch (SpellingListIndex) {
    1016           0 :   default:
    1017           0 :     llvm_unreachable("Unknown attribute spelling!");
    1018             :     return "(No spelling)";
    1019             :   case 0:
    1020             :     return "assert_capability";
    1021             :   case 1:
    1022             :     return "assert_capability";
    1023           0 :   case 2:
    1024           0 :     return "assert_shared_capability";
    1025           0 :   case 3:
    1026           0 :     return "assert_shared_capability";
    1027             :   }
    1028             : }
    1029             : 
    1030           3 : AssertExclusiveLockAttr *AssertExclusiveLockAttr::clone(ASTContext &C) const {
    1031          15 :   auto *A = new (C) AssertExclusiveLockAttr(getLocation(), C, args_, args_Size, getSpellingListIndex());
    1032           3 :   A->Inherited = Inherited;
    1033           3 :   A->IsPackExpansion = IsPackExpansion;
    1034           3 :   A->Implicit = Implicit;
    1035           3 :   return A;
    1036             : }
    1037             : 
    1038           0 : void AssertExclusiveLockAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    1039           0 :   switch (SpellingListIndex) {
    1040           0 :   default:
    1041           0 :     llvm_unreachable("Unknown attribute spelling!");
    1042             :     break;
    1043           0 :   case 0 : {
    1044           0 :     OS << " __attribute__((assert_exclusive_lock(";
    1045           0 :   bool isFirst = true;
    1046           0 :   for (const auto &Val : args()) {
    1047           0 :     if (isFirst) isFirst = false;
    1048           0 :     else OS << ", ";
    1049           0 :     OS << Val;
    1050             :   }
    1051           0 :   OS << ")))";
    1052             :     break;
    1053             :   }
    1054             : }
    1055           0 : }
    1056             : 
    1057           0 : const char *AssertExclusiveLockAttr::getSpelling() const {
    1058           0 :   switch (SpellingListIndex) {
    1059           0 :   default:
    1060           0 :     llvm_unreachable("Unknown attribute spelling!");
    1061             :     return "(No spelling)";
    1062           0 :   case 0:
    1063             :     return "assert_exclusive_lock";
    1064             :   }
    1065             : }
    1066             : 
    1067           3 : AssertSharedLockAttr *AssertSharedLockAttr::clone(ASTContext &C) const {
    1068          15 :   auto *A = new (C) AssertSharedLockAttr(getLocation(), C, args_, args_Size, getSpellingListIndex());
    1069           3 :   A->Inherited = Inherited;
    1070           3 :   A->IsPackExpansion = IsPackExpansion;
    1071           3 :   A->Implicit = Implicit;
    1072           3 :   return A;
    1073             : }
    1074             : 
    1075           0 : void AssertSharedLockAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    1076           0 :   switch (SpellingListIndex) {
    1077           0 :   default:
    1078           0 :     llvm_unreachable("Unknown attribute spelling!");
    1079             :     break;
    1080           0 :   case 0 : {
    1081           0 :     OS << " __attribute__((assert_shared_lock(";
    1082           0 :   bool isFirst = true;
    1083           0 :   for (const auto &Val : args()) {
    1084           0 :     if (isFirst) isFirst = false;
    1085           0 :     else OS << ", ";
    1086           0 :     OS << Val;
    1087             :   }
    1088           0 :   OS << ")))";
    1089             :     break;
    1090             :   }
    1091             : }
    1092           0 : }
    1093             : 
    1094           0 : const char *AssertSharedLockAttr::getSpelling() const {
    1095           0 :   switch (SpellingListIndex) {
    1096           0 :   default:
    1097           0 :     llvm_unreachable("Unknown attribute spelling!");
    1098             :     return "(No spelling)";
    1099           0 :   case 0:
    1100             :     return "assert_shared_lock";
    1101             :   }
    1102             : }
    1103             : 
    1104           4 : AssumeAlignedAttr *AssumeAlignedAttr::clone(ASTContext &C) const {
    1105          20 :   auto *A = new (C) AssumeAlignedAttr(getLocation(), C, alignment, offset, getSpellingListIndex());
    1106           4 :   A->Inherited = Inherited;
    1107           4 :   A->IsPackExpansion = IsPackExpansion;
    1108           4 :   A->Implicit = Implicit;
    1109           4 :   return A;
    1110             : }
    1111             : 
    1112           0 : void AssumeAlignedAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    1113           0 :   switch (SpellingListIndex) {
    1114           0 :   default:
    1115           0 :     llvm_unreachable("Unknown attribute spelling!");
    1116             :     break;
    1117           0 :   case 0 : {
    1118           0 :     OS << " __attribute__((assume_aligned(" << getAlignment() << ", " << getOffset() << ")))";
    1119           0 :     break;
    1120             :   }
    1121           0 :   case 1 : {
    1122           0 :     OS << " [[gnu::assume_aligned(" << getAlignment() << ", " << getOffset() << ")]]";
    1123           0 :     break;
    1124             :   }
    1125             : }
    1126           0 : }
    1127             : 
    1128           3 : const char *AssumeAlignedAttr::getSpelling() const {
    1129           3 :   switch (SpellingListIndex) {
    1130           0 :   default:
    1131           0 :     llvm_unreachable("Unknown attribute spelling!");
    1132             :     return "(No spelling)";
    1133             :   case 0:
    1134             :     return "assume_aligned";
    1135             :   case 1:
    1136             :     return "assume_aligned";
    1137             :   }
    1138             : }
    1139             : 
    1140         112 : AvailabilityAttr *AvailabilityAttr::clone(ASTContext &C) const {
    1141        1120 :   auto *A = new (C) AvailabilityAttr(getLocation(), C, platform, getIntroduced(), getDeprecated(), getObsoleted(), unavailable, getMessage(), strict, getReplacement(), getSpellingListIndex());
    1142         112 :   A->Inherited = Inherited;
    1143         112 :   A->IsPackExpansion = IsPackExpansion;
    1144         112 :   A->Implicit = Implicit;
    1145         112 :   return A;
    1146             : }
    1147             : 
    1148           6 : void AvailabilityAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    1149           6 :   switch (SpellingListIndex) {
    1150           0 :   default:
    1151           0 :     llvm_unreachable("Unknown attribute spelling!");
    1152             :     break;
    1153           6 :   case 0 : {
    1154          12 :     OS << " __attribute__((availability(" << getPlatform()->getName();
    1155           6 :   if (getStrict()) OS << ", strict";
    1156          18 :   if (!getIntroduced().empty()) OS << ", introduced=" << getIntroduced();
    1157          22 :   if (!getDeprecated().empty()) OS << ", deprecated=" << getDeprecated();
    1158          12 :   if (!getObsoleted().empty()) OS << ", obsoleted=" << getObsoleted();
    1159           6 :   if (getUnavailable()) OS << ", unavailable";
    1160           6 :   OS << ")))";
    1161             :     break;
    1162             :   }
    1163             : }
    1164           6 : }
    1165             : 
    1166           0 : const char *AvailabilityAttr::getSpelling() const {
    1167           0 :   switch (SpellingListIndex) {
    1168           0 :   default:
    1169           0 :     llvm_unreachable("Unknown attribute spelling!");
    1170             :     return "(No spelling)";
    1171           0 :   case 0:
    1172             :     return "availability";
    1173             :   }
    1174             : }
    1175             : 
    1176           3 : BlocksAttr *BlocksAttr::clone(ASTContext &C) const {
    1177          15 :   auto *A = new (C) BlocksAttr(getLocation(), C, type, getSpellingListIndex());
    1178           3 :   A->Inherited = Inherited;
    1179           3 :   A->IsPackExpansion = IsPackExpansion;
    1180           3 :   A->Implicit = Implicit;
    1181           3 :   return A;
    1182             : }
    1183             : 
    1184           1 : void BlocksAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    1185           1 :   switch (SpellingListIndex) {
    1186           0 :   default:
    1187           0 :     llvm_unreachable("Unknown attribute spelling!");
    1188             :     break;
    1189           1 :   case 0 : {
    1190           2 :     OS << " __attribute__((blocks(\"" << BlocksAttr::ConvertBlockTypeToStr(getType()) << "\")))";
    1191             :     break;
    1192             :   }
    1193             : }
    1194           1 : }
    1195             : 
    1196           0 : const char *BlocksAttr::getSpelling() const {
    1197           0 :   switch (SpellingListIndex) {
    1198           0 :   default:
    1199           0 :     llvm_unreachable("Unknown attribute spelling!");
    1200             :     return "(No spelling)";
    1201           0 :   case 0:
    1202             :     return "blocks";
    1203             :   }
    1204             : }
    1205             : 
    1206           7 : C11NoReturnAttr *C11NoReturnAttr::clone(ASTContext &C) const {
    1207          35 :   auto *A = new (C) C11NoReturnAttr(getLocation(), C, getSpellingListIndex());
    1208           7 :   A->Inherited = Inherited;
    1209           7 :   A->IsPackExpansion = IsPackExpansion;
    1210           7 :   A->Implicit = Implicit;
    1211           7 :   return A;
    1212             : }
    1213             : 
    1214           0 : void C11NoReturnAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    1215           0 :   switch (SpellingListIndex) {
    1216           0 :   default:
    1217           0 :     llvm_unreachable("Unknown attribute spelling!");
    1218             :     break;
    1219           0 :   case 0 : {
    1220           0 :     OS << " _Noreturn";
    1221             :     break;
    1222             :   }
    1223             : }
    1224           0 : }
    1225             : 
    1226           0 : const char *C11NoReturnAttr::getSpelling() const {
    1227           0 :   switch (SpellingListIndex) {
    1228           0 :   default:
    1229           0 :     llvm_unreachable("Unknown attribute spelling!");
    1230             :     return "(No spelling)";
    1231           0 :   case 0:
    1232             :     return "_Noreturn";
    1233             :   }
    1234             : }
    1235             : 
    1236           0 : CDeclAttr *CDeclAttr::clone(ASTContext &C) const {
    1237           0 :   auto *A = new (C) CDeclAttr(getLocation(), C, getSpellingListIndex());
    1238           0 :   A->Inherited = Inherited;
    1239           0 :   A->IsPackExpansion = IsPackExpansion;
    1240           0 :   A->Implicit = Implicit;
    1241           0 :   return A;
    1242             : }
    1243             : 
    1244           0 : void CDeclAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    1245           0 :   switch (SpellingListIndex) {
    1246           0 :   default:
    1247           0 :     llvm_unreachable("Unknown attribute spelling!");
    1248             :     break;
    1249           0 :   case 0 : {
    1250           0 :     OS << " __attribute__((cdecl))";
    1251           0 :     break;
    1252             :   }
    1253           0 :   case 1 : {
    1254           0 :     OS << " [[gnu::cdecl]]";
    1255           0 :     break;
    1256             :   }
    1257           0 :   case 2 : {
    1258           0 :     OS << " __cdecl";
    1259           0 :     break;
    1260             :   }
    1261           0 :   case 3 : {
    1262           0 :     OS << " _cdecl";
    1263           0 :     break;
    1264             :   }
    1265             : }
    1266           0 : }
    1267             : 
    1268           0 : const char *CDeclAttr::getSpelling() const {
    1269           0 :   switch (SpellingListIndex) {
    1270           0 :   default:
    1271           0 :     llvm_unreachable("Unknown attribute spelling!");
    1272             :     return "(No spelling)";
    1273             :   case 0:
    1274             :     return "cdecl";
    1275             :   case 1:
    1276             :     return "cdecl";
    1277           0 :   case 2:
    1278           0 :     return "__cdecl";
    1279           0 :   case 3:
    1280           0 :     return "_cdecl";
    1281             :   }
    1282             : }
    1283             : 
    1284           0 : CFAuditedTransferAttr *CFAuditedTransferAttr::clone(ASTContext &C) const {
    1285           0 :   auto *A = new (C) CFAuditedTransferAttr(getLocation(), C, getSpellingListIndex());
    1286           0 :   A->Inherited = Inherited;
    1287           0 :   A->IsPackExpansion = IsPackExpansion;
    1288           0 :   A->Implicit = Implicit;
    1289           0 :   return A;
    1290             : }
    1291             : 
    1292           0 : void CFAuditedTransferAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    1293           0 :   switch (SpellingListIndex) {
    1294           0 :   default:
    1295           0 :     llvm_unreachable("Unknown attribute spelling!");
    1296             :     break;
    1297           0 :   case 0 : {
    1298           0 :     OS << " __attribute__((cf_audited_transfer))";
    1299             :     break;
    1300             :   }
    1301             : }
    1302           0 : }
    1303             : 
    1304           0 : const char *CFAuditedTransferAttr::getSpelling() const {
    1305           0 :   switch (SpellingListIndex) {
    1306           0 :   default:
    1307           0 :     llvm_unreachable("Unknown attribute spelling!");
    1308             :     return "(No spelling)";
    1309           0 :   case 0:
    1310             :     return "cf_audited_transfer";
    1311             :   }
    1312             : }
    1313             : 
    1314           5 : CFConsumedAttr *CFConsumedAttr::clone(ASTContext &C) const {
    1315          25 :   auto *A = new (C) CFConsumedAttr(getLocation(), C, getSpellingListIndex());
    1316           5 :   A->Inherited = Inherited;
    1317           5 :   A->IsPackExpansion = IsPackExpansion;
    1318           5 :   A->Implicit = Implicit;
    1319           5 :   return A;
    1320             : }
    1321             : 
    1322           0 : void CFConsumedAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    1323           0 :   switch (SpellingListIndex) {
    1324           0 :   default:
    1325           0 :     llvm_unreachable("Unknown attribute spelling!");
    1326             :     break;
    1327           0 :   case 0 : {
    1328           0 :     OS << " __attribute__((cf_consumed))";
    1329             :     break;
    1330             :   }
    1331             : }
    1332           0 : }
    1333             : 
    1334           0 : const char *CFConsumedAttr::getSpelling() const {
    1335           0 :   switch (SpellingListIndex) {
    1336           0 :   default:
    1337           0 :     llvm_unreachable("Unknown attribute spelling!");
    1338             :     return "(No spelling)";
    1339           0 :   case 0:
    1340             :     return "cf_consumed";
    1341             :   }
    1342             : }
    1343             : 
    1344           5 : CFReturnsNotRetainedAttr *CFReturnsNotRetainedAttr::clone(ASTContext &C) const {
    1345          25 :   auto *A = new (C) CFReturnsNotRetainedAttr(getLocation(), C, getSpellingListIndex());
    1346           5 :   A->Inherited = Inherited;
    1347           5 :   A->IsPackExpansion = IsPackExpansion;
    1348           5 :   A->Implicit = Implicit;
    1349           5 :   return A;
    1350             : }
    1351             : 
    1352           0 : void CFReturnsNotRetainedAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    1353           0 :   switch (SpellingListIndex) {
    1354           0 :   default:
    1355           0 :     llvm_unreachable("Unknown attribute spelling!");
    1356             :     break;
    1357           0 :   case 0 : {
    1358           0 :     OS << " __attribute__((cf_returns_not_retained))";
    1359             :     break;
    1360             :   }
    1361             : }
    1362           0 : }
    1363             : 
    1364           0 : const char *CFReturnsNotRetainedAttr::getSpelling() const {
    1365           0 :   switch (SpellingListIndex) {
    1366           0 :   default:
    1367           0 :     llvm_unreachable("Unknown attribute spelling!");
    1368             :     return "(No spelling)";
    1369           0 :   case 0:
    1370             :     return "cf_returns_not_retained";
    1371             :   }
    1372             : }
    1373             : 
    1374          16 : CFReturnsRetainedAttr *CFReturnsRetainedAttr::clone(ASTContext &C) const {
    1375          80 :   auto *A = new (C) CFReturnsRetainedAttr(getLocation(), C, getSpellingListIndex());
    1376          16 :   A->Inherited = Inherited;
    1377          16 :   A->IsPackExpansion = IsPackExpansion;
    1378          16 :   A->Implicit = Implicit;
    1379          16 :   return A;
    1380             : }
    1381             : 
    1382           0 : void CFReturnsRetainedAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    1383           0 :   switch (SpellingListIndex) {
    1384           0 :   default:
    1385           0 :     llvm_unreachable("Unknown attribute spelling!");
    1386             :     break;
    1387           0 :   case 0 : {
    1388           0 :     OS << " __attribute__((cf_returns_retained))";
    1389             :     break;
    1390             :   }
    1391             : }
    1392           0 : }
    1393             : 
    1394           0 : const char *CFReturnsRetainedAttr::getSpelling() const {
    1395           0 :   switch (SpellingListIndex) {
    1396           0 :   default:
    1397           0 :     llvm_unreachable("Unknown attribute spelling!");
    1398             :     return "(No spelling)";
    1399           0 :   case 0:
    1400             :     return "cf_returns_retained";
    1401             :   }
    1402             : }
    1403             : 
    1404           0 : CFUnknownTransferAttr *CFUnknownTransferAttr::clone(ASTContext &C) const {
    1405           0 :   auto *A = new (C) CFUnknownTransferAttr(getLocation(), C, getSpellingListIndex());
    1406           0 :   A->Inherited = Inherited;
    1407           0 :   A->IsPackExpansion = IsPackExpansion;
    1408           0 :   A->Implicit = Implicit;
    1409           0 :   return A;
    1410             : }
    1411             : 
    1412           0 : void CFUnknownTransferAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    1413           0 :   switch (SpellingListIndex) {
    1414           0 :   default:
    1415           0 :     llvm_unreachable("Unknown attribute spelling!");
    1416             :     break;
    1417           0 :   case 0 : {
    1418           0 :     OS << " __attribute__((cf_unknown_transfer))";
    1419             :     break;
    1420             :   }
    1421             : }
    1422           0 : }
    1423             : 
    1424           0 : const char *CFUnknownTransferAttr::getSpelling() const {
    1425           0 :   switch (SpellingListIndex) {
    1426           0 :   default:
    1427           0 :     llvm_unreachable("Unknown attribute spelling!");
    1428             :     return "(No spelling)";
    1429           0 :   case 0:
    1430             :     return "cf_unknown_transfer";
    1431             :   }
    1432             : }
    1433             : 
    1434           0 : CUDAConstantAttr *CUDAConstantAttr::clone(ASTContext &C) const {
    1435           0 :   auto *A = new (C) CUDAConstantAttr(getLocation(), C, getSpellingListIndex());
    1436           0 :   A->Inherited = Inherited;
    1437           0 :   A->IsPackExpansion = IsPackExpansion;
    1438           0 :   A->Implicit = Implicit;
    1439           0 :   return A;
    1440             : }
    1441             : 
    1442           0 : void CUDAConstantAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    1443           0 :   switch (SpellingListIndex) {
    1444           0 :   default:
    1445           0 :     llvm_unreachable("Unknown attribute spelling!");
    1446             :     break;
    1447           0 :   case 0 : {
    1448           0 :     OS << " __attribute__((constant))";
    1449           0 :     break;
    1450             :   }
    1451           0 :   case 1 : {
    1452           0 :     OS << " __declspec(__constant__)";
    1453           0 :     break;
    1454             :   }
    1455             : }
    1456           0 : }
    1457             : 
    1458           2 : const char *CUDAConstantAttr::getSpelling() const {
    1459           2 :   switch (SpellingListIndex) {
    1460           0 :   default:
    1461           0 :     llvm_unreachable("Unknown attribute spelling!");
    1462             :     return "(No spelling)";
    1463             :   case 0:
    1464             :     return "constant";
    1465           0 :   case 1:
    1466           0 :     return "__constant__";
    1467             :   }
    1468             : }
    1469             : 
    1470          54 : CUDADeviceAttr *CUDADeviceAttr::clone(ASTContext &C) const {
    1471         270 :   auto *A = new (C) CUDADeviceAttr(getLocation(), C, getSpellingListIndex());
    1472          54 :   A->Inherited = Inherited;
    1473          54 :   A->IsPackExpansion = IsPackExpansion;
    1474          54 :   A->Implicit = Implicit;
    1475          54 :   return A;
    1476             : }
    1477             : 
    1478           0 : void CUDADeviceAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    1479           0 :   switch (SpellingListIndex) {
    1480           0 :   default:
    1481           0 :     llvm_unreachable("Unknown attribute spelling!");
    1482             :     break;
    1483           0 :   case 0 : {
    1484           0 :     OS << " __attribute__((device))";
    1485           0 :     break;
    1486             :   }
    1487           0 :   case 1 : {
    1488           0 :     OS << " __declspec(__device__)";
    1489           0 :     break;
    1490             :   }
    1491             : }
    1492           0 : }
    1493             : 
    1494           2 : const char *CUDADeviceAttr::getSpelling() const {
    1495           2 :   switch (SpellingListIndex) {
    1496           0 :   default:
    1497           0 :     llvm_unreachable("Unknown attribute spelling!");
    1498             :     return "(No spelling)";
    1499             :   case 0:
    1500             :     return "device";
    1501           0 :   case 1:
    1502           0 :     return "__device__";
    1503             :   }
    1504             : }
    1505             : 
    1506           4 : CUDAGlobalAttr *CUDAGlobalAttr::clone(ASTContext &C) const {
    1507          20 :   auto *A = new (C) CUDAGlobalAttr(getLocation(), C, getSpellingListIndex());
    1508           4 :   A->Inherited = Inherited;
    1509           4 :   A->IsPackExpansion = IsPackExpansion;
    1510           4 :   A->Implicit = Implicit;
    1511           4 :   return A;
    1512             : }
    1513             : 
    1514           0 : void CUDAGlobalAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    1515           0 :   switch (SpellingListIndex) {
    1516           0 :   default:
    1517           0 :     llvm_unreachable("Unknown attribute spelling!");
    1518             :     break;
    1519           0 :   case 0 : {
    1520           0 :     OS << " __attribute__((global))";
    1521           0 :     break;
    1522             :   }
    1523           0 :   case 1 : {
    1524           0 :     OS << " __declspec(__global__)";
    1525           0 :     break;
    1526             :   }
    1527             : }
    1528           0 : }
    1529             : 
    1530           4 : const char *CUDAGlobalAttr::getSpelling() const {
    1531           4 :   switch (SpellingListIndex) {
    1532           0 :   default:
    1533           0 :     llvm_unreachable("Unknown attribute spelling!");
    1534             :     return "(No spelling)";
    1535             :   case 0:
    1536             :     return "global";
    1537           0 :   case 1:
    1538           0 :     return "__global__";
    1539             :   }
    1540             : }
    1541             : 
    1542          41 : CUDAHostAttr *CUDAHostAttr::clone(ASTContext &C) const {
    1543         205 :   auto *A = new (C) CUDAHostAttr(getLocation(), C, getSpellingListIndex());
    1544          41 :   A->Inherited = Inherited;
    1545          41 :   A->IsPackExpansion = IsPackExpansion;
    1546          41 :   A->Implicit = Implicit;
    1547          41 :   return A;
    1548             : }
    1549             : 
    1550           0 : void CUDAHostAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    1551           0 :   switch (SpellingListIndex) {
    1552           0 :   default:
    1553           0 :     llvm_unreachable("Unknown attribute spelling!");
    1554             :     break;
    1555           0 :   case 0 : {
    1556           0 :     OS << " __attribute__((host))";
    1557           0 :     break;
    1558             :   }
    1559           0 :   case 1 : {
    1560           0 :     OS << " __declspec(__host__)";
    1561           0 :     break;
    1562             :   }
    1563             : }
    1564           0 : }
    1565             : 
    1566           2 : const char *CUDAHostAttr::getSpelling() const {
    1567           2 :   switch (SpellingListIndex) {
    1568           0 :   default:
    1569           0 :     llvm_unreachable("Unknown attribute spelling!");
    1570             :     return "(No spelling)";
    1571             :   case 0:
    1572             :     return "host";
    1573           0 :   case 1:
    1574           0 :     return "__host__";
    1575             :   }
    1576             : }
    1577             : 
    1578           0 : CUDAInvalidTargetAttr *CUDAInvalidTargetAttr::clone(ASTContext &C) const {
    1579           0 :   auto *A = new (C) CUDAInvalidTargetAttr(getLocation(), C, getSpellingListIndex());
    1580           0 :   A->Inherited = Inherited;
    1581           0 :   A->IsPackExpansion = IsPackExpansion;
    1582           0 :   A->Implicit = Implicit;
    1583           0 :   return A;
    1584             : }
    1585             : 
    1586           0 : void CUDAInvalidTargetAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    1587           0 : }
    1588             : 
    1589           0 : const char *CUDAInvalidTargetAttr::getSpelling() const {
    1590           0 :   return "(No spelling)";
    1591             : }
    1592             : 
    1593           0 : CUDALaunchBoundsAttr *CUDALaunchBoundsAttr::clone(ASTContext &C) const {
    1594           0 :   auto *A = new (C) CUDALaunchBoundsAttr(getLocation(), C, maxThreads, minBlocks, getSpellingListIndex());
    1595           0 :   A->Inherited = Inherited;
    1596           0 :   A->IsPackExpansion = IsPackExpansion;
    1597           0 :   A->Implicit = Implicit;
    1598           0 :   return A;
    1599             : }
    1600             : 
    1601           0 : void CUDALaunchBoundsAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    1602           0 :   switch (SpellingListIndex) {
    1603           0 :   default:
    1604           0 :     llvm_unreachable("Unknown attribute spelling!");
    1605             :     break;
    1606           0 :   case 0 : {
    1607           0 :     OS << " __attribute__((launch_bounds(" << getMaxThreads() << ", " << getMinBlocks() << ")))";
    1608           0 :     break;
    1609             :   }
    1610           0 :   case 1 : {
    1611           0 :     OS << " __declspec(__launch_bounds__(" << getMaxThreads() << ", " << getMinBlocks() << "))";
    1612           0 :     break;
    1613             :   }
    1614             : }
    1615           0 : }
    1616             : 
    1617           7 : const char *CUDALaunchBoundsAttr::getSpelling() const {
    1618           7 :   switch (SpellingListIndex) {
    1619           0 :   default:
    1620           0 :     llvm_unreachable("Unknown attribute spelling!");
    1621             :     return "(No spelling)";
    1622             :   case 0:
    1623             :     return "launch_bounds";
    1624           0 :   case 1:
    1625           0 :     return "__launch_bounds__";
    1626             :   }
    1627             : }
    1628             : 
    1629           0 : CUDASharedAttr *CUDASharedAttr::clone(ASTContext &C) const {
    1630           0 :   auto *A = new (C) CUDASharedAttr(getLocation(), C, getSpellingListIndex());
    1631           0 :   A->Inherited = Inherited;
    1632           0 :   A->IsPackExpansion = IsPackExpansion;
    1633           0 :   A->Implicit = Implicit;
    1634           0 :   return A;
    1635             : }
    1636             : 
    1637           0 : void CUDASharedAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    1638           0 :   switch (SpellingListIndex) {
    1639           0 :   default:
    1640           0 :     llvm_unreachable("Unknown attribute spelling!");
    1641             :     break;
    1642           0 :   case 0 : {
    1643           0 :     OS << " __attribute__((shared))";
    1644           0 :     break;
    1645             :   }
    1646           0 :   case 1 : {
    1647           0 :     OS << " __declspec(__shared__)";
    1648           0 :     break;
    1649             :   }
    1650             : }
    1651           0 : }
    1652             : 
    1653           4 : const char *CUDASharedAttr::getSpelling() const {
    1654           4 :   switch (SpellingListIndex) {
    1655           0 :   default:
    1656           0 :     llvm_unreachable("Unknown attribute spelling!");
    1657             :     return "(No spelling)";
    1658             :   case 0:
    1659             :     return "shared";
    1660           0 :   case 1:
    1661           0 :     return "__shared__";
    1662             :   }
    1663             : }
    1664             : 
    1665           4 : CXX11NoReturnAttr *CXX11NoReturnAttr::clone(ASTContext &C) const {
    1666          20 :   auto *A = new (C) CXX11NoReturnAttr(getLocation(), C, getSpellingListIndex());
    1667           4 :   A->Inherited = Inherited;
    1668           4 :   A->IsPackExpansion = IsPackExpansion;
    1669           4 :   A->Implicit = Implicit;
    1670           4 :   return A;
    1671             : }
    1672             : 
    1673           1 : void CXX11NoReturnAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    1674           1 :   switch (SpellingListIndex) {
    1675           0 :   default:
    1676           0 :     llvm_unreachable("Unknown attribute spelling!");
    1677             :     break;
    1678           1 :   case 0 : {
    1679           1 :     OS << " [[noreturn]]";
    1680             :     break;
    1681             :   }
    1682             : }
    1683           1 : }
    1684             : 
    1685           0 : const char *CXX11NoReturnAttr::getSpelling() const {
    1686           0 :   switch (SpellingListIndex) {
    1687           0 :   default:
    1688           0 :     llvm_unreachable("Unknown attribute spelling!");
    1689             :     return "(No spelling)";
    1690           0 :   case 0:
    1691             :     return "noreturn";
    1692             :   }
    1693             : }
    1694             : 
    1695           6 : CallableWhenAttr *CallableWhenAttr::clone(ASTContext &C) const {
    1696          30 :   auto *A = new (C) CallableWhenAttr(getLocation(), C, callableStates_, callableStates_Size, getSpellingListIndex());
    1697           6 :   A->Inherited = Inherited;
    1698           6 :   A->IsPackExpansion = IsPackExpansion;
    1699           6 :   A->Implicit = Implicit;
    1700           6 :   return A;
    1701             : }
    1702             : 
    1703           1 : void CallableWhenAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    1704           1 :   switch (SpellingListIndex) {
    1705           0 :   default:
    1706           0 :     llvm_unreachable("Unknown attribute spelling!");
    1707             :     break;
    1708           1 :   case 0 : {
    1709           1 :     OS << " __attribute__((callable_when(";
    1710           1 :   bool isFirst = true;
    1711           3 :   for (const auto &Val : callableStates()) {
    1712           2 :     if (isFirst) isFirst = false;
    1713           1 :     else OS << ", ";
    1714           4 :     OS << "\"" << CallableWhenAttr::ConvertConsumedStateToStr(Val)<< "\"";
    1715             :   }
    1716           1 :   OS << ")))";
    1717             :     break;
    1718             :   }
    1719             : }
    1720           1 : }
    1721             : 
    1722           0 : const char *CallableWhenAttr::getSpelling() const {
    1723           0 :   switch (SpellingListIndex) {
    1724           0 :   default:
    1725           0 :     llvm_unreachable("Unknown attribute spelling!");
    1726             :     return "(No spelling)";
    1727           0 :   case 0:
    1728             :     return "callable_when";
    1729             :   }
    1730             : }
    1731             : 
    1732           0 : CapabilityAttr *CapabilityAttr::clone(ASTContext &C) const {
    1733           0 :   auto *A = new (C) CapabilityAttr(getLocation(), C, getName(), getSpellingListIndex());
    1734           0 :   A->Inherited = Inherited;
    1735           0 :   A->IsPackExpansion = IsPackExpansion;
    1736           0 :   A->Implicit = Implicit;
    1737           0 :   return A;
    1738             : }
    1739             : 
    1740           0 : void CapabilityAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    1741           0 :   switch (SpellingListIndex) {
    1742           0 :   default:
    1743           0 :     llvm_unreachable("Unknown attribute spelling!");
    1744             :     break;
    1745           0 :   case 0 : {
    1746           0 :     OS << " __attribute__((capability(\"" << getName() << "\")))";
    1747           0 :     break;
    1748             :   }
    1749           0 :   case 1 : {
    1750           0 :     OS << " [[clang::capability(\"" << getName() << "\")]]";
    1751           0 :     break;
    1752             :   }
    1753           0 :   case 2 : {
    1754           0 :     OS << " __attribute__((shared_capability(\"" << getName() << "\")))";
    1755           0 :     break;
    1756             :   }
    1757           0 :   case 3 : {
    1758           0 :     OS << " [[clang::shared_capability(\"" << getName() << "\")]]";
    1759           0 :     break;
    1760             :   }
    1761             : }
    1762           0 : }
    1763             : 
    1764           1 : const char *CapabilityAttr::getSpelling() const {
    1765           1 :   switch (SpellingListIndex) {
    1766           0 :   default:
    1767           0 :     llvm_unreachable("Unknown attribute spelling!");
    1768             :     return "(No spelling)";
    1769             :   case 0:
    1770             :     return "capability";
    1771             :   case 1:
    1772             :     return "capability";
    1773           0 :   case 2:
    1774           0 :     return "shared_capability";
    1775           0 :   case 3:
    1776           0 :     return "shared_capability";
    1777             :   }
    1778             : }
    1779             : 
    1780           0 : CapturedRecordAttr *CapturedRecordAttr::clone(ASTContext &C) const {
    1781           0 :   auto *A = new (C) CapturedRecordAttr(getLocation(), C, getSpellingListIndex());
    1782           0 :   A->Inherited = Inherited;
    1783           0 :   A->IsPackExpansion = IsPackExpansion;
    1784           0 :   A->Implicit = Implicit;
    1785           0 :   return A;
    1786             : }
    1787             : 
    1788           0 : void CapturedRecordAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    1789           0 : }
    1790             : 
    1791           0 : const char *CapturedRecordAttr::getSpelling() const {
    1792           0 :   return "(No spelling)";
    1793             : }
    1794             : 
    1795           5 : CarriesDependencyAttr *CarriesDependencyAttr::clone(ASTContext &C) const {
    1796          25 :   auto *A = new (C) CarriesDependencyAttr(getLocation(), C, getSpellingListIndex());
    1797           5 :   A->Inherited = Inherited;
    1798           5 :   A->IsPackExpansion = IsPackExpansion;
    1799           5 :   A->Implicit = Implicit;
    1800           5 :   return A;
    1801             : }
    1802             : 
    1803           0 : void CarriesDependencyAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    1804           0 :   switch (SpellingListIndex) {
    1805           0 :   default:
    1806           0 :     llvm_unreachable("Unknown attribute spelling!");
    1807             :     break;
    1808           0 :   case 0 : {
    1809           0 :     OS << " __attribute__((carries_dependency))";
    1810           0 :     break;
    1811             :   }
    1812           0 :   case 1 : {
    1813           0 :     OS << " [[carries_dependency]]";
    1814           0 :     break;
    1815             :   }
    1816             : }
    1817           0 : }
    1818             : 
    1819           0 : const char *CarriesDependencyAttr::getSpelling() const {
    1820           0 :   switch (SpellingListIndex) {
    1821           0 :   default:
    1822           0 :     llvm_unreachable("Unknown attribute spelling!");
    1823             :     return "(No spelling)";
    1824             :   case 0:
    1825             :     return "carries_dependency";
    1826             :   case 1:
    1827             :     return "carries_dependency";
    1828             :   }
    1829             : }
    1830             : 
    1831           0 : CleanupAttr *CleanupAttr::clone(ASTContext &C) const {
    1832           0 :   auto *A = new (C) CleanupAttr(getLocation(), C, functionDecl, getSpellingListIndex());
    1833           0 :   A->Inherited = Inherited;
    1834           0 :   A->IsPackExpansion = IsPackExpansion;
    1835           0 :   A->Implicit = Implicit;
    1836           0 :   return A;
    1837             : }
    1838             : 
    1839           0 : void CleanupAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    1840           0 :   switch (SpellingListIndex) {
    1841           0 :   default:
    1842           0 :     llvm_unreachable("Unknown attribute spelling!");
    1843             :     break;
    1844           0 :   case 0 : {
    1845           0 :     OS << " __attribute__((cleanup(" << getFunctionDecl()->getNameInfo().getAsString() << ")))";
    1846           0 :     break;
    1847             :   }
    1848           0 :   case 1 : {
    1849           0 :     OS << " [[gnu::cleanup(" << getFunctionDecl()->getNameInfo().getAsString() << ")]]";
    1850           0 :     break;
    1851             :   }
    1852             : }
    1853           0 : }
    1854             : 
    1855           0 : const char *CleanupAttr::getSpelling() const {
    1856           0 :   switch (SpellingListIndex) {
    1857           0 :   default:
    1858           0 :     llvm_unreachable("Unknown attribute spelling!");
    1859             :     return "(No spelling)";
    1860             :   case 0:
    1861             :     return "cleanup";
    1862             :   case 1:
    1863             :     return "cleanup";
    1864             :   }
    1865             : }
    1866             : 
    1867           1 : ColdAttr *ColdAttr::clone(ASTContext &C) const {
    1868           5 :   auto *A = new (C) ColdAttr(getLocation(), C, getSpellingListIndex());
    1869           1 :   A->Inherited = Inherited;
    1870           1 :   A->IsPackExpansion = IsPackExpansion;
    1871           1 :   A->Implicit = Implicit;
    1872           1 :   return A;
    1873             : }
    1874             : 
    1875           6 : void ColdAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    1876           6 :   switch (SpellingListIndex) {
    1877           0 :   default:
    1878           0 :     llvm_unreachable("Unknown attribute spelling!");
    1879             :     break;
    1880           6 :   case 0 : {
    1881           6 :     OS << " __attribute__((cold))";
    1882           6 :     break;
    1883             :   }
    1884           0 :   case 1 : {
    1885           0 :     OS << " [[gnu::cold]]";
    1886           0 :     break;
    1887             :   }
    1888             : }
    1889           6 : }
    1890             : 
    1891           1 : const char *ColdAttr::getSpelling() const {
    1892           1 :   switch (SpellingListIndex) {
    1893           0 :   default:
    1894           0 :     llvm_unreachable("Unknown attribute spelling!");
    1895             :     return "(No spelling)";
    1896             :   case 0:
    1897             :     return "cold";
    1898             :   case 1:
    1899             :     return "cold";
    1900             :   }
    1901             : }
    1902             : 
    1903           0 : CommonAttr *CommonAttr::clone(ASTContext &C) const {
    1904           0 :   auto *A = new (C) CommonAttr(getLocation(), C, getSpellingListIndex());
    1905           0 :   A->Inherited = Inherited;
    1906           0 :   A->IsPackExpansion = IsPackExpansion;
    1907           0 :   A->Implicit = Implicit;
    1908           0 :   return A;
    1909             : }
    1910             : 
    1911           0 : void CommonAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    1912           0 :   switch (SpellingListIndex) {
    1913           0 :   default:
    1914           0 :     llvm_unreachable("Unknown attribute spelling!");
    1915             :     break;
    1916           0 :   case 0 : {
    1917           0 :     OS << " __attribute__((common))";
    1918           0 :     break;
    1919             :   }
    1920           0 :   case 1 : {
    1921           0 :     OS << " [[gnu::common]]";
    1922           0 :     break;
    1923             :   }
    1924             : }
    1925           0 : }
    1926             : 
    1927           3 : const char *CommonAttr::getSpelling() const {
    1928           3 :   switch (SpellingListIndex) {
    1929           0 :   default:
    1930           0 :     llvm_unreachable("Unknown attribute spelling!");
    1931             :     return "(No spelling)";
    1932             :   case 0:
    1933             :     return "common";
    1934             :   case 1:
    1935             :     return "common";
    1936             :   }
    1937             : }
    1938             : 
    1939         524 : ConstAttr *ConstAttr::clone(ASTContext &C) const {
    1940        2620 :   auto *A = new (C) ConstAttr(getLocation(), C, getSpellingListIndex());
    1941         524 :   A->Inherited = Inherited;
    1942         524 :   A->IsPackExpansion = IsPackExpansion;
    1943         524 :   A->Implicit = Implicit;
    1944         524 :   return A;
    1945             : }
    1946             : 
    1947           6 : void ConstAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    1948           6 :   switch (SpellingListIndex) {
    1949           0 :   default:
    1950           0 :     llvm_unreachable("Unknown attribute spelling!");
    1951             :     break;
    1952           3 :   case 0 : {
    1953           3 :     OS << " __attribute__((const))";
    1954           3 :     break;
    1955             :   }
    1956           0 :   case 1 : {
    1957           0 :     OS << " [[gnu::const]]";
    1958           0 :     break;
    1959             :   }
    1960           3 :   case 2 : {
    1961           3 :     OS << " __attribute__((__const))";
    1962           3 :     break;
    1963             :   }
    1964           0 :   case 3 : {
    1965           0 :     OS << " [[gnu::__const]]";
    1966           0 :     break;
    1967             :   }
    1968             : }
    1969           6 : }
    1970             : 
    1971           0 : const char *ConstAttr::getSpelling() const {
    1972           0 :   switch (SpellingListIndex) {
    1973           0 :   default:
    1974           0 :     llvm_unreachable("Unknown attribute spelling!");
    1975             :     return "(No spelling)";
    1976             :   case 0:
    1977             :     return "const";
    1978             :   case 1:
    1979             :     return "const";
    1980           0 :   case 2:
    1981           0 :     return "__const";
    1982           0 :   case 3:
    1983           0 :     return "__const";
    1984             :   }
    1985             : }
    1986             : 
    1987          13 : ConstructorAttr *ConstructorAttr::clone(ASTContext &C) const {
    1988          65 :   auto *A = new (C) ConstructorAttr(getLocation(), C, priority, getSpellingListIndex());
    1989          13 :   A->Inherited = Inherited;
    1990          13 :   A->IsPackExpansion = IsPackExpansion;
    1991          13 :   A->Implicit = Implicit;
    1992          13 :   return A;
    1993             : }
    1994             : 
    1995           0 : void ConstructorAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    1996           0 :   switch (SpellingListIndex) {
    1997           0 :   default:
    1998           0 :     llvm_unreachable("Unknown attribute spelling!");
    1999             :     break;
    2000           0 :   case 0 : {
    2001           0 :     OS << " __attribute__((constructor(" << getPriority() << ")))";
    2002           0 :     break;
    2003             :   }
    2004           0 :   case 1 : {
    2005           0 :     OS << " [[gnu::constructor(" << getPriority() << ")]]";
    2006           0 :     break;
    2007             :   }
    2008             : }
    2009           0 : }
    2010             : 
    2011           0 : const char *ConstructorAttr::getSpelling() const {
    2012           0 :   switch (SpellingListIndex) {
    2013           0 :   default:
    2014           0 :     llvm_unreachable("Unknown attribute spelling!");
    2015             :     return "(No spelling)";
    2016             :   case 0:
    2017             :     return "constructor";
    2018             :   case 1:
    2019             :     return "constructor";
    2020             :   }
    2021             : }
    2022             : 
    2023           2 : ConsumableAttr *ConsumableAttr::clone(ASTContext &C) const {
    2024          10 :   auto *A = new (C) ConsumableAttr(getLocation(), C, defaultState, getSpellingListIndex());
    2025           2 :   A->Inherited = Inherited;
    2026           2 :   A->IsPackExpansion = IsPackExpansion;
    2027           2 :   A->Implicit = Implicit;
    2028           2 :   return A;
    2029             : }
    2030             : 
    2031           1 : void ConsumableAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    2032           1 :   switch (SpellingListIndex) {
    2033           0 :   default:
    2034           0 :     llvm_unreachable("Unknown attribute spelling!");
    2035             :     break;
    2036           1 :   case 0 : {
    2037           2 :     OS << " __attribute__((consumable(\"" << ConsumableAttr::ConvertConsumedStateToStr(getDefaultState()) << "\")))";
    2038             :     break;
    2039             :   }
    2040             : }
    2041           1 : }
    2042             : 
    2043           0 : const char *ConsumableAttr::getSpelling() const {
    2044           0 :   switch (SpellingListIndex) {
    2045           0 :   default:
    2046           0 :     llvm_unreachable("Unknown attribute spelling!");
    2047             :     return "(No spelling)";
    2048           0 :   case 0:
    2049             :     return "consumable";
    2050             :   }
    2051             : }
    2052             : 
    2053           0 : ConsumableAutoCastAttr *ConsumableAutoCastAttr::clone(ASTContext &C) const {
    2054           0 :   auto *A = new (C) ConsumableAutoCastAttr(getLocation(), C, getSpellingListIndex());
    2055           0 :   A->Inherited = Inherited;
    2056           0 :   A->IsPackExpansion = IsPackExpansion;
    2057           0 :   A->Implicit = Implicit;
    2058           0 :   return A;
    2059             : }
    2060             : 
    2061           0 : void ConsumableAutoCastAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    2062           0 :   switch (SpellingListIndex) {
    2063           0 :   default:
    2064           0 :     llvm_unreachable("Unknown attribute spelling!");
    2065             :     break;
    2066           0 :   case 0 : {
    2067           0 :     OS << " __attribute__((consumable_auto_cast_state))";
    2068             :     break;
    2069             :   }
    2070             : }
    2071           0 : }
    2072             : 
    2073           0 : const char *ConsumableAutoCastAttr::getSpelling() const {
    2074           0 :   switch (SpellingListIndex) {
    2075           0 :   default:
    2076           0 :     llvm_unreachable("Unknown attribute spelling!");
    2077             :     return "(No spelling)";
    2078           0 :   case 0:
    2079             :     return "consumable_auto_cast_state";
    2080             :   }
    2081             : }
    2082             : 
    2083           0 : ConsumableSetOnReadAttr *ConsumableSetOnReadAttr::clone(ASTContext &C) const {
    2084           0 :   auto *A = new (C) ConsumableSetOnReadAttr(getLocation(), C, getSpellingListIndex());
    2085           0 :   A->Inherited = Inherited;
    2086           0 :   A->IsPackExpansion = IsPackExpansion;
    2087           0 :   A->Implicit = Implicit;
    2088           0 :   return A;
    2089             : }
    2090             : 
    2091           0 : void ConsumableSetOnReadAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    2092           0 :   switch (SpellingListIndex) {
    2093           0 :   default:
    2094           0 :     llvm_unreachable("Unknown attribute spelling!");
    2095             :     break;
    2096           0 :   case 0 : {
    2097           0 :     OS << " __attribute__((consumable_set_state_on_read))";
    2098             :     break;
    2099             :   }
    2100             : }
    2101           0 : }
    2102             : 
    2103           0 : const char *ConsumableSetOnReadAttr::getSpelling() const {
    2104           0 :   switch (SpellingListIndex) {
    2105           0 :   default:
    2106           0 :     llvm_unreachable("Unknown attribute spelling!");
    2107             :     return "(No spelling)";
    2108           0 :   case 0:
    2109             :     return "consumable_set_state_on_read";
    2110             :   }
    2111             : }
    2112             : 
    2113           0 : ConvergentAttr *ConvergentAttr::clone(ASTContext &C) const {
    2114           0 :   auto *A = new (C) ConvergentAttr(getLocation(), C, getSpellingListIndex());
    2115           0 :   A->Inherited = Inherited;
    2116           0 :   A->IsPackExpansion = IsPackExpansion;
    2117           0 :   A->Implicit = Implicit;
    2118           0 :   return A;
    2119             : }
    2120             : 
    2121           0 : void ConvergentAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    2122           0 :   switch (SpellingListIndex) {
    2123           0 :   default:
    2124           0 :     llvm_unreachable("Unknown attribute spelling!");
    2125             :     break;
    2126           0 :   case 0 : {
    2127           0 :     OS << " __attribute__((convergent))";
    2128           0 :     break;
    2129             :   }
    2130           0 :   case 1 : {
    2131           0 :     OS << " [[clang::convergent]]";
    2132           0 :     break;
    2133             :   }
    2134             : }
    2135           0 : }
    2136             : 
    2137           0 : const char *ConvergentAttr::getSpelling() const {
    2138           0 :   switch (SpellingListIndex) {
    2139           0 :   default:
    2140           0 :     llvm_unreachable("Unknown attribute spelling!");
    2141             :     return "(No spelling)";
    2142             :   case 0:
    2143             :     return "convergent";
    2144             :   case 1:
    2145             :     return "convergent";
    2146             :   }
    2147             : }
    2148             : 
    2149        2317 : DLLExportAttr *DLLExportAttr::clone(ASTContext &C) const {
    2150       11585 :   auto *A = new (C) DLLExportAttr(getLocation(), C, getSpellingListIndex());
    2151        2317 :   A->Inherited = Inherited;
    2152        2317 :   A->IsPackExpansion = IsPackExpansion;
    2153        2317 :   A->Implicit = Implicit;
    2154        2317 :   return A;
    2155             : }
    2156             : 
    2157           0 : void DLLExportAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    2158           0 :   switch (SpellingListIndex) {
    2159           0 :   default:
    2160           0 :     llvm_unreachable("Unknown attribute spelling!");
    2161             :     break;
    2162           0 :   case 0 : {
    2163           0 :     OS << " __declspec(dllexport)";
    2164           0 :     break;
    2165             :   }
    2166           0 :   case 1 : {
    2167           0 :     OS << " __attribute__((dllexport))";
    2168           0 :     break;
    2169             :   }
    2170           0 :   case 2 : {
    2171           0 :     OS << " [[gnu::dllexport]]";
    2172           0 :     break;
    2173             :   }
    2174             : }
    2175           0 : }
    2176             : 
    2177         365 : const char *DLLExportAttr::getSpelling() const {
    2178         365 :   switch (SpellingListIndex) {
    2179           0 :   default:
    2180           0 :     llvm_unreachable("Unknown attribute spelling!");
    2181             :     return "(No spelling)";
    2182             :   case 0:
    2183             :     return "dllexport";
    2184             :   case 1:
    2185             :     return "dllexport";
    2186             :   case 2:
    2187             :     return "dllexport";
    2188             :   }
    2189             : }
    2190             : 
    2191        2193 : DLLImportAttr *DLLImportAttr::clone(ASTContext &C) const {
    2192       10965 :   auto *A = new (C) DLLImportAttr(getLocation(), C, getSpellingListIndex());
    2193        2193 :   A->Inherited = Inherited;
    2194        2193 :   A->IsPackExpansion = IsPackExpansion;
    2195        2193 :   A->Implicit = Implicit;
    2196        2193 :   return A;
    2197             : }
    2198             : 
    2199           0 : void DLLImportAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    2200           0 :   switch (SpellingListIndex) {
    2201           0 :   default:
    2202           0 :     llvm_unreachable("Unknown attribute spelling!");
    2203             :     break;
    2204           0 :   case 0 : {
    2205           0 :     OS << " __declspec(dllimport)";
    2206           0 :     break;
    2207             :   }
    2208           0 :   case 1 : {
    2209           0 :     OS << " __attribute__((dllimport))";
    2210           0 :     break;
    2211             :   }
    2212           0 :   case 2 : {
    2213           0 :     OS << " [[gnu::dllimport]]";
    2214           0 :     break;
    2215             :   }
    2216             : }
    2217           0 : }
    2218             : 
    2219         830 : const char *DLLImportAttr::getSpelling() const {
    2220         830 :   switch (SpellingListIndex) {
    2221           0 :   default:
    2222           0 :     llvm_unreachable("Unknown attribute spelling!");
    2223             :     return "(No spelling)";
    2224             :   case 0:
    2225             :     return "dllimport";
    2226             :   case 1:
    2227             :     return "dllimport";
    2228             :   case 2:
    2229             :     return "dllimport";
    2230             :   }
    2231             : }
    2232             : 
    2233         138 : DeprecatedAttr *DeprecatedAttr::clone(ASTContext &C) const {
    2234         966 :   auto *A = new (C) DeprecatedAttr(getLocation(), C, getMessage(), getReplacement(), getSpellingListIndex());
    2235         138 :   A->Inherited = Inherited;
    2236         138 :   A->IsPackExpansion = IsPackExpansion;
    2237         138 :   A->Implicit = Implicit;
    2238         138 :   return A;
    2239             : }
    2240             : 
    2241           9 : void DeprecatedAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    2242           9 :   switch (SpellingListIndex) {
    2243           0 :   default:
    2244           0 :     llvm_unreachable("Unknown attribute spelling!");
    2245             :     break;
    2246           6 :   case 0 : {
    2247          12 :     OS << " __attribute__((deprecated(\"" << getMessage() << "\"";
    2248          13 :     if (!getReplacement().empty()) OS << ", \"" << getReplacement() << "\"";
    2249           6 :     OS << ")))";
    2250           6 :     break;
    2251             :   }
    2252           1 :   case 1 : {
    2253           2 :     OS << " [[gnu::deprecated(\"" << getMessage() << "\"";
    2254           1 :     OS << ")]]";
    2255           1 :     break;
    2256             :   }
    2257           1 :   case 2 : {
    2258           2 :     OS << " __declspec(deprecated(\"" << getMessage() << "\"";
    2259           1 :     OS << "))";
    2260           1 :     break;
    2261             :   }
    2262           1 :   case 3 : {
    2263           2 :     OS << " [[deprecated(\"" << getMessage() << "\"";
    2264           1 :     OS << ")]]";
    2265           1 :     break;
    2266             :   }
    2267             : }
    2268           9 : }
    2269             : 
    2270           0 : const char *DeprecatedAttr::getSpelling() const {
    2271           0 :   switch (SpellingListIndex) {
    2272           0 :   default:
    2273           0 :     llvm_unreachable("Unknown attribute spelling!");
    2274             :     return "(No spelling)";
    2275             :   case 0:
    2276             :     return "deprecated";
    2277             :   case 1:
    2278             :     return "deprecated";
    2279             :   case 2:
    2280             :     return "deprecated";
    2281             :   case 3:
    2282             :     return "deprecated";
    2283             :   }
    2284             : }
    2285             : 
    2286           7 : DestructorAttr *DestructorAttr::clone(ASTContext &C) const {
    2287          35 :   auto *A = new (C) DestructorAttr(getLocation(), C, priority, getSpellingListIndex());
    2288           7 :   A->Inherited = Inherited;
    2289           7 :   A->IsPackExpansion = IsPackExpansion;
    2290           7 :   A->Implicit = Implicit;
    2291           7 :   return A;
    2292             : }
    2293             : 
    2294           0 : void DestructorAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    2295           0 :   switch (SpellingListIndex) {
    2296           0 :   default:
    2297           0 :     llvm_unreachable("Unknown attribute spelling!");
    2298             :     break;
    2299           0 :   case 0 : {
    2300           0 :     OS << " __attribute__((destructor(" << getPriority() << ")))";
    2301           0 :     break;
    2302             :   }
    2303           0 :   case 1 : {
    2304           0 :     OS << " [[gnu::destructor(" << getPriority() << ")]]";
    2305           0 :     break;
    2306             :   }
    2307             : }
    2308           0 : }
    2309             : 
    2310           0 : const char *DestructorAttr::getSpelling() const {
    2311           0 :   switch (SpellingListIndex) {
    2312           0 :   default:
    2313           0 :     llvm_unreachable("Unknown attribute spelling!");
    2314             :     return "(No spelling)";
    2315             :   case 0:
    2316             :     return "destructor";
    2317             :   case 1:
    2318             :     return "destructor";
    2319             :   }
    2320             : }
    2321             : 
    2322           4 : DiagnoseIfAttr *DiagnoseIfAttr::clone(ASTContext &C) const {
    2323          24 :   auto *A = new (C) DiagnoseIfAttr(getLocation(), C, cond, getMessage(), diagnosticType, argDependent, parent, getSpellingListIndex());
    2324           4 :   A->Inherited = Inherited;
    2325           4 :   A->IsPackExpansion = IsPackExpansion;
    2326           4 :   A->Implicit = Implicit;
    2327           4 :   return A;
    2328             : }
    2329             : 
    2330           0 : void DiagnoseIfAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    2331           0 :   switch (SpellingListIndex) {
    2332           0 :   default:
    2333           0 :     llvm_unreachable("Unknown attribute spelling!");
    2334             :     break;
    2335           0 :   case 0 : {
    2336           0 :     OS << " __attribute__((diagnose_if(" << getCond() << ", \"" << getMessage() << "\", \"" << DiagnoseIfAttr::ConvertDiagnosticTypeToStr(getDiagnosticType()) << "\")))";
    2337             :     break;
    2338             :   }
    2339             : }
    2340           0 : }
    2341             : 
    2342           0 : const char *DiagnoseIfAttr::getSpelling() const {
    2343           0 :   switch (SpellingListIndex) {
    2344           0 :   default:
    2345           0 :     llvm_unreachable("Unknown attribute spelling!");
    2346             :     return "(No spelling)";
    2347           0 :   case 0:
    2348             :     return "diagnose_if";
    2349             :   }
    2350             : }
    2351             : 
    2352           0 : DisableTailCallsAttr *DisableTailCallsAttr::clone(ASTContext &C) const {
    2353           0 :   auto *A = new (C) DisableTailCallsAttr(getLocation(), C, getSpellingListIndex());
    2354           0 :   A->Inherited = Inherited;
    2355           0 :   A->IsPackExpansion = IsPackExpansion;
    2356           0 :   A->Implicit = Implicit;
    2357           0 :   return A;
    2358             : }
    2359             : 
    2360           0 : void DisableTailCallsAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    2361           0 :   switch (SpellingListIndex) {
    2362           0 :   default:
    2363           0 :     llvm_unreachable("Unknown attribute spelling!");
    2364             :     break;
    2365           0 :   case 0 : {
    2366           0 :     OS << " __attribute__((disable_tail_calls))";
    2367           0 :     break;
    2368             :   }
    2369           0 :   case 1 : {
    2370           0 :     OS << " [[clang::disable_tail_calls]]";
    2371           0 :     break;
    2372             :   }
    2373             : }
    2374           0 : }
    2375             : 
    2376           1 : const char *DisableTailCallsAttr::getSpelling() const {
    2377           1 :   switch (SpellingListIndex) {
    2378           0 :   default:
    2379           0 :     llvm_unreachable("Unknown attribute spelling!");
    2380             :     return "(No spelling)";
    2381             :   case 0:
    2382             :     return "disable_tail_calls";
    2383             :   case 1:
    2384             :     return "disable_tail_calls";
    2385             :   }
    2386             : }
    2387             : 
    2388           0 : EmptyBasesAttr *EmptyBasesAttr::clone(ASTContext &C) const {
    2389           0 :   auto *A = new (C) EmptyBasesAttr(getLocation(), C, getSpellingListIndex());
    2390           0 :   A->Inherited = Inherited;
    2391           0 :   A->IsPackExpansion = IsPackExpansion;
    2392           0 :   A->Implicit = Implicit;
    2393           0 :   return A;
    2394             : }
    2395             : 
    2396           0 : void EmptyBasesAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    2397           0 :   switch (SpellingListIndex) {
    2398           0 :   default:
    2399           0 :     llvm_unreachable("Unknown attribute spelling!");
    2400             :     break;
    2401           0 :   case 0 : {
    2402           0 :     OS << " __declspec(empty_bases)";
    2403             :     break;
    2404             :   }
    2405             : }
    2406           0 : }
    2407             : 
    2408           0 : const char *EmptyBasesAttr::getSpelling() const {
    2409           0 :   switch (SpellingListIndex) {
    2410           0 :   default:
    2411           0 :     llvm_unreachable("Unknown attribute spelling!");
    2412             :     return "(No spelling)";
    2413           0 :   case 0:
    2414             :     return "empty_bases";
    2415             :   }
    2416             : }
    2417             : 
    2418           0 : EnableIfAttr *EnableIfAttr::clone(ASTContext &C) const {
    2419           0 :   auto *A = new (C) EnableIfAttr(getLocation(), C, cond, getMessage(), getSpellingListIndex());
    2420           0 :   A->Inherited = Inherited;
    2421           0 :   A->IsPackExpansion = IsPackExpansion;
    2422           0 :   A->Implicit = Implicit;
    2423           0 :   return A;
    2424             : }
    2425             : 
    2426           0 : void EnableIfAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    2427           0 :   switch (SpellingListIndex) {
    2428           0 :   default:
    2429           0 :     llvm_unreachable("Unknown attribute spelling!");
    2430             :     break;
    2431           0 :   case 0 : {
    2432           0 :     OS << " __attribute__((enable_if(" << getCond() << ", \"" << getMessage() << "\")))";
    2433             :     break;
    2434             :   }
    2435             : }
    2436           0 : }
    2437             : 
    2438           0 : const char *EnableIfAttr::getSpelling() const {
    2439           0 :   switch (SpellingListIndex) {
    2440           0 :   default:
    2441           0 :     llvm_unreachable("Unknown attribute spelling!");
    2442             :     return "(No spelling)";
    2443           0 :   case 0:
    2444             :     return "enable_if";
    2445             :   }
    2446             : }
    2447             : 
    2448           0 : EnumExtensibilityAttr *EnumExtensibilityAttr::clone(ASTContext &C) const {
    2449           0 :   auto *A = new (C) EnumExtensibilityAttr(getLocation(), C, extensibility, getSpellingListIndex());
    2450           0 :   A->Inherited = Inherited;
    2451           0 :   A->IsPackExpansion = IsPackExpansion;
    2452           0 :   A->Implicit = Implicit;
    2453           0 :   return A;
    2454             : }
    2455             : 
    2456           0 : void EnumExtensibilityAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    2457           0 :   switch (SpellingListIndex) {
    2458           0 :   default:
    2459           0 :     llvm_unreachable("Unknown attribute spelling!");
    2460             :     break;
    2461           0 :   case 0 : {
    2462           0 :     OS << " __attribute__((enum_extensibility(\"" << EnumExtensibilityAttr::ConvertKindToStr(getExtensibility()) << "\")))";
    2463           0 :     break;
    2464             :   }
    2465           0 :   case 1 : {
    2466           0 :     OS << " [[clang::enum_extensibility(\"" << EnumExtensibilityAttr::ConvertKindToStr(getExtensibility()) << "\")]]";
    2467           0 :     break;
    2468             :   }
    2469             : }
    2470           0 : }
    2471             : 
    2472           0 : const char *EnumExtensibilityAttr::getSpelling() const {
    2473           0 :   switch (SpellingListIndex) {
    2474           0 :   default:
    2475           0 :     llvm_unreachable("Unknown attribute spelling!");
    2476             :     return "(No spelling)";
    2477             :   case 0:
    2478             :     return "enum_extensibility";
    2479             :   case 1:
    2480             :     return "enum_extensibility";
    2481             :   }
    2482             : }
    2483             : 
    2484           9 : ExclusiveTrylockFunctionAttr *ExclusiveTrylockFunctionAttr::clone(ASTContext &C) const {
    2485          45 :   auto *A = new (C) ExclusiveTrylockFunctionAttr(getLocation(), C, successValue, args_, args_Size, getSpellingListIndex());
    2486           9 :   A->Inherited = Inherited;
    2487           9 :   A->IsPackExpansion = IsPackExpansion;
    2488           9 :   A->Implicit = Implicit;
    2489           9 :   return A;
    2490             : }
    2491             : 
    2492           0 : void ExclusiveTrylockFunctionAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    2493           0 :   switch (SpellingListIndex) {
    2494           0 :   default:
    2495           0 :     llvm_unreachable("Unknown attribute spelling!");
    2496             :     break;
    2497           0 :   case 0 : {
    2498           0 :     OS << " __attribute__((exclusive_trylock_function(" << getSuccessValue() << ", ";
    2499           0 :   bool isFirst = true;
    2500           0 :   for (const auto &Val : args()) {
    2501           0 :     if (isFirst) isFirst = false;
    2502           0 :     else OS << ", ";
    2503           0 :     OS << Val;
    2504             :   }
    2505           0 :   OS << ")))";
    2506             :     break;
    2507             :   }
    2508             : }
    2509           0 : }
    2510             : 
    2511           0 : const char *ExclusiveTrylockFunctionAttr::getSpelling() const {
    2512           0 :   switch (SpellingListIndex) {
    2513           0 :   default:
    2514           0 :     llvm_unreachable("Unknown attribute spelling!");
    2515             :     return "(No spelling)";
    2516           0 :   case 0:
    2517             :     return "exclusive_trylock_function";
    2518             :   }
    2519             : }
    2520             : 
    2521           0 : ExternalSourceSymbolAttr *ExternalSourceSymbolAttr::clone(ASTContext &C) const {
    2522           0 :   auto *A = new (C) ExternalSourceSymbolAttr(getLocation(), C, getLanguage(), getDefinedIn(), generatedDeclaration, getSpellingListIndex());
    2523           0 :   A->Inherited = Inherited;
    2524           0 :   A->IsPackExpansion = IsPackExpansion;
    2525           0 :   A->Implicit = Implicit;
    2526           0 :   return A;
    2527             : }
    2528             : 
    2529           0 : void ExternalSourceSymbolAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    2530           0 :   switch (SpellingListIndex) {
    2531           0 :   default:
    2532           0 :     llvm_unreachable("Unknown attribute spelling!");
    2533             :     break;
    2534           0 :   case 0 : {
    2535           0 :     OS << " __attribute__((external_source_symbol(\"" << getLanguage() << "\", \"" << getDefinedIn() << "\", " << getGeneratedDeclaration() << ")))";
    2536           0 :     break;
    2537             :   }
    2538           0 :   case 1 : {
    2539           0 :     OS << " [[clang::external_source_symbol(\"" << getLanguage() << "\", \"" << getDefinedIn() << "\", " << getGeneratedDeclaration() << ")]]";
    2540           0 :     break;
    2541             :   }
    2542             : }
    2543           0 : }
    2544             : 
    2545           0 : const char *ExternalSourceSymbolAttr::getSpelling() const {
    2546           0 :   switch (SpellingListIndex) {
    2547           0 :   default:
    2548           0 :     llvm_unreachable("Unknown attribute spelling!");
    2549             :     return "(No spelling)";
    2550             :   case 0:
    2551             :     return "external_source_symbol";
    2552             :   case 1:
    2553             :     return "external_source_symbol";
    2554             :   }
    2555             : }
    2556             : 
    2557           0 : FallThroughAttr *FallThroughAttr::clone(ASTContext &C) const {
    2558           0 :   auto *A = new (C) FallThroughAttr(getLocation(), C, getSpellingListIndex());
    2559           0 :   A->Inherited = Inherited;
    2560           0 :   A->IsPackExpansion = IsPackExpansion;
    2561           0 :   A->Implicit = Implicit;
    2562           0 :   return A;
    2563             : }
    2564             : 
    2565           3 : void FallThroughAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    2566           3 :   switch (SpellingListIndex) {
    2567           0 :   default:
    2568           0 :     llvm_unreachable("Unknown attribute spelling!");
    2569             :     break;
    2570           0 :   case 0 : {
    2571           0 :     OS << " [[fallthrough]]";
    2572           0 :     break;
    2573             :   }
    2574           3 :   case 1 : {
    2575           3 :     OS << " [[clang::fallthrough]]";
    2576           3 :     break;
    2577             :   }
    2578             : }
    2579           3 : }
    2580             : 
    2581           5 : const char *FallThroughAttr::getSpelling() const {
    2582           5 :   switch (SpellingListIndex) {
    2583           0 :   default:
    2584           0 :     llvm_unreachable("Unknown attribute spelling!");
    2585             :     return "(No spelling)";
    2586             :   case 0:
    2587             :     return "fallthrough";
    2588             :   case 1:
    2589             :     return "fallthrough";
    2590             :   }
    2591             : }
    2592             : 
    2593           0 : FastCallAttr *FastCallAttr::clone(ASTContext &C) const {
    2594           0 :   auto *A = new (C) FastCallAttr(getLocation(), C, getSpellingListIndex());
    2595           0 :   A->Inherited = Inherited;
    2596           0 :   A->IsPackExpansion = IsPackExpansion;
    2597           0 :   A->Implicit = Implicit;
    2598           0 :   return A;
    2599             : }
    2600             : 
    2601           0 : void FastCallAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    2602           0 :   switch (SpellingListIndex) {
    2603           0 :   default:
    2604           0 :     llvm_unreachable("Unknown attribute spelling!");
    2605             :     break;
    2606           0 :   case 0 : {
    2607           0 :     OS << " __attribute__((fastcall))";
    2608           0 :     break;
    2609             :   }
    2610           0 :   case 1 : {
    2611           0 :     OS << " [[gnu::fastcall]]";
    2612           0 :     break;
    2613             :   }
    2614           0 :   case 2 : {
    2615           0 :     OS << " __fastcall";
    2616           0 :     break;
    2617             :   }
    2618           0 :   case 3 : {
    2619           0 :     OS << " _fastcall";
    2620           0 :     break;
    2621             :   }
    2622             : }
    2623           0 : }
    2624             : 
    2625           0 : const char *FastCallAttr::getSpelling() const {
    2626           0 :   switch (SpellingListIndex) {
    2627           0 :   default:
    2628           0 :     llvm_unreachable("Unknown attribute spelling!");
    2629             :     return "(No spelling)";
    2630             :   case 0:
    2631             :     return "fastcall";
    2632             :   case 1:
    2633             :     return "fastcall";
    2634           0 :   case 2:
    2635           0 :     return "__fastcall";
    2636           0 :   case 3:
    2637           0 :     return "_fastcall";
    2638             :   }
    2639             : }
    2640             : 
    2641          49 : FinalAttr *FinalAttr::clone(ASTContext &C) const {
    2642         245 :   auto *A = new (C) FinalAttr(getLocation(), C, getSpellingListIndex());
    2643          49 :   A->Inherited = Inherited;
    2644          49 :   A->IsPackExpansion = IsPackExpansion;
    2645          49 :   A->Implicit = Implicit;
    2646          49 :   return A;
    2647             : }
    2648             : 
    2649           0 : void FinalAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    2650           0 :   switch (SpellingListIndex) {
    2651           0 :   default:
    2652           0 :     llvm_unreachable("Unknown attribute spelling!");
    2653             :     break;
    2654           0 :   case 0 : {
    2655           0 :     OS << " final";
    2656           0 :     break;
    2657             :   }
    2658           0 :   case 1 : {
    2659           0 :     OS << " sealed";
    2660           0 :     break;
    2661             :   }
    2662             : }
    2663           0 : }
    2664             : 
    2665           0 : const char *FinalAttr::getSpelling() const {
    2666           0 :   switch (SpellingListIndex) {
    2667           0 :   default:
    2668           0 :     llvm_unreachable("Unknown attribute spelling!");
    2669             :     return "(No spelling)";
    2670             :   case 0:
    2671             :     return "final";
    2672           0 :   case 1:
    2673           0 :     return "sealed";
    2674             :   }
    2675             : }
    2676             : 
    2677           0 : FlagEnumAttr *FlagEnumAttr::clone(ASTContext &C) const {
    2678           0 :   auto *A = new (C) FlagEnumAttr(getLocation(), C, getSpellingListIndex());
    2679           0 :   A->Inherited = Inherited;
    2680           0 :   A->IsPackExpansion = IsPackExpansion;
    2681           0 :   A->Implicit = Implicit;
    2682           0 :   return A;
    2683             : }
    2684             : 
    2685           0 : void FlagEnumAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    2686           0 :   switch (SpellingListIndex) {
    2687           0 :   default:
    2688           0 :     llvm_unreachable("Unknown attribute spelling!");
    2689             :     break;
    2690           0 :   case 0 : {
    2691           0 :     OS << " __attribute__((flag_enum))";
    2692             :     break;
    2693             :   }
    2694             : }
    2695           0 : }
    2696             : 
    2697           0 : const char *FlagEnumAttr::getSpelling() const {
    2698           0 :   switch (SpellingListIndex) {
    2699           0 :   default:
    2700           0 :     llvm_unreachable("Unknown attribute spelling!");
    2701             :     return "(No spelling)";
    2702           0 :   case 0:
    2703             :     return "flag_enum";
    2704             :   }
    2705             : }
    2706             : 
    2707           0 : FlattenAttr *FlattenAttr::clone(ASTContext &C) const {
    2708           0 :   auto *A = new (C) FlattenAttr(getLocation(), C, getSpellingListIndex());
    2709           0 :   A->Inherited = Inherited;
    2710           0 :   A->IsPackExpansion = IsPackExpansion;
    2711           0 :   A->Implicit = Implicit;
    2712           0 :   return A;
    2713             : }
    2714             : 
    2715           0 : void FlattenAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    2716           0 :   switch (SpellingListIndex) {
    2717           0 :   default:
    2718           0 :     llvm_unreachable("Unknown attribute spelling!");
    2719             :     break;
    2720           0 :   case 0 : {
    2721           0 :     OS << " __attribute__((flatten))";
    2722           0 :     break;
    2723             :   }
    2724           0 :   case 1 : {
    2725           0 :     OS << " [[gnu::flatten]]";
    2726           0 :     break;
    2727             :   }
    2728             : }
    2729           0 : }
    2730             : 
    2731           0 : const char *FlattenAttr::getSpelling() const {
    2732           0 :   switch (SpellingListIndex) {
    2733           0 :   default:
    2734           0 :     llvm_unreachable("Unknown attribute spelling!");
    2735             :     return "(No spelling)";
    2736             :   case 0:
    2737             :     return "flatten";
    2738             :   case 1:
    2739             :     return "flatten";
    2740             :   }
    2741             : }
    2742             : 
    2743           3 : FormatAttr *FormatAttr::clone(ASTContext &C) const {
    2744          15 :   auto *A = new (C) FormatAttr(getLocation(), C, type, formatIdx, firstArg, getSpellingListIndex());
    2745           3 :   A->Inherited = Inherited;
    2746           3 :   A->IsPackExpansion = IsPackExpansion;
    2747           3 :   A->Implicit = Implicit;
    2748           3 :   return A;
    2749             : }
    2750             : 
    2751           1 : void FormatAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    2752           1 :   switch (SpellingListIndex) {
    2753           0 :   default:
    2754           0 :     llvm_unreachable("Unknown attribute spelling!");
    2755             :     break;
    2756           1 :   case 0 : {
    2757           1 :     OS << " __attribute__((format(";
    2758           2 :     OS << getType()->getName();
    2759           3 :     OS << ", " << getFormatIdx() << ", " << getFirstArg() << ")))";
    2760           1 :     break;
    2761             :   }
    2762           0 :   case 1 : {
    2763           0 :     OS << " [[gnu::format(";
    2764           0 :     OS << getType()->getName();
    2765           0 :     OS << ", " << getFormatIdx() << ", " << getFirstArg() << ")]]";
    2766           0 :     break;
    2767             :   }
    2768             : }
    2769           1 : }
    2770             : 
    2771           0 : const char *FormatAttr::getSpelling() const {
    2772           0 :   switch (SpellingListIndex) {
    2773           0 :   default:
    2774           0 :     llvm_unreachable("Unknown attribute spelling!");
    2775             :     return "(No spelling)";
    2776             :   case 0:
    2777             :     return "format";
    2778             :   case 1:
    2779             :     return "format";
    2780             :   }
    2781             : }
    2782             : 
    2783           0 : FormatArgAttr *FormatArgAttr::clone(ASTContext &C) const {
    2784           0 :   auto *A = new (C) FormatArgAttr(getLocation(), C, formatIdx, getSpellingListIndex());
    2785           0 :   A->Inherited = Inherited;
    2786           0 :   A->IsPackExpansion = IsPackExpansion;
    2787           0 :   A->Implicit = Implicit;
    2788           0 :   return A;
    2789             : }
    2790             : 
    2791           0 : void FormatArgAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    2792           0 :   switch (SpellingListIndex) {
    2793           0 :   default:
    2794           0 :     llvm_unreachable("Unknown attribute spelling!");
    2795             :     break;
    2796           0 :   case 0 : {
    2797           0 :     OS << " __attribute__((format_arg(" << getFormatIdx() << ")))";
    2798           0 :     break;
    2799             :   }
    2800           0 :   case 1 : {
    2801           0 :     OS << " [[gnu::format_arg(" << getFormatIdx() << ")]]";
    2802           0 :     break;
    2803             :   }
    2804             : }
    2805           0 : }
    2806             : 
    2807           0 : const char *FormatArgAttr::getSpelling() const {
    2808           0 :   switch (SpellingListIndex) {
    2809           0 :   default:
    2810           0 :     llvm_unreachable("Unknown attribute spelling!");
    2811             :     return "(No spelling)";
    2812             :   case 0:
    2813             :     return "format_arg";
    2814             :   case 1:
    2815             :     return "format_arg";
    2816             :   }
    2817             : }
    2818             : 
    2819           3 : GNUInlineAttr *GNUInlineAttr::clone(ASTContext &C) const {
    2820          15 :   auto *A = new (C) GNUInlineAttr(getLocation(), C, getSpellingListIndex());
    2821           3 :   A->Inherited = Inherited;
    2822           3 :   A->IsPackExpansion = IsPackExpansion;
    2823           3 :   A->Implicit = Implicit;
    2824           3 :   return A;
    2825             : }
    2826             : 
    2827           2 : void GNUInlineAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    2828           2 :   switch (SpellingListIndex) {
    2829           0 :   default:
    2830           0 :     llvm_unreachable("Unknown attribute spelling!");
    2831             :     break;
    2832           1 :   case 0 : {
    2833           1 :     OS << " __attribute__((gnu_inline))";
    2834           1 :     break;
    2835             :   }
    2836           1 :   case 1 : {
    2837           1 :     OS << " [[gnu::gnu_inline]]";
    2838           1 :     break;
    2839             :   }
    2840             : }
    2841           2 : }
    2842             : 
    2843           0 : const char *GNUInlineAttr::getSpelling() const {
    2844           0 :   switch (SpellingListIndex) {
    2845           0 :   default:
    2846           0 :     llvm_unreachable("Unknown attribute spelling!");
    2847             :     return "(No spelling)";
    2848             :   case 0:
    2849             :     return "gnu_inline";
    2850             :   case 1:
    2851             :     return "gnu_inline";
    2852             :   }
    2853             : }
    2854             : 
    2855           0 : GuardedByAttr *GuardedByAttr::clone(ASTContext &C) const {
    2856           0 :   auto *A = new (C) GuardedByAttr(getLocation(), C, arg, getSpellingListIndex());
    2857           0 :   A->Inherited = Inherited;
    2858           0 :   A->IsPackExpansion = IsPackExpansion;
    2859           0 :   A->Implicit = Implicit;
    2860           0 :   return A;
    2861             : }
    2862             : 
    2863           0 : void GuardedByAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    2864           0 :   switch (SpellingListIndex) {
    2865           0 :   default:
    2866           0 :     llvm_unreachable("Unknown attribute spelling!");
    2867             :     break;
    2868           0 :   case 0 : {
    2869           0 :     OS << " __attribute__((guarded_by(" << getArg() << ")))";
    2870             :     break;
    2871             :   }
    2872             : }
    2873           0 : }
    2874             : 
    2875           0 : const char *GuardedByAttr::getSpelling() const {
    2876           0 :   switch (SpellingListIndex) {
    2877           0 :   default:
    2878           0 :     llvm_unreachable("Unknown attribute spelling!");
    2879             :     return "(No spelling)";
    2880           0 :   case 0:
    2881             :     return "guarded_by";
    2882             :   }
    2883             : }
    2884             : 
    2885           0 : GuardedVarAttr *GuardedVarAttr::clone(ASTContext &C) const {
    2886           0 :   auto *A = new (C) GuardedVarAttr(getLocation(), C, getSpellingListIndex());
    2887           0 :   A->Inherited = Inherited;
    2888           0 :   A->IsPackExpansion = IsPackExpansion;
    2889           0 :   A->Implicit = Implicit;
    2890           0 :   return A;
    2891             : }
    2892             : 
    2893           0 : void GuardedVarAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    2894           0 :   switch (SpellingListIndex) {
    2895           0 :   default:
    2896           0 :     llvm_unreachable("Unknown attribute spelling!");
    2897             :     break;
    2898           0 :   case 0 : {
    2899           0 :     OS << " __attribute__((guarded_var))";
    2900             :     break;
    2901             :   }
    2902             : }
    2903           0 : }
    2904             : 
    2905           0 : const char *GuardedVarAttr::getSpelling() const {
    2906           0 :   switch (SpellingListIndex) {
    2907           0 :   default:
    2908           0 :     llvm_unreachable("Unknown attribute spelling!");
    2909             :     return "(No spelling)";
    2910           0 :   case 0:
    2911             :     return "guarded_var";
    2912             :   }
    2913             : }
    2914             : 
    2915           0 : HotAttr *HotAttr::clone(ASTContext &C) const {
    2916           0 :   auto *A = new (C) HotAttr(getLocation(), C, getSpellingListIndex());
    2917           0 :   A->Inherited = Inherited;
    2918           0 :   A->IsPackExpansion = IsPackExpansion;
    2919           0 :   A->Implicit = Implicit;
    2920           0 :   return A;
    2921             : }
    2922             : 
    2923           0 : void HotAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    2924           0 :   switch (SpellingListIndex) {
    2925           0 :   default:
    2926           0 :     llvm_unreachable("Unknown attribute spelling!");
    2927             :     break;
    2928           0 :   case 0 : {
    2929           0 :     OS << " __attribute__((hot))";
    2930           0 :     break;
    2931             :   }
    2932           0 :   case 1 : {
    2933           0 :     OS << " [[gnu::hot]]";
    2934           0 :     break;
    2935             :   }
    2936             : }
    2937           0 : }
    2938             : 
    2939           1 : const char *HotAttr::getSpelling() const {
    2940           1 :   switch (SpellingListIndex) {
    2941           0 :   default:
    2942           0 :     llvm_unreachable("Unknown attribute spelling!");
    2943             :     return "(No spelling)";
    2944             :   case 0:
    2945             :     return "hot";
    2946             :   case 1:
    2947             :     return "hot";
    2948             :   }
    2949             : }
    2950             : 
    2951           0 : IBActionAttr *IBActionAttr::clone(ASTContext &C) const {
    2952           0 :   auto *A = new (C) IBActionAttr(getLocation(), C, getSpellingListIndex());
    2953           0 :   A->Inherited = Inherited;
    2954           0 :   A->IsPackExpansion = IsPackExpansion;
    2955           0 :   A->Implicit = Implicit;
    2956           0 :   return A;
    2957             : }
    2958             : 
    2959           0 : void IBActionAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    2960           0 :   switch (SpellingListIndex) {
    2961           0 :   default:
    2962           0 :     llvm_unreachable("Unknown attribute spelling!");
    2963             :     break;
    2964           0 :   case 0 : {
    2965           0 :     OS << " __attribute__((ibaction))";
    2966             :     break;
    2967             :   }
    2968             : }
    2969           0 : }
    2970             : 
    2971           0 : const char *IBActionAttr::getSpelling() const {
    2972           0 :   switch (SpellingListIndex) {
    2973           0 :   default:
    2974           0 :     llvm_unreachable("Unknown attribute spelling!");
    2975             :     return "(No spelling)";
    2976           0 :   case 0:
    2977             :     return "ibaction";
    2978             :   }
    2979             : }
    2980             : 
    2981           0 : IBOutletAttr *IBOutletAttr::clone(ASTContext &C) const {
    2982           0 :   auto *A = new (C) IBOutletAttr(getLocation(), C, getSpellingListIndex());
    2983           0 :   A->Inherited = Inherited;
    2984           0 :   A->IsPackExpansion = IsPackExpansion;
    2985           0 :   A->Implicit = Implicit;
    2986           0 :   return A;
    2987             : }
    2988             : 
    2989           0 : void IBOutletAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    2990           0 :   switch (SpellingListIndex) {
    2991           0 :   default:
    2992           0 :     llvm_unreachable("Unknown attribute spelling!");
    2993             :     break;
    2994           0 :   case 0 : {
    2995           0 :     OS << " __attribute__((iboutlet))";
    2996             :     break;
    2997             :   }
    2998             : }
    2999           0 : }
    3000             : 
    3001           0 : const char *IBOutletAttr::getSpelling() const {
    3002           0 :   switch (SpellingListIndex) {
    3003           0 :   default:
    3004           0 :     llvm_unreachable("Unknown attribute spelling!");
    3005             :     return "(No spelling)";
    3006           0 :   case 0:
    3007             :     return "iboutlet";
    3008             :   }
    3009             : }
    3010             : 
    3011           0 : IBOutletCollectionAttr *IBOutletCollectionAttr::clone(ASTContext &C) const {
    3012           0 :   auto *A = new (C) IBOutletCollectionAttr(getLocation(), C, interface_, getSpellingListIndex());
    3013           0 :   A->Inherited = Inherited;
    3014           0 :   A->IsPackExpansion = IsPackExpansion;
    3015           0 :   A->Implicit = Implicit;
    3016           0 :   return A;
    3017             : }
    3018             : 
    3019           0 : void IBOutletCollectionAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    3020           0 :   switch (SpellingListIndex) {
    3021           0 :   default:
    3022           0 :     llvm_unreachable("Unknown attribute spelling!");
    3023             :     break;
    3024           0 :   case 0 : {
    3025           0 :     OS << " __attribute__((iboutletcollection(" << getInterface().getAsString() << ")))";
    3026             :     break;
    3027             :   }
    3028             : }
    3029           0 : }
    3030             : 
    3031           0 : const char *IBOutletCollectionAttr::getSpelling() const {
    3032           0 :   switch (SpellingListIndex) {
    3033           0 :   default:
    3034           0 :     llvm_unreachable("Unknown attribute spelling!");
    3035             :     return "(No spelling)";
    3036           0 :   case 0:
    3037             :     return "iboutletcollection";
    3038             :   }
    3039             : }
    3040             : 
    3041           0 : IFuncAttr *IFuncAttr::clone(ASTContext &C) const {
    3042           0 :   auto *A = new (C) IFuncAttr(getLocation(), C, getResolver(), getSpellingListIndex());
    3043           0 :   A->Inherited = Inherited;
    3044           0 :   A->IsPackExpansion = IsPackExpansion;
    3045           0 :   A->Implicit = Implicit;
    3046           0 :   return A;
    3047             : }
    3048             : 
    3049           0 : void IFuncAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    3050           0 :   switch (SpellingListIndex) {
    3051           0 :   default:
    3052           0 :     llvm_unreachable("Unknown attribute spelling!");
    3053             :     break;
    3054           0 :   case 0 : {
    3055           0 :     OS << " __attribute__((ifunc(\"" << getResolver() << "\")))";
    3056           0 :     break;
    3057             :   }
    3058           0 :   case 1 : {
    3059           0 :     OS << " [[gnu::ifunc(\"" << getResolver() << "\")]]";
    3060           0 :     break;
    3061             :   }
    3062             : }
    3063           0 : }
    3064             : 
    3065           0 : const char *IFuncAttr::getSpelling() const {
    3066           0 :   switch (SpellingListIndex) {
    3067           0 :   default:
    3068           0 :     llvm_unreachable("Unknown attribute spelling!");
    3069             :     return "(No spelling)";
    3070             :   case 0:
    3071             :     return "ifunc";
    3072             :   case 1:
    3073             :     return "ifunc";
    3074             :   }
    3075             : }
    3076             : 
    3077           0 : InitPriorityAttr *InitPriorityAttr::clone(ASTContext &C) const {
    3078           0 :   auto *A = new (C) InitPriorityAttr(getLocation(), C, priority, getSpellingListIndex());
    3079           0 :   A->Inherited = Inherited;
    3080           0 :   A->IsPackExpansion = IsPackExpansion;
    3081           0 :   A->Implicit = Implicit;
    3082           0 :   return A;
    3083             : }
    3084             : 
    3085           0 : void InitPriorityAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    3086           0 :   switch (SpellingListIndex) {
    3087           0 :   default:
    3088           0 :     llvm_unreachable("Unknown attribute spelling!");
    3089             :     break;
    3090           0 :   case 0 : {
    3091           0 :     OS << " __attribute__((init_priority(" << getPriority() << ")))";
    3092             :     break;
    3093             :   }
    3094             : }
    3095           0 : }
    3096             : 
    3097           0 : const char *InitPriorityAttr::getSpelling() const {
    3098           0 :   switch (SpellingListIndex) {
    3099           0 :   default:
    3100           0 :     llvm_unreachable("Unknown attribute spelling!");
    3101             :     return "(No spelling)";
    3102           0 :   case 0:
    3103             :     return "init_priority";
    3104             :   }
    3105             : }
    3106             : 
    3107           2 : InitSegAttr *InitSegAttr::clone(ASTContext &C) const {
    3108          12 :   auto *A = new (C) InitSegAttr(getLocation(), C, getSection(), getSpellingListIndex());
    3109           2 :   A->Inherited = Inherited;
    3110           2 :   A->IsPackExpansion = IsPackExpansion;
    3111           2 :   A->Implicit = Implicit;
    3112           2 :   return A;
    3113             : }
    3114             : 
    3115           1 : void InitSegAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    3116           1 :   switch (SpellingListIndex) {
    3117           0 :   default:
    3118           0 :     llvm_unreachable("Unknown attribute spelling!");
    3119             :     break;
    3120           1 :   case 0 : {
    3121           1 :     OS << "#pragma init_seg ";
    3122           1 :     printPrettyPragma(OS, Policy);
    3123           1 :     OS << "\n";    break;
    3124             :   }
    3125             : }
    3126           1 : }
    3127             : 
    3128           0 : const char *InitSegAttr::getSpelling() const {
    3129           0 :   switch (SpellingListIndex) {
    3130           0 :   default:
    3131           0 :     llvm_unreachable("Unknown attribute spelling!");
    3132             :     return "(No spelling)";
    3133           0 :   case 0:
    3134             :     return "init_seg";
    3135             :   }
    3136             : }
    3137             : 
    3138           0 : IntelOclBiccAttr *IntelOclBiccAttr::clone(ASTContext &C) const {
    3139           0 :   auto *A = new (C) IntelOclBiccAttr(getLocation(), C, getSpellingListIndex());
    3140           0 :   A->Inherited = Inherited;
    3141           0 :   A->IsPackExpansion = IsPackExpansion;
    3142           0 :   A->Implicit = Implicit;
    3143           0 :   return A;
    3144             : }
    3145             : 
    3146           0 : void IntelOclBiccAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    3147           0 :   switch (SpellingListIndex) {
    3148           0 :   default:
    3149           0 :     llvm_unreachable("Unknown attribute spelling!");
    3150             :     break;
    3151           0 :   case 0 : {
    3152           0 :     OS << " __attribute__((intel_ocl_bicc))";
    3153             :     break;
    3154             :   }
    3155             : }
    3156           0 : }
    3157             : 
    3158           0 : const char *IntelOclBiccAttr::getSpelling() const {
    3159           0 :   switch (SpellingListIndex) {
    3160           0 :   default:
    3161           0 :     llvm_unreachable("Unknown attribute spelling!");
    3162             :     return "(No spelling)";
    3163           0 :   case 0:
    3164             :     return "intel_ocl_bicc";
    3165             :   }
    3166             : }
    3167             : 
    3168           0 : InternalLinkageAttr *InternalLinkageAttr::clone(ASTContext &C) const {
    3169           0 :   auto *A = new (C) InternalLinkageAttr(getLocation(), C, getSpellingListIndex());
    3170           0 :   A->Inherited = Inherited;
    3171           0 :   A->IsPackExpansion = IsPackExpansion;
    3172           0 :   A->Implicit = Implicit;
    3173           0 :   return A;
    3174             : }
    3175             : 
    3176           0 : void InternalLinkageAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    3177           0 :   switch (SpellingListIndex) {
    3178           0 :   default:
    3179           0 :     llvm_unreachable("Unknown attribute spelling!");
    3180             :     break;
    3181           0 :   case 0 : {
    3182           0 :     OS << " __attribute__((internal_linkage))";
    3183           0 :     break;
    3184             :   }
    3185           0 :   case 1 : {
    3186           0 :     OS << " [[clang::internal_linkage]]";
    3187           0 :     break;
    3188             :   }
    3189             : }
    3190           0 : }
    3191             : 
    3192          10 : const char *InternalLinkageAttr::getSpelling() const {
    3193          10 :   switch (SpellingListIndex) {
    3194           0 :   default:
    3195           0 :     llvm_unreachable("Unknown attribute spelling!");
    3196             :     return "(No spelling)";
    3197             :   case 0:
    3198             :     return "internal_linkage";
    3199             :   case 1:
    3200             :     return "internal_linkage";
    3201             :   }
    3202             : }
    3203             : 
    3204           0 : LTOVisibilityPublicAttr *LTOVisibilityPublicAttr::clone(ASTContext &C) const {
    3205           0 :   auto *A = new (C) LTOVisibilityPublicAttr(getLocation(), C, getSpellingListIndex());
    3206           0 :   A->Inherited = Inherited;
    3207           0 :   A->IsPackExpansion = IsPackExpansion;
    3208           0 :   A->Implicit = Implicit;
    3209           0 :   return A;
    3210             : }
    3211             : 
    3212           0 : void LTOVisibilityPublicAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    3213           0 :   switch (SpellingListIndex) {
    3214           0 :   default:
    3215           0 :     llvm_unreachable("Unknown attribute spelling!");
    3216             :     break;
    3217           0 :   case 0 : {
    3218           0 :     OS << " [[clang::lto_visibility_public]]";
    3219             :     break;
    3220             :   }
    3221             : }
    3222           0 : }
    3223             : 
    3224           0 : const char *LTOVisibilityPublicAttr::getSpelling() const {
    3225           0 :   switch (SpellingListIndex) {
    3226           0 :   default:
    3227           0 :     llvm_unreachable("Unknown attribute spelling!");
    3228             :     return "(No spelling)";
    3229           0 :   case 0:
    3230             :     return "lto_visibility_public";
    3231             :   }
    3232             : }
    3233             : 
    3234           0 : LayoutVersionAttr *LayoutVersionAttr::clone(ASTContext &C) const {
    3235           0 :   auto *A = new (C) LayoutVersionAttr(getLocation(), C, version, getSpellingListIndex());
    3236           0 :   A->Inherited = Inherited;
    3237           0 :   A->IsPackExpansion = IsPackExpansion;
    3238           0 :   A->Implicit = Implicit;
    3239           0 :   return A;
    3240             : }
    3241             : 
    3242           0 : void LayoutVersionAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    3243           0 :   switch (SpellingListIndex) {
    3244           0 :   default:
    3245           0 :     llvm_unreachable("Unknown attribute spelling!");
    3246             :     break;
    3247           0 :   case 0 : {
    3248           0 :     OS << " __declspec(layout_version(" << getVersion() << "))";
    3249             :     break;
    3250             :   }
    3251             : }
    3252           0 : }
    3253             : 
    3254           0 : const char *LayoutVersionAttr::getSpelling() const {
    3255           0 :   switch (SpellingListIndex) {
    3256           0 :   default:
    3257           0 :     llvm_unreachable("Unknown attribute spelling!");
    3258             :     return "(No spelling)";
    3259           0 :   case 0:
    3260             :     return "layout_version";
    3261             :   }
    3262             : }
    3263             : 
    3264           3 : LockReturnedAttr *LockReturnedAttr::clone(ASTContext &C) const {
    3265          15 :   auto *A = new (C) LockReturnedAttr(getLocation(), C, arg, getSpellingListIndex());
    3266           3 :   A->Inherited = Inherited;
    3267           3 :   A->IsPackExpansion = IsPackExpansion;
    3268           3 :   A->Implicit = Implicit;
    3269           3 :   return A;
    3270             : }
    3271             : 
    3272           0 : void LockReturnedAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    3273           0 :   switch (SpellingListIndex) {
    3274           0 :   default:
    3275           0 :     llvm_unreachable("Unknown attribute spelling!");
    3276             :     break;
    3277           0 :   case 0 : {
    3278           0 :     OS << " __attribute__((lock_returned(" << getArg() << ")))";
    3279             :     break;
    3280             :   }
    3281             : }
    3282           0 : }
    3283             : 
    3284           0 : const char *LockReturnedAttr::getSpelling() const {
    3285           0 :   switch (SpellingListIndex) {
    3286           0 :   default:
    3287           0 :     llvm_unreachable("Unknown attribute spelling!");
    3288             :     return "(No spelling)";
    3289           0 :   case 0:
    3290             :     return "lock_returned";
    3291             :   }
    3292             : }
    3293             : 
    3294          11 : LocksExcludedAttr *LocksExcludedAttr::clone(ASTContext &C) const {
    3295          55 :   auto *A = new (C) LocksExcludedAttr(getLocation(), C, args_, args_Size, getSpellingListIndex());
    3296          11 :   A->Inherited = Inherited;
    3297          11 :   A->IsPackExpansion = IsPackExpansion;
    3298          11 :   A->Implicit = Implicit;
    3299          11 :   return A;
    3300             : }
    3301             : 
    3302           0 : void LocksExcludedAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    3303           0 :   switch (SpellingListIndex) {
    3304           0 :   default:
    3305           0 :     llvm_unreachable("Unknown attribute spelling!");
    3306             :     break;
    3307           0 :   case 0 : {
    3308           0 :     OS << " __attribute__((locks_excluded(";
    3309           0 :   bool isFirst = true;
    3310           0 :   for (const auto &Val : args()) {
    3311           0 :     if (isFirst) isFirst = false;
    3312           0 :     else OS << ", ";
    3313           0 :     OS << Val;
    3314             :   }
    3315           0 :   OS << ")))";
    3316             :     break;
    3317             :   }
    3318             : }
    3319           0 : }
    3320             : 
    3321           0 : const char *LocksExcludedAttr::getSpelling() const {
    3322           0 :   switch (SpellingListIndex) {
    3323           0 :   default:
    3324           0 :     llvm_unreachable("Unknown attribute spelling!");
    3325             :     return "(No spelling)";
    3326           0 :   case 0:
    3327             :     return "locks_excluded";
    3328             :   }
    3329             : }
    3330             : 
    3331           0 : LoopHintAttr *LoopHintAttr::clone(ASTContext &C) const {
    3332           0 :   auto *A = new (C) LoopHintAttr(getLocation(), C, option, state, value, getSpellingListIndex());
    3333           0 :   A->Inherited = Inherited;
    3334           0 :   A->IsPackExpansion = IsPackExpansion;
    3335           0 :   A->Implicit = Implicit;
    3336           0 :   return A;
    3337             : }
    3338             : 
    3339          42 : void LoopHintAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    3340          42 :   switch (SpellingListIndex) {
    3341           0 :   default:
    3342           0 :     llvm_unreachable("Unknown attribute spelling!");
    3343             :     break;
    3344          39 :   case 0 : {
    3345          39 :     OS << "#pragma clang loop ";
    3346          39 :     printPrettyPragma(OS, Policy);
    3347          39 :     OS << "\n";    break;
    3348             :   }
    3349           2 :   case 1 : {
    3350           2 :     OS << "#pragma unroll ";
    3351           2 :     printPrettyPragma(OS, Policy);
    3352           2 :     OS << "\n";    break;
    3353             :   }
    3354           1 :   case 2 : {
    3355           1 :     OS << "#pragma nounroll ";
    3356           1 :     printPrettyPragma(OS, Policy);
    3357           1 :     OS << "\n";    break;
    3358             :   }
    3359             : }
    3360          42 : }
    3361             : 
    3362           0 : const char *LoopHintAttr::getSpelling() const {
    3363           0 :   switch (SpellingListIndex) {
    3364           0 :   default:
    3365           0 :     llvm_unreachable("Unknown attribute spelling!");
    3366             :     return "(No spelling)";
    3367             :   case 0:
    3368             :     return "loop";
    3369           0 :   case 1:
    3370           0 :     return "unroll";
    3371           0 :   case 2:
    3372           0 :     return "nounroll";
    3373             :   }
    3374             : }
    3375             : 
    3376           0 : MSABIAttr *MSABIAttr::clone(ASTContext &C) const {
    3377           0 :   auto *A = new (C) MSABIAttr(getLocation(), C, getSpellingListIndex());
    3378           0 :   A->Inherited = Inherited;
    3379           0 :   A->IsPackExpansion = IsPackExpansion;
    3380           0 :   A->Implicit = Implicit;
    3381           0 :   return A;
    3382             : }
    3383             : 
    3384           0 : void MSABIAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    3385           0 :   switch (SpellingListIndex) {
    3386           0 :   default:
    3387           0 :     llvm_unreachable("Unknown attribute spelling!");
    3388             :     break;
    3389           0 :   case 0 : {
    3390           0 :     OS << " __attribute__((ms_abi))";
    3391           0 :     break;
    3392             :   }
    3393           0 :   case 1 : {
    3394           0 :     OS << " [[gnu::ms_abi]]";
    3395           0 :     break;
    3396             :   }
    3397             : }
    3398           0 : }
    3399             : 
    3400           0 : const char *MSABIAttr::getSpelling() const {
    3401           0 :   switch (SpellingListIndex) {
    3402           0 :   default:
    3403           0 :     llvm_unreachable("Unknown attribute spelling!");
    3404             :     return "(No spelling)";
    3405             :   case 0:
    3406             :     return "ms_abi";
    3407             :   case 1:
    3408             :     return "ms_abi";
    3409             :   }
    3410             : }
    3411             : 
    3412           0 : MSInheritanceAttr *MSInheritanceAttr::clone(ASTContext &C) const {
    3413           0 :   auto *A = new (C) MSInheritanceAttr(getLocation(), C, bestCase, getSpellingListIndex());
    3414           0 :   A->Inherited = Inherited;
    3415           0 :   A->IsPackExpansion = IsPackExpansion;
    3416           0 :   A->Implicit = Implicit;
    3417           0 :   return A;
    3418             : }
    3419             : 
    3420           0 : void MSInheritanceAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    3421           0 :   switch (SpellingListIndex) {
    3422           0 :   default:
    3423           0 :     llvm_unreachable("Unknown attribute spelling!");
    3424             :     break;
    3425           0 :   case 0 : {
    3426           0 :     OS << " __single_inheritance(" << getBestCase() << ")";
    3427           0 :     break;
    3428             :   }
    3429           0 :   case 1 : {
    3430           0 :     OS << " __multiple_inheritance(" << getBestCase() << ")";
    3431           0 :     break;
    3432             :   }
    3433           0 :   case 2 : {
    3434           0 :     OS << " __virtual_inheritance(" << getBestCase() << ")";
    3435           0 :     break;
    3436             :   }
    3437           0 :   case 3 : {
    3438           0 :     OS << " __unspecified_inheritance(" << getBestCase() << ")";
    3439           0 :     break;
    3440             :   }
    3441             : }
    3442           0 : }
    3443             : 
    3444           0 : const char *MSInheritanceAttr::getSpelling() const {
    3445           0 :   switch (SpellingListIndex) {
    3446           0 :   default:
    3447           0 :     llvm_unreachable("Unknown attribute spelling!");
    3448             :     return "(No spelling)";
    3449             :   case 0:
    3450             :     return "__single_inheritance";
    3451           0 :   case 1:
    3452           0 :     return "__multiple_inheritance";
    3453           0 :   case 2:
    3454           0 :     return "__virtual_inheritance";
    3455           0 :   case 3:
    3456           0 :     return "__unspecified_inheritance";
    3457             :   }
    3458             : }
    3459             : 
    3460           0 : MSNoVTableAttr *MSNoVTableAttr::clone(ASTContext &C) const {
    3461           0 :   auto *A = new (C) MSNoVTableAttr(getLocation(), C, getSpellingListIndex());
    3462           0 :   A->Inherited = Inherited;
    3463           0 :   A->IsPackExpansion = IsPackExpansion;
    3464           0 :   A->Implicit = Implicit;
    3465           0 :   return A;
    3466             : }
    3467             : 
    3468           0 : void MSNoVTableAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    3469           0 :   switch (SpellingListIndex) {
    3470           0 :   default:
    3471           0 :     llvm_unreachable("Unknown attribute spelling!");
    3472             :     break;
    3473           0 :   case 0 : {
    3474           0 :     OS << " __declspec(novtable)";
    3475             :     break;
    3476             :   }
    3477             : }
    3478           0 : }
    3479             : 
    3480           0 : const char *MSNoVTableAttr::getSpelling() const {
    3481           0 :   switch (SpellingListIndex) {
    3482           0 :   default:
    3483           0 :     llvm_unreachable("Unknown attribute spelling!");
    3484             :     return "(No spelling)";
    3485           0 :   case 0:
    3486             :     return "novtable";
    3487             :   }
    3488             : }
    3489             : 
    3490           0 : MSP430InterruptAttr *MSP430InterruptAttr::clone(ASTContext &C) const {
    3491           0 :   auto *A = new (C) MSP430InterruptAttr(getLocation(), C, number, getSpellingListIndex());
    3492           0 :   A->Inherited = Inherited;
    3493           0 :   A->IsPackExpansion = IsPackExpansion;
    3494           0 :   A->Implicit = Implicit;
    3495           0 :   return A;
    3496             : }
    3497             : 
    3498           0 : void MSP430InterruptAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    3499           0 :   switch (SpellingListIndex) {
    3500           0 :   default:
    3501           0 :     llvm_unreachable("Unknown attribute spelling!");
    3502             :     break;
    3503           0 :   case 0 : {
    3504           0 :     OS << " __attribute__((interrupt(" << getNumber() << ")))";
    3505             :     break;
    3506             :   }
    3507             : }
    3508           0 : }
    3509             : 
    3510           0 : const char *MSP430InterruptAttr::getSpelling() const {
    3511           0 :   switch (SpellingListIndex) {
    3512           0 :   default:
    3513           0 :     llvm_unreachable("Unknown attribute spelling!");
    3514             :     return "(No spelling)";
    3515           0 :   case 0:
    3516             :     return "interrupt";
    3517             :   }
    3518             : }
    3519             : 
    3520           1 : MSStructAttr *MSStructAttr::clone(ASTContext &C) const {
    3521           5 :   auto *A = new (C) MSStructAttr(getLocation(), C, getSpellingListIndex());
    3522           1 :   A->Inherited = Inherited;
    3523           1 :   A->IsPackExpansion = IsPackExpansion;
    3524           1 :   A->Implicit = Implicit;
    3525           1 :   return A;
    3526             : }
    3527             : 
    3528           0 : void MSStructAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    3529           0 :   switch (SpellingListIndex) {
    3530           0 :   default:
    3531           0 :     llvm_unreachable("Unknown attribute spelling!");
    3532             :     break;
    3533           0 :   case 0 : {
    3534           0 :     OS << " __attribute__((ms_struct))";
    3535           0 :     break;
    3536             :   }
    3537           0 :   case 1 : {
    3538           0 :     OS << " [[gnu::ms_struct]]";
    3539           0 :     break;
    3540             :   }
    3541             : }
    3542           0 : }
    3543             : 
    3544           0 : const char *MSStructAttr::getSpelling() const {
    3545           0 :   switch (SpellingListIndex) {
    3546           0 :   default:
    3547           0 :     llvm_unreachable("Unknown attribute spelling!");
    3548             :     return "(No spelling)";
    3549             :   case 0:
    3550             :     return "ms_struct";
    3551             :   case 1:
    3552             :     return "ms_struct";
    3553             :   }
    3554             : }
    3555             : 
    3556           2 : MSVtorDispAttr *MSVtorDispAttr::clone(ASTContext &C) const {
    3557          10 :   auto *A = new (C) MSVtorDispAttr(getLocation(), C, vdm, getSpellingListIndex());
    3558           2 :   A->Inherited = Inherited;
    3559           2 :   A->IsPackExpansion = IsPackExpansion;
    3560           2 :   A->Implicit = Implicit;
    3561           2 :   return A;
    3562             : }
    3563             : 
    3564           0 : void MSVtorDispAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    3565           0 : }
    3566             : 
    3567           0 : const char *MSVtorDispAttr::getSpelling() const {
    3568           0 :   return "(No spelling)";
    3569             : }
    3570             : 
    3571           1 : MaxFieldAlignmentAttr *MaxFieldAlignmentAttr::clone(ASTContext &C) const {
    3572           5 :   auto *A = new (C) MaxFieldAlignmentAttr(getLocation(), C, alignment, getSpellingListIndex());
    3573           1 :   A->Inherited = Inherited;
    3574           1 :   A->IsPackExpansion = IsPackExpansion;
    3575           1 :   A->Implicit = Implicit;
    3576           1 :   return A;
    3577             : }
    3578             : 
    3579           0 : void MaxFieldAlignmentAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    3580           0 : }
    3581             : 
    3582           0 : const char *MaxFieldAlignmentAttr::getSpelling() const {
    3583           0 :   return "(No spelling)";
    3584             : }
    3585             : 
    3586           0 : MayAliasAttr *MayAliasAttr::clone(ASTContext &C) const {
    3587           0 :   auto *A = new (C) MayAliasAttr(getLocation(), C, getSpellingListIndex());
    3588           0 :   A->Inherited = Inherited;
    3589           0 :   A->IsPackExpansion = IsPackExpansion;
    3590           0 :   A->Implicit = Implicit;
    3591           0 :   return A;
    3592             : }
    3593             : 
    3594           0 : void MayAliasAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    3595           0 :   switch (SpellingListIndex) {
    3596           0 :   default:
    3597           0 :     llvm_unreachable("Unknown attribute spelling!");
    3598             :     break;
    3599           0 :   case 0 : {
    3600           0 :     OS << " __attribute__((may_alias))";
    3601           0 :     break;
    3602             :   }
    3603           0 :   case 1 : {
    3604           0 :     OS << " [[gnu::may_alias]]";
    3605           0 :     break;
    3606             :   }
    3607             : }
    3608           0 : }
    3609             : 
    3610           0 : const char *MayAliasAttr::getSpelling() const {
    3611           0 :   switch (SpellingListIndex) {
    3612           0 :   default:
    3613           0 :     llvm_unreachable("Unknown attribute spelling!");
    3614             :     return "(No spelling)";
    3615             :   case 0:
    3616             :     return "may_alias";
    3617             :   case 1:
    3618             :     return "may_alias";
    3619             :   }
    3620             : }
    3621             : 
    3622           0 : MicroMipsAttr *MicroMipsAttr::clone(ASTContext &C) const {
    3623           0 :   auto *A = new (C) MicroMipsAttr(getLocation(), C, getSpellingListIndex());
    3624           0 :   A->Inherited = Inherited;
    3625           0 :   A->IsPackExpansion = IsPackExpansion;
    3626           0 :   A->Implicit = Implicit;
    3627           0 :   return A;
    3628             : }
    3629             : 
    3630           0 : void MicroMipsAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    3631           0 :   switch (SpellingListIndex) {
    3632           0 :   default:
    3633           0 :     llvm_unreachable("Unknown attribute spelling!");
    3634             :     break;
    3635           0 :   case 0 : {
    3636           0 :     OS << " __attribute__((micromips))";
    3637           0 :     break;
    3638             :   }
    3639           0 :   case 1 : {
    3640           0 :     OS << " [[gnu::micromips]]";
    3641           0 :     break;
    3642             :   }
    3643             : }
    3644           0 : }
    3645             : 
    3646           1 : const char *MicroMipsAttr::getSpelling() const {
    3647           1 :   switch (SpellingListIndex) {
    3648           0 :   default:
    3649           0 :     llvm_unreachable("Unknown attribute spelling!");
    3650             :     return "(No spelling)";
    3651             :   case 0:
    3652             :     return "micromips";
    3653             :   case 1:
    3654             :     return "micromips";
    3655             :   }
    3656             : }
    3657             : 
    3658          12 : MinSizeAttr *MinSizeAttr::clone(ASTContext &C) const {
    3659          60 :   auto *A = new (C) MinSizeAttr(getLocation(), C, getSpellingListIndex());
    3660          12 :   A->Inherited = Inherited;
    3661          12 :   A->IsPackExpansion = IsPackExpansion;
    3662          12 :   A->Implicit = Implicit;
    3663          12 :   return A;
    3664             : }
    3665             : 
    3666           0 : void MinSizeAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    3667           0 :   switch (SpellingListIndex) {
    3668           0 :   default:
    3669           0 :     llvm_unreachable("Unknown attribute spelling!");
    3670             :     break;
    3671           0 :   case 0 : {
    3672           0 :     OS << " __attribute__((minsize))";
    3673             :     break;
    3674             :   }
    3675             : }
    3676           0 : }
    3677             : 
    3678           3 : const char *MinSizeAttr::getSpelling() const {
    3679           3 :   switch (SpellingListIndex) {
    3680           0 :   default:
    3681           0 :     llvm_unreachable("Unknown attribute spelling!");
    3682             :     return "(No spelling)";
    3683           3 :   case 0:
    3684             :     return "minsize";
    3685             :   }
    3686             : }
    3687             : 
    3688           1 : Mips16Attr *Mips16Attr::clone(ASTContext &C) const {
    3689           5 :   auto *A = new (C) Mips16Attr(getLocation(), C, getSpellingListIndex());
    3690           1 :   A->Inherited = Inherited;
    3691           1 :   A->IsPackExpansion = IsPackExpansion;
    3692           1 :   A->Implicit = Implicit;
    3693           1 :   return A;
    3694             : }
    3695             : 
    3696           0 : void Mips16Attr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    3697           0 :   switch (SpellingListIndex) {
    3698           0 :   default:
    3699           0 :     llvm_unreachable("Unknown attribute spelling!");
    3700             :     break;
    3701           0 :   case 0 : {
    3702           0 :     OS << " __attribute__((mips16))";
    3703           0 :     break;
    3704             :   }
    3705           0 :   case 1 : {
    3706           0 :     OS << " [[gnu::mips16]]";
    3707           0 :     break;
    3708             :   }
    3709             : }
    3710           0 : }
    3711             : 
    3712           4 : const char *Mips16Attr::getSpelling() const {
    3713           4 :   switch (SpellingListIndex) {
    3714           0 :   default:
    3715           0 :     llvm_unreachable("Unknown attribute spelling!");
    3716             :     return "(No spelling)";
    3717             :   case 0:
    3718             :     return "mips16";
    3719             :   case 1:
    3720             :     return "mips16";
    3721             :   }
    3722             : }
    3723             : 
    3724           0 : MipsInterruptAttr *MipsInterruptAttr::clone(ASTContext &C) const {
    3725           0 :   auto *A = new (C) MipsInterruptAttr(getLocation(), C, interrupt, getSpellingListIndex());
    3726           0 :   A->Inherited = Inherited;
    3727           0 :   A->IsPackExpansion = IsPackExpansion;
    3728           0 :   A->Implicit = Implicit;
    3729           0 :   return A;
    3730             : }
    3731             : 
    3732           0 : void MipsInterruptAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    3733           0 :   switch (SpellingListIndex) {
    3734           0 :   default:
    3735           0 :     llvm_unreachable("Unknown attribute spelling!");
    3736             :     break;
    3737           0 :   case 0 : {
    3738           0 :     OS << " __attribute__((interrupt(\"" << MipsInterruptAttr::ConvertInterruptTypeToStr(getInterrupt()) << "\")))";
    3739             :     break;
    3740             :   }
    3741             : }
    3742           0 : }
    3743             : 
    3744           2 : const char *MipsInterruptAttr::getSpelling() const {
    3745           2 :   switch (SpellingListIndex) {
    3746           0 :   default:
    3747           0 :     llvm_unreachable("Unknown attribute spelling!");
    3748             :     return "(No spelling)";
    3749           2 :   case 0:
    3750             :     return "interrupt";
    3751             :   }
    3752             : }
    3753             : 
    3754           0 : MipsLongCallAttr *MipsLongCallAttr::clone(ASTContext &C) const {
    3755           0 :   auto *A = new (C) MipsLongCallAttr(getLocation(), C, getSpellingListIndex());
    3756           0 :   A->Inherited = Inherited;
    3757           0 :   A->IsPackExpansion = IsPackExpansion;
    3758           0 :   A->Implicit = Implicit;
    3759           0 :   return A;
    3760             : }
    3761             : 
    3762           0 : void MipsLongCallAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    3763           0 :   switch (SpellingListIndex) {
    3764           0 :   default:
    3765           0 :     llvm_unreachable("Unknown attribute spelling!");
    3766             :     break;
    3767           0 :   case 0 : {
    3768           0 :     OS << " __attribute__((long_call))";
    3769           0 :     break;
    3770             :   }
    3771           0 :   case 1 : {
    3772           0 :     OS << " [[gnu::long_call]]";
    3773           0 :     break;
    3774             :   }
    3775           0 :   case 2 : {
    3776           0 :     OS << " __attribute__((far))";
    3777           0 :     break;
    3778             :   }
    3779           0 :   case 3 : {
    3780           0 :     OS << " [[gnu::far]]";
    3781           0 :     break;
    3782             :   }
    3783             : }
    3784           0 : }
    3785             : 
    3786           2 : const char *MipsLongCallAttr::getSpelling() const {
    3787           2 :   switch (SpellingListIndex) {
    3788           0 :   default:
    3789           0 :     llvm_unreachable("Unknown attribute spelling!");
    3790             :     return "(No spelling)";
    3791             :   case 0:
    3792             :     return "long_call";
    3793             :   case 1:
    3794             :     return "long_call";
    3795           0 :   case 2:
    3796           0 :     return "far";
    3797           0 :   case 3:
    3798           0 :     return "far";
    3799             :   }
    3800             : }
    3801             : 
    3802           0 : MipsShortCallAttr *MipsShortCallAttr::clone(ASTContext &C) const {
    3803           0 :   auto *A = new (C) MipsShortCallAttr(getLocation(), C, getSpellingListIndex());
    3804           0 :   A->Inherited = Inherited;
    3805           0 :   A->IsPackExpansion = IsPackExpansion;
    3806           0 :   A->Implicit = Implicit;
    3807           0 :   return A;
    3808             : }
    3809             : 
    3810           0 : void MipsShortCallAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    3811           0 :   switch (SpellingListIndex) {
    3812           0 :   default:
    3813           0 :     llvm_unreachable("Unknown attribute spelling!");
    3814             :     break;
    3815           0 :   case 0 : {
    3816           0 :     OS << " __attribute__((short_call))";
    3817           0 :     break;
    3818             :   }
    3819           0 :   case 1 : {
    3820           0 :     OS << " [[gnu::short_call]]";
    3821           0 :     break;
    3822             :   }
    3823           0 :   case 2 : {
    3824           0 :     OS << " __attribute__((near))";
    3825           0 :     break;
    3826             :   }
    3827           0 :   case 3 : {
    3828           0 :     OS << " [[gnu::near]]";
    3829           0 :     break;
    3830             :   }
    3831             : }
    3832           0 : }
    3833             : 
    3834           2 : const char *MipsShortCallAttr::getSpelling() const {
    3835           2 :   switch (SpellingListIndex) {
    3836           0 :   default:
    3837           0 :     llvm_unreachable("Unknown attribute spelling!");
    3838             :     return "(No spelling)";
    3839             :   case 0:
    3840             :     return "short_call";
    3841             :   case 1:
    3842             :     return "short_call";
    3843           2 :   case 2:
    3844           2 :     return "near";
    3845           0 :   case 3:
    3846           0 :     return "near";
    3847             :   }
    3848             : }
    3849             : 
    3850           0 : ModeAttr *ModeAttr::clone(ASTContext &C) const {
    3851           0 :   auto *A = new (C) ModeAttr(getLocation(), C, mode, getSpellingListIndex());
    3852           0 :   A->Inherited = Inherited;
    3853           0 :   A->IsPackExpansion = IsPackExpansion;
    3854           0 :   A->Implicit = Implicit;
    3855           0 :   return A;
    3856             : }
    3857             : 
    3858           3 : void ModeAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    3859           3 :   switch (SpellingListIndex) {
    3860           0 :   default:
    3861           0 :     llvm_unreachable("Unknown attribute spelling!");
    3862             :     break;
    3863           2 :   case 0 : {
    3864           2 :     OS << " __attribute__((mode(";
    3865           4 :     OS << getMode()->getName();
    3866           2 :     OS << ")))";
    3867           2 :     break;
    3868             :   }
    3869           1 :   case 1 : {
    3870           1 :     OS << " [[gnu::mode(";
    3871           2 :     OS << getMode()->getName();
    3872           1 :     OS << ")]]";
    3873           1 :     break;
    3874             :   }
    3875             : }
    3876           3 : }
    3877             : 
    3878           0 : const char *ModeAttr::getSpelling() const {
    3879           0 :   switch (SpellingListIndex) {
    3880           0 :   default:
    3881           0 :     llvm_unreachable("Unknown attribute spelling!");
    3882             :     return "(No spelling)";
    3883             :   case 0:
    3884             :     return "mode";
    3885             :   case 1:
    3886             :     return "mode";
    3887             :   }
    3888             : }
    3889             : 
    3890           6 : NSConsumedAttr *NSConsumedAttr::clone(ASTContext &C) const {
    3891          30 :   auto *A = new (C) NSConsumedAttr(getLocation(), C, getSpellingListIndex());
    3892           6 :   A->Inherited = Inherited;
    3893           6 :   A->IsPackExpansion = IsPackExpansion;
    3894           6 :   A->Implicit = Implicit;
    3895           6 :   return A;
    3896             : }
    3897             : 
    3898           0 : void NSConsumedAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    3899           0 :   switch (SpellingListIndex) {
    3900           0 :   default:
    3901           0 :     llvm_unreachable("Unknown attribute spelling!");
    3902             :     break;
    3903           0 :   case 0 : {
    3904           0 :     OS << " __attribute__((ns_consumed))";
    3905             :     break;
    3906             :   }
    3907             : }
    3908           0 : }
    3909             : 
    3910           0 : const char *NSConsumedAttr::getSpelling() const {
    3911           0 :   switch (SpellingListIndex) {
    3912           0 :   default:
    3913           0 :     llvm_unreachable("Unknown attribute spelling!");
    3914             :     return "(No spelling)";
    3915           0 :   case 0:
    3916             :     return "ns_consumed";
    3917             :   }
    3918             : }
    3919             : 
    3920         137 : NSConsumesSelfAttr *NSConsumesSelfAttr::clone(ASTContext &C) const {
    3921         685 :   auto *A = new (C) NSConsumesSelfAttr(getLocation(), C, getSpellingListIndex());
    3922         137 :   A->Inherited = Inherited;
    3923         137 :   A->IsPackExpansion = IsPackExpansion;
    3924         137 :   A->Implicit = Implicit;
    3925         137 :   return A;
    3926             : }
    3927             : 
    3928           0 : void NSConsumesSelfAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    3929           0 :   switch (SpellingListIndex) {
    3930           0 :   default:
    3931           0 :     llvm_unreachable("Unknown attribute spelling!");
    3932             :     break;
    3933           0 :   case 0 : {
    3934           0 :     OS << " __attribute__((ns_consumes_self))";
    3935             :     break;
    3936             :   }
    3937             : }
    3938           0 : }
    3939             : 
    3940           0 : const char *NSConsumesSelfAttr::getSpelling() const {
    3941           0 :   switch (SpellingListIndex) {
    3942           0 :   default:
    3943           0 :     llvm_unreachable("Unknown attribute spelling!");
    3944             :     return "(No spelling)";
    3945           0 :   case 0:
    3946             :     return "ns_consumes_self";
    3947             :   }
    3948             : }
    3949             : 
    3950           0 : NSReturnsAutoreleasedAttr *NSReturnsAutoreleasedAttr::clone(ASTContext &C) const {
    3951           0 :   auto *A = new (C) NSReturnsAutoreleasedAttr(getLocation(), C, getSpellingListIndex());
    3952           0 :   A->Inherited = Inherited;
    3953           0 :   A->IsPackExpansion = IsPackExpansion;
    3954           0 :   A->Implicit = Implicit;
    3955           0 :   return A;
    3956             : }
    3957             : 
    3958           0 : void NSReturnsAutoreleasedAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    3959           0 :   switch (SpellingListIndex) {
    3960           0 :   default:
    3961           0 :     llvm_unreachable("Unknown attribute spelling!");
    3962             :     break;
    3963           0 :   case 0 : {
    3964           0 :     OS << " __attribute__((ns_returns_autoreleased))";
    3965             :     break;
    3966             :   }
    3967             : }
    3968           0 : }
    3969             : 
    3970           0 : const char *NSReturnsAutoreleasedAttr::getSpelling() const {
    3971           0 :   switch (SpellingListIndex) {
    3972           0 :   default:
    3973           0 :     llvm_unreachable("Unknown attribute spelling!");
    3974             :     return "(No spelling)";
    3975           0 :   case 0:
    3976             :     return "ns_returns_autoreleased";
    3977             :   }
    3978             : }
    3979             : 
    3980           8 : NSReturnsNotRetainedAttr *NSReturnsNotRetainedAttr::clone(ASTContext &C) const {
    3981          40 :   auto *A = new (C) NSReturnsNotRetainedAttr(getLocation(), C, getSpellingListIndex());
    3982           8 :   A->Inherited = Inherited;
    3983           8 :   A->IsPackExpansion = IsPackExpansion;
    3984           8 :   A->Implicit = Implicit;
    3985           8 :   return A;
    3986             : }
    3987             : 
    3988           0 : void NSReturnsNotRetainedAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    3989           0 :   switch (SpellingListIndex) {
    3990           0 :   default:
    3991           0 :     llvm_unreachable("Unknown attribute spelling!");
    3992             :     break;
    3993           0 :   case 0 : {
    3994           0 :     OS << " __attribute__((ns_returns_not_retained))";
    3995             :     break;
    3996             :   }
    3997             : }
    3998           0 : }
    3999             : 
    4000           0 : const char *NSReturnsNotRetainedAttr::getSpelling() const {
    4001           0 :   switch (SpellingListIndex) {
    4002           0 :   default:
    4003           0 :     llvm_unreachable("Unknown attribute spelling!");
    4004             :     return "(No spelling)";
    4005           0 :   case 0:
    4006             :     return "ns_returns_not_retained";
    4007             :   }
    4008             : }
    4009             : 
    4010         174 : NSReturnsRetainedAttr *NSReturnsRetainedAttr::clone(ASTContext &C) const {
    4011         870 :   auto *A = new (C) NSReturnsRetainedAttr(getLocation(), C, getSpellingListIndex());
    4012         174 :   A->Inherited = Inherited;
    4013         174 :   A->IsPackExpansion = IsPackExpansion;
    4014         174 :   A->Implicit = Implicit;
    4015         174 :   return A;
    4016             : }
    4017             : 
    4018           0 : void NSReturnsRetainedAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    4019           0 :   switch (SpellingListIndex) {
    4020           0 :   default:
    4021           0 :     llvm_unreachable("Unknown attribute spelling!");
    4022             :     break;
    4023           0 :   case 0 : {
    4024           0 :     OS << " __attribute__((ns_returns_retained))";
    4025             :     break;
    4026             :   }
    4027             : }
    4028           0 : }
    4029             : 
    4030           0 : const char *NSReturnsRetainedAttr::getSpelling() const {
    4031           0 :   switch (SpellingListIndex) {
    4032           0 :   default:
    4033           0 :     llvm_unreachable("Unknown attribute spelling!");
    4034             :     return "(No spelling)";
    4035           0 :   case 0:
    4036             :     return "ns_returns_retained";
    4037             :   }
    4038             : }
    4039             : 
    4040           1 : NakedAttr *NakedAttr::clone(ASTContext &C) const {
    4041           5 :   auto *A = new (C) NakedAttr(getLocation(), C, getSpellingListIndex());
    4042           1 :   A->Inherited = Inherited;
    4043           1 :   A->IsPackExpansion = IsPackExpansion;
    4044           1 :   A->Implicit = Implicit;
    4045           1 :   return A;
    4046             : }
    4047             : 
    4048           0 : void NakedAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    4049           0 :   switch (SpellingListIndex) {
    4050           0 :   default:
    4051           0 :     llvm_unreachable("Unknown attribute spelling!");
    4052             :     break;
    4053           0 :   case 0 : {
    4054           0 :     OS << " __attribute__((naked))";
    4055           0 :     break;
    4056             :   }
    4057           0 :   case 1 : {
    4058           0 :     OS << " [[gnu::naked]]";
    4059           0 :     break;
    4060             :   }
    4061           0 :   case 2 : {
    4062           0 :     OS << " __declspec(naked)";
    4063           0 :     break;
    4064             :   }
    4065             : }
    4066           0 : }
    4067             : 
    4068           1 : const char *NakedAttr::getSpelling() const {
    4069           1 :   switch (SpellingListIndex) {
    4070           0 :   default:
    4071           0 :     llvm_unreachable("Unknown attribute spelling!");
    4072             :     return "(No spelling)";
    4073             :   case 0:
    4074             :     return "naked";
    4075             :   case 1:
    4076             :     return "naked";
    4077             :   case 2:
    4078             :     return "naked";
    4079             :   }
    4080             : }
    4081             : 
    4082           0 : NoAliasAttr *NoAliasAttr::clone(ASTContext &C) const {
    4083           0 :   auto *A = new (C) NoAliasAttr(getLocation(), C, getSpellingListIndex());
    4084           0 :   A->Inherited = Inherited;
    4085           0 :   A->IsPackExpansion = IsPackExpansion;
    4086           0 :   A->Implicit = Implicit;
    4087           0 :   return A;
    4088             : }
    4089             : 
    4090           0 : void NoAliasAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    4091           0 :   switch (SpellingListIndex) {
    4092           0 :   default:
    4093           0 :     llvm_unreachable("Unknown attribute spelling!");
    4094             :     break;
    4095           0 :   case 0 : {
    4096           0 :     OS << " __declspec(noalias)";
    4097             :     break;
    4098             :   }
    4099             : }
    4100           0 : }
    4101             : 
    4102           0 : const char *NoAliasAttr::getSpelling() const {
    4103           0 :   switch (SpellingListIndex) {
    4104           0 :   default:
    4105           0 :     llvm_unreachable("Unknown attribute spelling!");
    4106             :     return "(No spelling)";
    4107           0 :   case 0:
    4108             :     return "noalias";
    4109             :   }
    4110             : }
    4111             : 
    4112           0 : NoCommonAttr *NoCommonAttr::clone(ASTContext &C) const {
    4113           0 :   auto *A = new (C) NoCommonAttr(getLocation(), C, getSpellingListIndex());
    4114           0 :   A->Inherited = Inherited;
    4115           0 :   A->IsPackExpansion = IsPackExpansion;
    4116           0 :   A->Implicit = Implicit;
    4117           0 :   return A;
    4118             : }
    4119             : 
    4120           0 : void NoCommonAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    4121           0 :   switch (SpellingListIndex) {
    4122           0 :   default:
    4123           0 :     llvm_unreachable("Unknown attribute spelling!");
    4124             :     break;
    4125           0 :   case 0 : {
    4126           0 :     OS << " __attribute__((nocommon))";
    4127           0 :     break;
    4128             :   }
    4129           0 :   case 1 : {
    4130           0 :     OS << " [[gnu::nocommon]]";
    4131           0 :     break;
    4132             :   }
    4133             : }
    4134           0 : }
    4135             : 
    4136           0 : const char *NoCommonAttr::getSpelling() const {
    4137           0 :   switch (SpellingListIndex) {
    4138           0 :   default:
    4139           0 :     llvm_unreachable("Unknown attribute spelling!");
    4140             :     return "(No spelling)";
    4141             :   case 0:
    4142             :     return "nocommon";
    4143             :   case 1:
    4144             :     return "nocommon";
    4145             :   }
    4146             : }
    4147             : 
    4148           3 : NoDebugAttr *NoDebugAttr::clone(ASTContext &C) const {
    4149          15 :   auto *A = new (C) NoDebugAttr(getLocation(), C, getSpellingListIndex());
    4150           3 :   A->Inherited = Inherited;
    4151           3 :   A->IsPackExpansion = IsPackExpansion;
    4152           3 :   A->Implicit = Implicit;
    4153           3 :   return A;
    4154             : }
    4155             : 
    4156           0 : void NoDebugAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    4157           0 :   switch (SpellingListIndex) {
    4158           0 :   default:
    4159           0 :     llvm_unreachable("Unknown attribute spelling!");
    4160             :     break;
    4161           0 :   case 0 : {
    4162           0 :     OS << " __attribute__((nodebug))";
    4163           0 :     break;
    4164             :   }
    4165           0 :   case 1 : {
    4166           0 :     OS << " [[gnu::nodebug]]";
    4167           0 :     break;
    4168             :   }
    4169             : }
    4170           0 : }
    4171             : 
    4172           0 : const char *NoDebugAttr::getSpelling() const {
    4173           0 :   switch (SpellingListIndex) {
    4174           0 :   default:
    4175           0 :     llvm_unreachable("Unknown attribute spelling!");
    4176             :     return "(No spelling)";
    4177             :   case 0:
    4178             :     return "nodebug";
    4179             :   case 1:
    4180             :     return "nodebug";
    4181             :   }
    4182             : }
    4183             : 
    4184           0 : NoDuplicateAttr *NoDuplicateAttr::clone(ASTContext &C) const {
    4185           0 :   auto *A = new (C) NoDuplicateAttr(getLocation(), C, getSpellingListIndex());
    4186           0 :   A->Inherited = Inherited;
    4187           0 :   A->IsPackExpansion = IsPackExpansion;
    4188           0 :   A->Implicit = Implicit;
    4189           0 :   return A;
    4190             : }
    4191             : 
    4192           0 : void NoDuplicateAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    4193           0 :   switch (SpellingListIndex) {
    4194           0 :   default:
    4195           0 :     llvm_unreachable("Unknown attribute spelling!");
    4196             :     break;
    4197           0 :   case 0 : {
    4198           0 :     OS << " __attribute__((noduplicate))";
    4199           0 :     break;
    4200             :   }
    4201           0 :   case 1 : {
    4202           0 :     OS << " [[clang::noduplicate]]";
    4203           0 :     break;
    4204             :   }
    4205             : }
    4206           0 : }
    4207             : 
    4208           0 : const char *NoDuplicateAttr::getSpelling() const {
    4209           0 :   switch (SpellingListIndex) {
    4210           0 :   default:
    4211           0 :     llvm_unreachable("Unknown attribute spelling!");
    4212             :     return "(No spelling)";
    4213             :   case 0:
    4214             :     return "noduplicate";
    4215             :   case 1:
    4216             :     return "noduplicate";
    4217             :   }
    4218             : }
    4219             : 
    4220          93 : NoInlineAttr *NoInlineAttr::clone(ASTContext &C) const {
    4221         465 :   auto *A = new (C) NoInlineAttr(getLocation(), C, getSpellingListIndex());
    4222          93 :   A->Inherited = Inherited;
    4223          93 :   A->IsPackExpansion = IsPackExpansion;
    4224          93 :   A->Implicit = Implicit;
    4225          93 :   return A;
    4226             : }
    4227             : 
    4228           1 : void NoInlineAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    4229           1 :   switch (SpellingListIndex) {
    4230           0 :   default:
    4231           0 :     llvm_unreachable("Unknown attribute spelling!");
    4232             :     break;
    4233           1 :   case 0 : {
    4234           1 :     OS << " __attribute__((noinline))";
    4235           1 :     break;
    4236             :   }
    4237           0 :   case 1 : {
    4238           0 :     OS << " [[gnu::noinline]]";
    4239           0 :     break;
    4240             :   }
    4241           0 :   case 2 : {
    4242           0 :     OS << " __declspec(noinline)";
    4243           0 :     break;
    4244             :   }
    4245             : }
    4246           1 : }
    4247             : 
    4248           0 : const char *NoInlineAttr::getSpelling() const {
    4249           0 :   switch (SpellingListIndex) {
    4250           0 :   default:
    4251           0 :     llvm_unreachable("Unknown attribute spelling!");
    4252             :     return "(No spelling)";
    4253             :   case 0:
    4254             :     return "noinline";
    4255             :   case 1:
    4256             :     return "noinline";
    4257             :   case 2:
    4258             :     return "noinline";
    4259             :   }
    4260             : }
    4261             : 
    4262           2 : NoInstrumentFunctionAttr *NoInstrumentFunctionAttr::clone(ASTContext &C) const {
    4263          10 :   auto *A = new (C) NoInstrumentFunctionAttr(getLocation(), C, getSpellingListIndex());
    4264           2 :   A->Inherited = Inherited;
    4265           2 :   A->IsPackExpansion = IsPackExpansion;
    4266           2 :   A->Implicit = Implicit;
    4267           2 :   return A;
    4268             : }
    4269             : 
    4270           0 : void NoInstrumentFunctionAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    4271           0 :   switch (SpellingListIndex) {
    4272           0 :   default:
    4273           0 :     llvm_unreachable("Unknown attribute spelling!");
    4274             :     break;
    4275           0 :   case 0 : {
    4276           0 :     OS << " __attribute__((no_instrument_function))";
    4277           0 :     break;
    4278             :   }
    4279           0 :   case 1 : {
    4280           0 :     OS << " [[gnu::no_instrument_function]]";
    4281           0 :     break;
    4282             :   }
    4283             : }
    4284           0 : }
    4285             : 
    4286           0 : const char *NoInstrumentFunctionAttr::getSpelling() const {
    4287           0 :   switch (SpellingListIndex) {
    4288           0 :   default:
    4289           0 :     llvm_unreachable("Unknown attribute spelling!");
    4290             :     return "(No spelling)";
    4291             :   case 0:
    4292             :     return "no_instrument_function";
    4293             :   case 1:
    4294             :     return "no_instrument_function";
    4295             :   }
    4296             : }
    4297             : 
    4298           0 : NoMicroMipsAttr *NoMicroMipsAttr::clone(ASTContext &C) const {
    4299           0 :   auto *A = new (C) NoMicroMipsAttr(getLocation(), C, getSpellingListIndex());
    4300           0 :   A->Inherited = Inherited;
    4301           0 :   A->IsPackExpansion = IsPackExpansion;
    4302           0 :   A->Implicit = Implicit;
    4303           0 :   return A;
    4304             : }
    4305             : 
    4306           0 : void NoMicroMipsAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    4307           0 :   switch (SpellingListIndex) {
    4308           0 :   default:
    4309           0 :     llvm_unreachable("Unknown attribute spelling!");
    4310             :     break;
    4311           0 :   case 0 : {
    4312           0 :     OS << " __attribute__((nomicromips))";
    4313           0 :     break;
    4314             :   }
    4315           0 :   case 1 : {
    4316           0 :     OS << " [[gnu::nomicromips]]";
    4317           0 :     break;
    4318             :   }
    4319             : }
    4320           0 : }
    4321             : 
    4322           0 : const char *NoMicroMipsAttr::getSpelling() const {
    4323           0 :   switch (SpellingListIndex) {
    4324           0 :   default:
    4325           0 :     llvm_unreachable("Unknown attribute spelling!");
    4326             :     return "(No spelling)";
    4327             :   case 0:
    4328             :     return "nomicromips";
    4329             :   case 1:
    4330             :     return "nomicromips";
    4331             :   }
    4332             : }
    4333             : 
    4334           2 : NoMips16Attr *NoMips16Attr::clone(ASTContext &C) const {
    4335          10 :   auto *A = new (C) NoMips16Attr(getLocation(), C, getSpellingListIndex());
    4336           2 :   A->Inherited = Inherited;
    4337           2 :   A->IsPackExpansion = IsPackExpansion;
    4338           2 :   A->Implicit = Implicit;
    4339           2 :   return A;
    4340             : }
    4341             : 
    4342           0 : void NoMips16Attr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    4343           0 :   switch (SpellingListIndex) {
    4344           0 :   default:
    4345           0 :     llvm_unreachable("Unknown attribute spelling!");
    4346             :     break;
    4347           0 :   case 0 : {
    4348           0 :     OS << " __attribute__((nomips16))";
    4349           0 :     break;
    4350             :   }
    4351           0 :   case 1 : {
    4352           0 :     OS << " [[gnu::nomips16]]";
    4353           0 :     break;
    4354             :   }
    4355             : }
    4356           0 : }
    4357             : 
    4358           0 : const char *NoMips16Attr::getSpelling() const {
    4359           0 :   switch (SpellingListIndex) {
    4360           0 :   default:
    4361           0 :     llvm_unreachable("Unknown attribute spelling!");
    4362             :     return "(No spelling)";
    4363             :   case 0:
    4364             :     return "nomips16";
    4365             :   case 1:
    4366             :     return "nomips16";
    4367             :   }
    4368             : }
    4369             : 
    4370           0 : NoReturnAttr *NoReturnAttr::clone(ASTContext &C) const {
    4371           0 :   auto *A = new (C) NoReturnAttr(getLocation(), C, getSpellingListIndex());
    4372           0 :   A->Inherited = Inherited;
    4373           0 :   A->IsPackExpansion = IsPackExpansion;
    4374           0 :   A->Implicit = Implicit;
    4375           0 :   return A;
    4376             : }
    4377             : 
    4378           0 : void NoReturnAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    4379           0 :   switch (SpellingListIndex) {
    4380           0 :   default:
    4381           0 :     llvm_unreachable("Unknown attribute spelling!");
    4382             :     break;
    4383           0 :   case 0 : {
    4384           0 :     OS << " __attribute__((noreturn))";
    4385           0 :     break;
    4386             :   }
    4387           0 :   case 1 : {
    4388           0 :     OS << " [[gnu::noreturn]]";
    4389           0 :     break;
    4390             :   }
    4391           0 :   case 2 : {
    4392           0 :     OS << " __declspec(noreturn)";
    4393           0 :     break;
    4394             :   }
    4395             : }
    4396           0 : }
    4397             : 
    4398           0 : const char *NoReturnAttr::getSpelling() const {
    4399           0 :   switch (SpellingListIndex) {
    4400           0 :   default:
    4401           0 :     llvm_unreachable("Unknown attribute spelling!");
    4402             :     return "(No spelling)";
    4403             :   case 0:
    4404             :     return "noreturn";
    4405             :   case 1:
    4406             :     return "noreturn";
    4407             :   case 2:
    4408             :     return "noreturn";
    4409             :   }
    4410             : }
    4411             : 
    4412          33 : NoSanitizeAttr *NoSanitizeAttr::clone(ASTContext &C) const {
    4413         165 :   auto *A = new (C) NoSanitizeAttr(getLocation(), C, sanitizers_, sanitizers_Size, getSpellingListIndex());
    4414          33 :   A->Inherited = Inherited;
    4415          33 :   A->IsPackExpansion = IsPackExpansion;
    4416          33 :   A->Implicit = Implicit;
    4417          33 :   return A;
    4418             : }
    4419             : 
    4420           4 : void NoSanitizeAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    4421           4 :   switch (SpellingListIndex) {
    4422           0 :   default:
    4423           0 :     llvm_unreachable("Unknown attribute spelling!");
    4424             :     break;
    4425           3 :   case 0 : {
    4426           3 :     OS << " __attribute__((no_sanitize(";
    4427           3 :   bool isFirst = true;
    4428           7 :   for (const auto &Val : sanitizers()) {
    4429           4 :     if (isFirst) isFirst = false;
    4430           1 :     else OS << ", ";
    4431           4 :     OS << "\"" << Val << "\"";
    4432             :   }
    4433           3 :   OS << ")))";
    4434           3 :     break;
    4435             :   }
    4436           1 :   case 1 : {
    4437           1 :     OS << " [[clang::no_sanitize(";
    4438           1 :   bool isFirst = true;
    4439           2 :   for (const auto &Val : sanitizers()) {
    4440           1 :     if (isFirst) isFirst = false;
    4441           0 :     else OS << ", ";
    4442           1 :     OS << "\"" << Val << "\"";
    4443             :   }
    4444           1 :   OS << ")]]";
    4445           1 :     break;
    4446             :   }
    4447             : }
    4448           4 : }
    4449             : 
    4450           0 : const char *NoSanitizeAttr::getSpelling() const {
    4451           0 :   switch (SpellingListIndex) {
    4452           0 :   default:
    4453           0 :     llvm_unreachable("Unknown attribute spelling!");
    4454             :     return "(No spelling)";
    4455             :   case 0:
    4456             :     return "no_sanitize";
    4457             :   case 1:
    4458             :     return "no_sanitize";
    4459             :   }
    4460             : }
    4461             : 
    4462           2 : NoSplitStackAttr *NoSplitStackAttr::clone(ASTContext &C) const {
    4463          10 :   auto *A = new (C) NoSplitStackAttr(getLocation(), C, getSpellingListIndex());
    4464           2 :   A->Inherited = Inherited;
    4465           2 :   A->IsPackExpansion = IsPackExpansion;
    4466           2 :   A->Implicit = Implicit;
    4467           2 :   return A;
    4468             : }
    4469             : 
    4470           0 : void NoSplitStackAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    4471           0 :   switch (SpellingListIndex) {
    4472           0 :   default:
    4473           0 :     llvm_unreachable("Unknown attribute spelling!");
    4474             :     break;
    4475           0 :   case 0 : {
    4476           0 :     OS << " __attribute__((no_split_stack))";
    4477           0 :     break;
    4478             :   }
    4479           0 :   case 1 : {
    4480           0 :     OS << " [[gnu::no_split_stack]]";
    4481           0 :     break;
    4482             :   }
    4483             : }
    4484           0 : }
    4485             : 
    4486           0 : const char *NoSplitStackAttr::getSpelling() const {
    4487           0 :   switch (SpellingListIndex) {
    4488           0 :   default:
    4489           0 :     llvm_unreachable("Unknown attribute spelling!");
    4490             :     return "(No spelling)";
    4491             :   case 0:
    4492             :     return "no_split_stack";
    4493             :   case 1:
    4494             :     return "no_split_stack";
    4495             :   }
    4496             : }
    4497             : 
    4498          15 : NoThreadSafetyAnalysisAttr *NoThreadSafetyAnalysisAttr::clone(ASTContext &C) const {
    4499          75 :   auto *A = new (C) NoThreadSafetyAnalysisAttr(getLocation(), C, getSpellingListIndex());
    4500          15 :   A->Inherited = Inherited;
    4501          15 :   A->IsPackExpansion = IsPackExpansion;
    4502          15 :   A->Implicit = Implicit;
    4503          15 :   return A;
    4504             : }
    4505             : 
    4506           0 : void NoThreadSafetyAnalysisAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    4507           0 :   switch (SpellingListIndex) {
    4508           0 :   default:
    4509           0 :     llvm_unreachable("Unknown attribute spelling!");
    4510             :     break;
    4511           0 :   case 0 : {
    4512           0 :     OS << " __attribute__((no_thread_safety_analysis))";
    4513             :     break;
    4514             :   }
    4515             : }
    4516           0 : }
    4517             : 
    4518           0 : const char *NoThreadSafetyAnalysisAttr::getSpelling() const {
    4519           0 :   switch (SpellingListIndex) {
    4520           0 :   default:
    4521           0 :     llvm_unreachable("Unknown attribute spelling!");
    4522             :     return "(No spelling)";
    4523           0 :   case 0:
    4524             :     return "no_thread_safety_analysis";
    4525             :   }
    4526             : }
    4527             : 
    4528         776 : NoThrowAttr *NoThrowAttr::clone(ASTContext &C) const {
    4529        3880 :   auto *A = new (C) NoThrowAttr(getLocation(), C, getSpellingListIndex());
    4530         776 :   A->Inherited = Inherited;
    4531         776 :   A->IsPackExpansion = IsPackExpansion;
    4532         776 :   A->Implicit = Implicit;
    4533         776 :   return A;
    4534             : }
    4535             : 
    4536           0 : void NoThrowAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    4537           0 :   switch (SpellingListIndex) {
    4538           0 :   default:
    4539           0 :     llvm_unreachable("Unknown attribute spelling!");
    4540             :     break;
    4541           0 :   case 0 : {
    4542           0 :     OS << " __attribute__((nothrow))";
    4543           0 :     break;
    4544             :   }
    4545           0 :   case 1 : {
    4546           0 :     OS << " [[gnu::nothrow]]";
    4547           0 :     break;
    4548             :   }
    4549           0 :   case 2 : {
    4550           0 :     OS << " __declspec(nothrow)";
    4551           0 :     break;
    4552             :   }
    4553             : }
    4554           0 : }
    4555             : 
    4556           0 : const char *NoThrowAttr::getSpelling() const {
    4557           0 :   switch (SpellingListIndex) {
    4558           0 :   default:
    4559           0 :     llvm_unreachable("Unknown attribute spelling!");
    4560             :     return "(No spelling)";
    4561             :   case 0:
    4562             :     return "nothrow";
    4563             :   case 1:
    4564             :     return "nothrow";
    4565             :   case 2:
    4566             :     return "nothrow";
    4567             :   }
    4568             : }
    4569             : 
    4570        1383 : NonNullAttr *NonNullAttr::clone(ASTContext &C) const {
    4571        6915 :   auto *A = new (C) NonNullAttr(getLocation(), C, args_, args_Size, getSpellingListIndex());
    4572        1383 :   A->Inherited = Inherited;
    4573        1383 :   A->IsPackExpansion = IsPackExpansion;
    4574        1383 :   A->Implicit = Implicit;
    4575        1383 :   return A;
    4576             : }
    4577             : 
    4578           0 : void NonNullAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    4579           0 :   switch (SpellingListIndex) {
    4580           0 :   default:
    4581           0 :     llvm_unreachable("Unknown attribute spelling!");
    4582             :     break;
    4583           0 :   case 0 : {
    4584           0 :     OS << " __attribute__((nonnull(";
    4585           0 :   bool isFirst = true;
    4586           0 :   for (const auto &Val : args()) {
    4587           0 :     if (isFirst) isFirst = false;
    4588           0 :     else OS << ", ";
    4589           0 :     OS << Val;
    4590             :   }
    4591           0 :   OS << ")))";
    4592           0 :     break;
    4593             :   }
    4594           0 :   case 1 : {
    4595           0 :     OS << " [[gnu::nonnull(";
    4596           0 :   bool isFirst = true;
    4597           0 :   for (const auto &Val : args()) {
    4598           0 :     if (isFirst) isFirst = false;
    4599           0 :     else OS << ", ";
    4600           0 :     OS << Val;
    4601             :   }
    4602           0 :   OS << ")]]";
    4603           0 :     break;
    4604             :   }
    4605             : }
    4606           0 : }
    4607             : 
    4608           0 : const char *NonNullAttr::getSpelling() const {
    4609           0 :   switch (SpellingListIndex) {
    4610           0 :   default:
    4611           0 :     llvm_unreachable("Unknown attribute spelling!");
    4612             :     return "(No spelling)";
    4613             :   case 0:
    4614             :     return "nonnull";
    4615             :   case 1:
    4616             :     return "nonnull";
    4617             :   }
    4618             : }
    4619             : 
    4620           0 : NotTailCalledAttr *NotTailCalledAttr::clone(ASTContext &C) const {
    4621           0 :   auto *A = new (C) NotTailCalledAttr(getLocation(), C, getSpellingListIndex());
    4622           0 :   A->Inherited = Inherited;
    4623           0 :   A->IsPackExpansion = IsPackExpansion;
    4624           0 :   A->Implicit = Implicit;
    4625           0 :   return A;
    4626             : }
    4627             : 
    4628           0 : void NotTailCalledAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    4629           0 :   switch (SpellingListIndex) {
    4630           0 :   default:
    4631           0 :     llvm_unreachable("Unknown attribute spelling!");
    4632             :     break;
    4633           0 :   case 0 : {
    4634           0 :     OS << " __attribute__((not_tail_called))";
    4635           0 :     break;
    4636             :   }
    4637           0 :   case 1 : {
    4638           0 :     OS << " [[clang::not_tail_called]]";
    4639           0 :     break;
    4640             :   }
    4641             : }
    4642           0 : }
    4643             : 
    4644           3 : const char *NotTailCalledAttr::getSpelling() const {
    4645           3 :   switch (SpellingListIndex) {
    4646           0 :   default:
    4647           0 :     llvm_unreachable("Unknown attribute spelling!");
    4648             :     return "(No spelling)";
    4649             :   case 0:
    4650             :     return "not_tail_called";
    4651             :   case 1:
    4652             :     return "not_tail_called";
    4653             :   }
    4654             : }
    4655             : 
    4656           0 : OMPCaptureKindAttr *OMPCaptureKindAttr::clone(ASTContext &C) const {
    4657           0 :   auto *A = new (C) OMPCaptureKindAttr(getLocation(), C, captureKind, getSpellingListIndex());
    4658           0 :   A->Inherited = Inherited;
    4659           0 :   A->IsPackExpansion = IsPackExpansion;
    4660           0 :   A->Implicit = Implicit;
    4661           0 :   return A;
    4662             : }
    4663             : 
    4664           0 : void OMPCaptureKindAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    4665           0 : }
    4666             : 
    4667           0 : const char *OMPCaptureKindAttr::getSpelling() const {
    4668           0 :   return "(No spelling)";
    4669             : }
    4670             : 
    4671           0 : OMPCaptureNoInitAttr *OMPCaptureNoInitAttr::clone(ASTContext &C) const {
    4672           0 :   auto *A = new (C) OMPCaptureNoInitAttr(getLocation(), C, getSpellingListIndex());
    4673           0 :   A->Inherited = Inherited;
    4674           0 :   A->IsPackExpansion = IsPackExpansion;
    4675           0 :   A->Implicit = Implicit;
    4676           0 :   return A;
    4677             : }
    4678             : 
    4679           0 : void OMPCaptureNoInitAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    4680           0 : }
    4681             : 
    4682           0 : const char *OMPCaptureNoInitAttr::getSpelling() const {
    4683           0 :   return "(No spelling)";
    4684             : }
    4685             : 
    4686           0 : OMPDeclareSimdDeclAttr *OMPDeclareSimdDeclAttr::clone(ASTContext &C) const {
    4687           0 :   auto *A = new (C) OMPDeclareSimdDeclAttr(getLocation(), C, branchState, simdlen, uniforms_, uniforms_Size, aligneds_, aligneds_Size, alignments_, alignments_Size, linears_, linears_Size, modifiers_, modifiers_Size, steps_, steps_Size, getSpellingListIndex());
    4688           0 :   A->Inherited = Inherited;
    4689           0 :   A->IsPackExpansion = IsPackExpansion;
    4690           0 :   A->Implicit = Implicit;
    4691           0 :   return A;
    4692             : }
    4693             : 
    4694          46 : void OMPDeclareSimdDeclAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    4695          46 :   switch (SpellingListIndex) {
    4696           0 :   default:
    4697           0 :     llvm_unreachable("Unknown attribute spelling!");
    4698             :     break;
    4699          46 :   case 0 : {
    4700          46 :     OS << "#pragma omp declare simd ";
    4701          46 :     printPrettyPragma(OS, Policy);
    4702          46 :     OS << "\n";    break;
    4703             :   }
    4704             : }
    4705          46 : }
    4706             : 
    4707           0 : const char *OMPDeclareSimdDeclAttr::getSpelling() const {
    4708           0 :   switch (SpellingListIndex) {
    4709           0 :   default:
    4710           0 :     llvm_unreachable("Unknown attribute spelling!");
    4711             :     return "(No spelling)";
    4712           0 :   case 0:
    4713             :     return "declare simd";
    4714             :   }
    4715             : }
    4716             : 
    4717           8 : OMPDeclareTargetDeclAttr *OMPDeclareTargetDeclAttr::clone(ASTContext &C) const {
    4718          40 :   auto *A = new (C) OMPDeclareTargetDeclAttr(getLocation(), C, mapType, getSpellingListIndex());
    4719           8 :   A->Inherited = Inherited;
    4720           8 :   A->IsPackExpansion = IsPackExpansion;
    4721           8 :   A->Implicit = Implicit;
    4722           8 :   return A;
    4723             : }
    4724             : 
    4725          46 : void OMPDeclareTargetDeclAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    4726          46 :   switch (SpellingListIndex) {
    4727           0 :   default:
    4728           0 :     llvm_unreachable("Unknown attribute spelling!");
    4729             :     break;
    4730          46 :   case 0 : {
    4731          46 :     OS << "#pragma omp declare target ";
    4732          46 :     printPrettyPragma(OS, Policy);
    4733          46 :     OS << "\n";    break;
    4734             :   }
    4735             : }
    4736          46 : }
    4737             : 
    4738           0 : const char *OMPDeclareTargetDeclAttr::getSpelling() const {
    4739           0 :   switch (SpellingListIndex) {
    4740           0 :   default:
    4741           0 :     llvm_unreachable("Unknown attribute spelling!");
    4742             :     return "(No spelling)";
    4743           0 :   case 0:
    4744             :     return "declare target";
    4745             :   }
    4746             : }
    4747             : 
    4748          22 : OMPThreadPrivateDeclAttr *OMPThreadPrivateDeclAttr::clone(ASTContext &C) const {
    4749         110 :   auto *A = new (C) OMPThreadPrivateDeclAttr(getLocation(), C, getSpellingListIndex());
    4750          22 :   A->Inherited = Inherited;
    4751          22 :   A->IsPackExpansion = IsPackExpansion;
    4752          22 :   A->Implicit = Implicit;
    4753          22 :   return A;
    4754             : }
    4755             : 
    4756         135 : void OMPThreadPrivateDeclAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    4757         135 : }
    4758             : 
    4759           0 : const char *OMPThreadPrivateDeclAttr::getSpelling() const {
    4760           0 :   return "(No spelling)";
    4761             : }
    4762             : 
    4763           0 : ObjCBoxableAttr *ObjCBoxableAttr::clone(ASTContext &C) const {
    4764           0 :   auto *A = new (C) ObjCBoxableAttr(getLocation(), C, getSpellingListIndex());
    4765           0 :   A->Inherited = Inherited;
    4766           0 :   A->IsPackExpansion = IsPackExpansion;
    4767           0 :   A->Implicit = Implicit;
    4768           0 :   return A;
    4769             : }
    4770             : 
    4771           0 : void ObjCBoxableAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    4772           0 :   switch (SpellingListIndex) {
    4773           0 :   default:
    4774           0 :     llvm_unreachable("Unknown attribute spelling!");
    4775             :     break;
    4776           0 :   case 0 : {
    4777           0 :     OS << " __attribute__((objc_boxable))";
    4778             :     break;
    4779             :   }
    4780             : }
    4781           0 : }
    4782             : 
    4783           0 : const char *ObjCBoxableAttr::getSpelling() const {
    4784           0 :   switch (SpellingListIndex) {
    4785           0 :   default:
    4786           0 :     llvm_unreachable("Unknown attribute spelling!");
    4787             :     return "(No spelling)";
    4788           0 :   case 0:
    4789             :     return "objc_boxable";
    4790             :   }
    4791             : }
    4792             : 
    4793           4 : ObjCBridgeAttr *ObjCBridgeAttr::clone(ASTContext &C) const {
    4794          20 :   auto *A = new (C) ObjCBridgeAttr(getLocation(), C, bridgedType, getSpellingListIndex());
    4795           4 :   A->Inherited = Inherited;
    4796           4 :   A->IsPackExpansion = IsPackExpansion;
    4797           4 :   A->Implicit = Implicit;
    4798           4 :   return A;
    4799             : }
    4800             : 
    4801           0 : void ObjCBridgeAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    4802           0 :   switch (SpellingListIndex) {
    4803           0 :   default:
    4804           0 :     llvm_unreachable("Unknown attribute spelling!");
    4805             :     break;
    4806           0 :   case 0 : {
    4807           0 :     OS << " __attribute__((objc_bridge(";
    4808           0 :     OS << getBridgedType()->getName();
    4809           0 :     OS << ")))";
    4810             :     break;
    4811             :   }
    4812             : }
    4813           0 : }
    4814             : 
    4815           0 : const char *ObjCBridgeAttr::getSpelling() const {
    4816           0 :   switch (SpellingListIndex) {
    4817           0 :   default:
    4818           0 :     llvm_unreachable("Unknown attribute spelling!");
    4819             :     return "(No spelling)";
    4820           0 :   case 0:
    4821             :     return "objc_bridge";
    4822             :   }
    4823             : }
    4824             : 
    4825           1 : ObjCBridgeMutableAttr *ObjCBridgeMutableAttr::clone(ASTContext &C) const {
    4826           5 :   auto *A = new (C) ObjCBridgeMutableAttr(getLocation(), C, bridgedType, getSpellingListIndex());
    4827           1 :   A->Inherited = Inherited;
    4828           1 :   A->IsPackExpansion = IsPackExpansion;
    4829           1 :   A->Implicit = Implicit;
    4830           1 :   return A;
    4831             : }
    4832             : 
    4833           0 : void ObjCBridgeMutableAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    4834           0 :   switch (SpellingListIndex) {
    4835           0 :   default:
    4836           0 :     llvm_unreachable("Unknown attribute spelling!");
    4837             :     break;
    4838           0 :   case 0 : {
    4839           0 :     OS << " __attribute__((objc_bridge_mutable(";
    4840           0 :     OS << getBridgedType()->getName();
    4841           0 :     OS << ")))";
    4842             :     break;
    4843             :   }
    4844             : }
    4845           0 : }
    4846             : 
    4847           0 : const char *ObjCBridgeMutableAttr::getSpelling() const {
    4848           0 :   switch (SpellingListIndex) {
    4849           0 :   default:
    4850           0 :     llvm_unreachable("Unknown attribute spelling!");
    4851             :     return "(No spelling)";
    4852           0 :   case 0:
    4853             :     return "objc_bridge_mutable";
    4854             :   }
    4855             : }
    4856             : 
    4857           0 : ObjCBridgeRelatedAttr *ObjCBridgeRelatedAttr::clone(ASTContext &C) const {
    4858           0 :   auto *A = new (C) ObjCBridgeRelatedAttr(getLocation(), C, relatedClass, classMethod, instanceMethod, getSpellingListIndex());
    4859           0 :   A->Inherited = Inherited;
    4860           0 :   A->IsPackExpansion = IsPackExpansion;
    4861           0 :   A->Implicit = Implicit;
    4862           0 :   return A;
    4863             : }
    4864             : 
    4865           1 : void ObjCBridgeRelatedAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    4866           1 :   switch (SpellingListIndex) {
    4867           0 :   default:
    4868           0 :     llvm_unreachable("Unknown attribute spelling!");
    4869             :     break;
    4870           1 :   case 0 : {
    4871           1 :     OS << " __attribute__((objc_bridge_related(";
    4872           2 :     OS << getRelatedClass()->getName();
    4873           1 :     OS << ", ";
    4874           1 :     if (getClassMethod()) OS << getClassMethod()->getName();
    4875           1 :     OS << ", ";
    4876           1 :     if (getInstanceMethod()) OS << getInstanceMethod()->getName();
    4877           1 :     OS << ")))";
    4878             :     break;
    4879             :   }
    4880             : }
    4881           1 : }
    4882             : 
    4883           0 : const char *ObjCBridgeRelatedAttr::getSpelling() const {
    4884           0 :   switch (SpellingListIndex) {
    4885           0 :   default:
    4886           0 :     llvm_unreachable("Unknown attribute spelling!");
    4887             :     return "(No spelling)";
    4888           0 :   case 0:
    4889             :     return "objc_bridge_related";
    4890             :   }
    4891             : }
    4892             : 
    4893           0 : ObjCDesignatedInitializerAttr *ObjCDesignatedInitializerAttr::clone(ASTContext &C) const {
    4894           0 :   auto *A = new (C) ObjCDesignatedInitializerAttr(getLocation(), C, getSpellingListIndex());
    4895           0 :   A->Inherited = Inherited;
    4896           0 :   A->IsPackExpansion = IsPackExpansion;
    4897           0 :   A->Implicit = Implicit;
    4898           0 :   return A;
    4899             : }
    4900             : 
    4901           0 : void ObjCDesignatedInitializerAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    4902           0 :   switch (SpellingListIndex) {
    4903           0 :   default:
    4904           0 :     llvm_unreachable("Unknown attribute spelling!");
    4905             :     break;
    4906           0 :   case 0 : {
    4907           0 :     OS << " __attribute__((objc_designated_initializer))";
    4908             :     break;
    4909             :   }
    4910             : }
    4911           0 : }
    4912             : 
    4913           0 : const char *ObjCDesignatedInitializerAttr::getSpelling() const {
    4914           0 :   switch (SpellingListIndex) {
    4915           0 :   default:
    4916           0 :     llvm_unreachable("Unknown attribute spelling!");
    4917             :     return "(No spelling)";
    4918           0 :   case 0:
    4919             :     return "objc_designated_initializer";
    4920             :   }
    4921             : }
    4922             : 
    4923           0 : ObjCExceptionAttr *ObjCExceptionAttr::clone(ASTContext &C) const {
    4924           0 :   auto *A = new (C) ObjCExceptionAttr(getLocation(), C, getSpellingListIndex());
    4925           0 :   A->Inherited = Inherited;
    4926           0 :   A->IsPackExpansion = IsPackExpansion;
    4927           0 :   A->Implicit = Implicit;
    4928           0 :   return A;
    4929             : }
    4930             : 
    4931           0 : void ObjCExceptionAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    4932           0 :   switch (SpellingListIndex) {
    4933           0 :   default:
    4934           0 :     llvm_unreachable("Unknown attribute spelling!");
    4935             :     break;
    4936           0 :   case 0 : {
    4937           0 :     OS << " __attribute__((objc_exception))";
    4938             :     break;
    4939             :   }
    4940             : }
    4941           0 : }
    4942             : 
    4943           0 : const char *ObjCExceptionAttr::getSpelling() const {
    4944           0 :   switch (SpellingListIndex) {
    4945           0 :   default:
    4946           0 :     llvm_unreachable("Unknown attribute spelling!");
    4947             :     return "(No spelling)";
    4948           0 :   case 0:
    4949             :     return "objc_exception";
    4950             :   }
    4951             : }
    4952             : 
    4953           0 : ObjCExplicitProtocolImplAttr *ObjCExplicitProtocolImplAttr::clone(ASTContext &C) const {
    4954           0 :   auto *A = new (C) ObjCExplicitProtocolImplAttr(getLocation(), C, getSpellingListIndex());
    4955           0 :   A->Inherited = Inherited;
    4956           0 :   A->IsPackExpansion = IsPackExpansion;
    4957           0 :   A->Implicit = Implicit;
    4958           0 :   return A;
    4959             : }
    4960             : 
    4961           0 : void ObjCExplicitProtocolImplAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    4962           0 :   switch (SpellingListIndex) {
    4963           0 :   default:
    4964           0 :     llvm_unreachable("Unknown attribute spelling!");
    4965             :     break;
    4966           0 :   case 0 : {
    4967           0 :     OS << " __attribute__((objc_protocol_requires_explicit_implementation))";
    4968             :     break;
    4969             :   }
    4970             : }
    4971           0 : }
    4972             : 
    4973           0 : const char *ObjCExplicitProtocolImplAttr::getSpelling() const {
    4974           0 :   switch (SpellingListIndex) {
    4975           0 :   default:
    4976           0 :     llvm_unreachable("Unknown attribute spelling!");
    4977             :     return "(No spelling)";
    4978           0 :   case 0:
    4979             :     return "objc_protocol_requires_explicit_implementation";
    4980             :   }
    4981             : }
    4982             : 
    4983           0 : ObjCIndependentClassAttr *ObjCIndependentClassAttr::clone(ASTContext &C) const {
    4984           0 :   auto *A = new (C) ObjCIndependentClassAttr(getLocation(), C, getSpellingListIndex());
    4985           0 :   A->Inherited = Inherited;
    4986           0 :   A->IsPackExpansion = IsPackExpansion;
    4987           0 :   A->Implicit = Implicit;
    4988           0 :   return A;
    4989             : }
    4990             : 
    4991           0 : void ObjCIndependentClassAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    4992           0 :   switch (SpellingListIndex) {
    4993           0 :   default:
    4994           0 :     llvm_unreachable("Unknown attribute spelling!");
    4995             :     break;
    4996           0 :   case 0 : {
    4997           0 :     OS << " __attribute__((objc_independent_class))";
    4998             :     break;
    4999             :   }
    5000             : }
    5001           0 : }
    5002             : 
    5003           0 : const char *ObjCIndependentClassAttr::getSpelling() const {
    5004           0 :   switch (SpellingListIndex) {
    5005           0 :   default:
    5006           0 :     llvm_unreachable("Unknown attribute spelling!");
    5007             :     return "(No spelling)";
    5008           0 :   case 0:
    5009             :     return "objc_independent_class";
    5010             :   }
    5011             : }
    5012             : 
    5013           9 : ObjCMethodFamilyAttr *ObjCMethodFamilyAttr::clone(ASTContext &C) const {
    5014          45 :   auto *A = new (C) ObjCMethodFamilyAttr(getLocation(), C, family, getSpellingListIndex());
    5015           9 :   A->Inherited = Inherited;
    5016           9 :   A->IsPackExpansion = IsPackExpansion;
    5017           9 :   A->Implicit = Implicit;
    5018           9 :   return A;
    5019             : }
    5020             : 
    5021           0 : void ObjCMethodFamilyAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    5022           0 :   switch (SpellingListIndex) {
    5023           0 :   default:
    5024           0 :     llvm_unreachable("Unknown attribute spelling!");
    5025             :     break;
    5026           0 :   case 0 : {
    5027           0 :     OS << " __attribute__((objc_method_family(\"" << ObjCMethodFamilyAttr::ConvertFamilyKindToStr(getFamily()) << "\")))";
    5028             :     break;
    5029             :   }
    5030             : }
    5031           0 : }
    5032             : 
    5033           0 : const char *ObjCMethodFamilyAttr::getSpelling() const {
    5034           0 :   switch (SpellingListIndex) {
    5035           0 :   default:
    5036           0 :     llvm_unreachable("Unknown attribute spelling!");
    5037             :     return "(No spelling)";
    5038           0 :   case 0:
    5039             :     return "objc_method_family";
    5040             :   }
    5041             : }
    5042             : 
    5043           0 : ObjCNSObjectAttr *ObjCNSObjectAttr::clone(ASTContext &C) const {
    5044           0 :   auto *A = new (C) ObjCNSObjectAttr(getLocation(), C, getSpellingListIndex());
    5045           0 :   A->Inherited = Inherited;
    5046           0 :   A->IsPackExpansion = IsPackExpansion;
    5047           0 :   A->Implicit = Implicit;
    5048           0 :   return A;
    5049             : }
    5050             : 
    5051           0 : void ObjCNSObjectAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    5052           0 :   switch (SpellingListIndex) {
    5053           0 :   default:
    5054           0 :     llvm_unreachable("Unknown attribute spelling!");
    5055             :     break;
    5056           0 :   case 0 : {
    5057           0 :     OS << " __attribute__((NSObject))";
    5058             :     break;
    5059             :   }
    5060             : }
    5061           0 : }
    5062             : 
    5063           0 : const char *ObjCNSObjectAttr::getSpelling() const {
    5064           0 :   switch (SpellingListIndex) {
    5065           0 :   default:
    5066           0 :     llvm_unreachable("Unknown attribute spelling!");
    5067             :     return "(No spelling)";
    5068           0 :   case 0:
    5069             :     return "NSObject";
    5070             :   }
    5071             : }
    5072             : 
    5073           0 : ObjCPreciseLifetimeAttr *ObjCPreciseLifetimeAttr::clone(ASTContext &C) const {
    5074           0 :   auto *A = new (C) ObjCPreciseLifetimeAttr(getLocation(), C, getSpellingListIndex());
    5075           0 :   A->Inherited = Inherited;
    5076           0 :   A->IsPackExpansion = IsPackExpansion;
    5077           0 :   A->Implicit = Implicit;
    5078           0 :   return A;
    5079             : }
    5080             : 
    5081           0 : void ObjCPreciseLifetimeAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    5082           0 :   switch (SpellingListIndex) {
    5083           0 :   default:
    5084           0 :     llvm_unreachable("Unknown attribute spelling!");
    5085             :     break;
    5086           0 :   case 0 : {
    5087           0 :     OS << " __attribute__((objc_precise_lifetime))";
    5088             :     break;
    5089             :   }
    5090             : }
    5091           0 : }
    5092             : 
    5093           0 : const char *ObjCPreciseLifetimeAttr::getSpelling() const {
    5094           0 :   switch (SpellingListIndex) {
    5095           0 :   default:
    5096           0 :     llvm_unreachable("Unknown attribute spelling!");
    5097             :     return "(No spelling)";
    5098           0 :   case 0:
    5099             :     return "objc_precise_lifetime";
    5100             :   }
    5101             : }
    5102             : 
    5103           0 : ObjCRequiresPropertyDefsAttr *ObjCRequiresPropertyDefsAttr::clone(ASTContext &C) const {
    5104           0 :   auto *A = new (C) ObjCRequiresPropertyDefsAttr(getLocation(), C, getSpellingListIndex());
    5105           0 :   A->Inherited = Inherited;
    5106           0 :   A->IsPackExpansion = IsPackExpansion;
    5107           0 :   A->Implicit = Implicit;
    5108           0 :   return A;
    5109             : }
    5110             : 
    5111           0 : void ObjCRequiresPropertyDefsAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    5112           0 :   switch (SpellingListIndex) {
    5113           0 :   default:
    5114           0 :     llvm_unreachable("Unknown attribute spelling!");
    5115             :     break;
    5116           0 :   case 0 : {
    5117           0 :     OS << " __attribute__((objc_requires_property_definitions))";
    5118             :     break;
    5119             :   }
    5120             : }
    5121           0 : }
    5122             : 
    5123           0 : const char *ObjCRequiresPropertyDefsAttr::getSpelling() const {
    5124           0 :   switch (SpellingListIndex) {
    5125           0 :   default:
    5126           0 :     llvm_unreachable("Unknown attribute spelling!");
    5127             :     return "(No spelling)";
    5128           0 :   case 0:
    5129             :     return "objc_requires_property_definitions";
    5130             :   }
    5131             : }
    5132             : 
    5133          12 : ObjCRequiresSuperAttr *ObjCRequiresSuperAttr::clone(ASTContext &C) const {
    5134          60 :   auto *A = new (C) ObjCRequiresSuperAttr(getLocation(), C, getSpellingListIndex());
    5135          12 :   A->Inherited = Inherited;
    5136          12 :   A->IsPackExpansion = IsPackExpansion;
    5137          12 :   A->Implicit = Implicit;
    5138          12 :   return A;
    5139             : }
    5140             : 
    5141           0 : void ObjCRequiresSuperAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    5142           0 :   switch (SpellingListIndex) {
    5143           0 :   default:
    5144           0 :     llvm_unreachable("Unknown attribute spelling!");
    5145             :     break;
    5146           0 :   case 0 : {
    5147           0 :     OS << " __attribute__((objc_requires_super))";
    5148             :     break;
    5149             :   }
    5150             : }
    5151           0 : }
    5152             : 
    5153           0 : const char *ObjCRequiresSuperAttr::getSpelling() const {
    5154           0 :   switch (SpellingListIndex) {
    5155           0 :   default:
    5156           0 :     llvm_unreachable("Unknown attribute spelling!");
    5157             :     return "(No spelling)";
    5158           0 :   case 0:
    5159             :     return "objc_requires_super";
    5160             :   }
    5161             : }
    5162             : 
    5163           0 : ObjCReturnsInnerPointerAttr *ObjCReturnsInnerPointerAttr::clone(ASTContext &C) const {
    5164           0 :   auto *A = new (C) ObjCReturnsInnerPointerAttr(getLocation(), C, getSpellingListIndex());
    5165           0 :   A->Inherited = Inherited;
    5166           0 :   A->IsPackExpansion = IsPackExpansion;
    5167           0 :   A->Implicit = Implicit;
    5168           0 :   return A;
    5169             : }
    5170             : 
    5171           0 : void ObjCReturnsInnerPointerAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    5172           0 :   switch (SpellingListIndex) {
    5173           0 :   default:
    5174           0 :     llvm_unreachable("Unknown attribute spelling!");
    5175             :     break;
    5176           0 :   case 0 : {
    5177           0 :     OS << " __attribute__((objc_returns_inner_pointer))";
    5178             :     break;
    5179             :   }
    5180             : }
    5181           0 : }
    5182             : 
    5183           0 : const char *ObjCReturnsInnerPointerAttr::getSpelling() const {
    5184           0 :   switch (SpellingListIndex) {
    5185           0 :   default:
    5186           0 :     llvm_unreachable("Unknown attribute spelling!");
    5187             :     return "(No spelling)";
    5188           0 :   case 0:
    5189             :     return "objc_returns_inner_pointer";
    5190             :   }
    5191             : }
    5192             : 
    5193           0 : ObjCRootClassAttr *ObjCRootClassAttr::clone(ASTContext &C) const {
    5194           0 :   auto *A = new (C) ObjCRootClassAttr(getLocation(), C, getSpellingListIndex());
    5195           0 :   A->Inherited = Inherited;
    5196           0 :   A->IsPackExpansion = IsPackExpansion;
    5197           0 :   A->Implicit = Implicit;
    5198           0 :   return A;
    5199             : }
    5200             : 
    5201           0 : void ObjCRootClassAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    5202           0 :   switch (SpellingListIndex) {
    5203           0 :   default:
    5204           0 :     llvm_unreachable("Unknown attribute spelling!");
    5205             :     break;
    5206           0 :   case 0 : {
    5207           0 :     OS << " __attribute__((objc_root_class))";
    5208             :     break;
    5209             :   }
    5210             : }
    5211           0 : }
    5212             : 
    5213           0 : const char *ObjCRootClassAttr::getSpelling() const {
    5214           0 :   switch (SpellingListIndex) {
    5215           0 :   default:
    5216           0 :     llvm_unreachable("Unknown attribute spelling!");
    5217             :     return "(No spelling)";
    5218           0 :   case 0:
    5219             :     return "objc_root_class";
    5220             :   }
    5221             : }
    5222             : 
    5223           0 : ObjCRuntimeNameAttr *ObjCRuntimeNameAttr::clone(ASTContext &C) const {
    5224           0 :   auto *A = new (C) ObjCRuntimeNameAttr(getLocation(), C, getMetadataName(), getSpellingListIndex());
    5225           0 :   A->Inherited = Inherited;
    5226           0 :   A->IsPackExpansion = IsPackExpansion;
    5227           0 :   A->Implicit = Implicit;
    5228           0 :   return A;
    5229             : }
    5230             : 
    5231           0 : void ObjCRuntimeNameAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    5232           0 :   switch (SpellingListIndex) {
    5233           0 :   default:
    5234           0 :     llvm_unreachable("Unknown attribute spelling!");
    5235             :     break;
    5236           0 :   case 0 : {
    5237           0 :     OS << " __attribute__((objc_runtime_name(\"" << getMetadataName() << "\")))";
    5238             :     break;
    5239             :   }
    5240             : }
    5241           0 : }
    5242             : 
    5243           0 : const char *ObjCRuntimeNameAttr::getSpelling() const {
    5244           0 :   switch (SpellingListIndex) {
    5245           0 :   default:
    5246           0 :     llvm_unreachable("Unknown attribute spelling!");
    5247             :     return "(No spelling)";
    5248           0 :   case 0:
    5249             :     return "objc_runtime_name";
    5250             :   }
    5251             : }
    5252             : 
    5253           0 : ObjCRuntimeVisibleAttr *ObjCRuntimeVisibleAttr::clone(ASTContext &C) const {
    5254           0 :   auto *A = new (C) ObjCRuntimeVisibleAttr(getLocation(), C, getSpellingListIndex());
    5255           0 :   A->Inherited = Inherited;
    5256           0 :   A->IsPackExpansion = IsPackExpansion;
    5257           0 :   A->Implicit = Implicit;
    5258           0 :   return A;
    5259             : }
    5260             : 
    5261           0 : void ObjCRuntimeVisibleAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    5262           0 :   switch (SpellingListIndex) {
    5263           0 :   default:
    5264           0 :     llvm_unreachable("Unknown attribute spelling!");
    5265             :     break;
    5266           0 :   case 0 : {
    5267           0 :     OS << " __attribute__((objc_runtime_visible))";
    5268             :     break;
    5269             :   }
    5270             : }
    5271           0 : }
    5272             : 
    5273           0 : const char *ObjCRuntimeVisibleAttr::getSpelling() const {
    5274           0 :   switch (SpellingListIndex) {
    5275           0 :   default:
    5276           0 :     llvm_unreachable("Unknown attribute spelling!");
    5277             :     return "(No spelling)";
    5278           0 :   case 0:
    5279             :     return "objc_runtime_visible";
    5280             :   }
    5281             : }
    5282             : 
    5283           0 : ObjCSubclassingRestrictedAttr *ObjCSubclassingRestrictedAttr::clone(ASTContext &C) const {
    5284           0 :   auto *A = new (C) ObjCSubclassingRestrictedAttr(getLocation(), C, getSpellingListIndex());
    5285           0 :   A->Inherited = Inherited;
    5286           0 :   A->IsPackExpansion = IsPackExpansion;
    5287           0 :   A->Implicit = Implicit;
    5288           0 :   return A;
    5289             : }
    5290             : 
    5291           0 : void ObjCSubclassingRestrictedAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    5292           0 :   switch (SpellingListIndex) {
    5293           0 :   default:
    5294           0 :     llvm_unreachable("Unknown attribute spelling!");
    5295             :     break;
    5296           0 :   case 0 : {
    5297           0 :     OS << " __attribute__((objc_subclassing_restricted))";
    5298             :     break;
    5299             :   }
    5300             : }
    5301           0 : }
    5302             : 
    5303           0 : const char *ObjCSubclassingRestrictedAttr::getSpelling() const {
    5304           0 :   switch (SpellingListIndex) {
    5305           0 :   default:
    5306           0 :     llvm_unreachable("Unknown attribute spelling!");
    5307             :     return "(No spelling)";
    5308           0 :   case 0:
    5309             :     return "objc_subclassing_restricted";
    5310             :   }
    5311             : }
    5312             : 
    5313           0 : OpenCLAccessAttr *OpenCLAccessAttr::clone(ASTContext &C) const {
    5314           0 :   auto *A = new (C) OpenCLAccessAttr(getLocation(), C, getSpellingListIndex());
    5315           0 :   A->Inherited = Inherited;
    5316           0 :   A->IsPackExpansion = IsPackExpansion;
    5317           0 :   A->Implicit = Implicit;
    5318           0 :   return A;
    5319             : }
    5320             : 
    5321           0 : void OpenCLAccessAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    5322           0 :   switch (SpellingListIndex) {
    5323           0 :   default:
    5324           0 :     llvm_unreachable("Unknown attribute spelling!");
    5325             :     break;
    5326           0 :   case 0 : {
    5327           0 :     OS << " __read_only";
    5328           0 :     break;
    5329             :   }
    5330           0 :   case 1 : {
    5331           0 :     OS << " read_only";
    5332           0 :     break;
    5333             :   }
    5334           0 :   case 2 : {
    5335           0 :     OS << " __write_only";
    5336           0 :     break;
    5337             :   }
    5338           0 :   case 3 : {
    5339           0 :     OS << " write_only";
    5340           0 :     break;
    5341             :   }
    5342           0 :   case 4 : {
    5343           0 :     OS << " __read_write";
    5344           0 :     break;
    5345             :   }
    5346           0 :   case 5 : {
    5347           0 :     OS << " read_write";
    5348           0 :     break;
    5349             :   }
    5350             : }
    5351           0 : }
    5352             : 
    5353           2 : const char *OpenCLAccessAttr::getSpelling() const {
    5354           2 :   switch (SpellingListIndex) {
    5355           0 :   default:
    5356           0 :     llvm_unreachable("Unknown attribute spelling!");
    5357             :     return "(No spelling)";
    5358             :   case 0:
    5359             :     return "__read_only";
    5360           1 :   case 1:
    5361           1 :     return "read_only";
    5362           0 :   case 2:
    5363           0 :     return "__write_only";
    5364           1 :   case 3:
    5365           1 :     return "write_only";
    5366           0 :   case 4:
    5367           0 :     return "__read_write";
    5368           0 :   case 5:
    5369           0 :     return "read_write";
    5370             :   }
    5371             : }
    5372             : 
    5373           0 : OpenCLIntelReqdSubGroupSizeAttr *OpenCLIntelReqdSubGroupSizeAttr::clone(ASTContext &C) const {
    5374           0 :   auto *A = new (C) OpenCLIntelReqdSubGroupSizeAttr(getLocation(), C, subGroupSize, getSpellingListIndex());
    5375           0 :   A->Inherited = Inherited;
    5376           0 :   A->IsPackExpansion = IsPackExpansion;
    5377           0 :   A->Implicit = Implicit;
    5378           0 :   return A;
    5379             : }
    5380             : 
    5381           0 : void OpenCLIntelReqdSubGroupSizeAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    5382           0 :   switch (SpellingListIndex) {
    5383           0 :   default:
    5384           0 :     llvm_unreachable("Unknown attribute spelling!");
    5385             :     break;
    5386           0 :   case 0 : {
    5387           0 :     OS << " __attribute__((intel_reqd_sub_group_size(" << getSubGroupSize() << ")))";
    5388             :     break;
    5389             :   }
    5390             : }
    5391           0 : }
    5392             : 
    5393           1 : const char *OpenCLIntelReqdSubGroupSizeAttr::getSpelling() const {
    5394           1 :   switch (SpellingListIndex) {
    5395           0 :   default:
    5396           0 :     llvm_unreachable("Unknown attribute spelling!");
    5397             :     return "(No spelling)";
    5398           1 :   case 0:
    5399             :     return "intel_reqd_sub_group_size";
    5400             :   }
    5401             : }
    5402             : 
    5403           0 : OpenCLKernelAttr *OpenCLKernelAttr::clone(ASTContext &C) const {
    5404           0 :   auto *A = new (C) OpenCLKernelAttr(getLocation(), C, getSpellingListIndex());
    5405           0 :   A->Inherited = Inherited;
    5406           0 :   A->IsPackExpansion = IsPackExpansion;
    5407           0 :   A->Implicit = Implicit;
    5408           0 :   return A;
    5409             : }
    5410             : 
    5411           0 : void OpenCLKernelAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    5412           0 :   switch (SpellingListIndex) {
    5413           0 :   default:
    5414           0 :     llvm_unreachable("Unknown attribute spelling!");
    5415             :     break;
    5416           0 :   case 0 : {
    5417           0 :     OS << " __kernel";
    5418           0 :     break;
    5419             :   }
    5420           0 :   case 1 : {
    5421           0 :     OS << " kernel";
    5422           0 :     break;
    5423             :   }
    5424             : }
    5425           0 : }
    5426             : 
    5427           0 : const char *OpenCLKernelAttr::getSpelling() const {
    5428           0 :   switch (SpellingListIndex) {
    5429           0 :   default:
    5430           0 :     llvm_unreachable("Unknown attribute spelling!");
    5431             :     return "(No spelling)";
    5432             :   case 0:
    5433             :     return "__kernel";
    5434           0 :   case 1:
    5435           0 :     return "kernel";
    5436             :   }
    5437             : }
    5438             : 
    5439           0 : OpenCLUnrollHintAttr *OpenCLUnrollHintAttr::clone(ASTContext &C) const {
    5440           0 :   auto *A = new (C) OpenCLUnrollHintAttr(getLocation(), C, unrollHint, getSpellingListIndex());
    5441           0 :   A->Inherited = Inherited;
    5442           0 :   A->IsPackExpansion = IsPackExpansion;
    5443           0 :   A->Implicit = Implicit;
    5444           0 :   return A;
    5445             : }
    5446             : 
    5447           0 : void OpenCLUnrollHintAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    5448           0 :   switch (SpellingListIndex) {
    5449           0 :   default:
    5450           0 :     llvm_unreachable("Unknown attribute spelling!");
    5451             :     break;
    5452           0 :   case 0 : {
    5453           0 :     OS << " __attribute__((opencl_unroll_hint(" << getUnrollHint() << ")))";
    5454             :     break;
    5455             :   }
    5456             : }
    5457           0 : }
    5458             : 
    5459           0 : const char *OpenCLUnrollHintAttr::getSpelling() const {
    5460           0 :   switch (SpellingListIndex) {
    5461           0 :   default:
    5462           0 :     llvm_unreachable("Unknown attribute spelling!");
    5463             :     return "(No spelling)";
    5464           0 :   case 0:
    5465             :     return "opencl_unroll_hint";
    5466             :   }
    5467             : }
    5468             : 
    5469           9 : OptimizeNoneAttr *OptimizeNoneAttr::clone(ASTContext &C) const {
    5470          45 :   auto *A = new (C) OptimizeNoneAttr(getLocation(), C, getSpellingListIndex());
    5471           9 :   A->Inherited = Inherited;
    5472           9 :   A->IsPackExpansion = IsPackExpansion;
    5473           9 :   A->Implicit = Implicit;
    5474           9 :   return A;
    5475             : }
    5476             : 
    5477           0 : void OptimizeNoneAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    5478           0 :   switch (SpellingListIndex) {
    5479           0 :   default:
    5480           0 :     llvm_unreachable("Unknown attribute spelling!");
    5481             :     break;
    5482           0 :   case 0 : {
    5483           0 :     OS << " __attribute__((optnone))";
    5484           0 :     break;
    5485             :   }
    5486           0 :   case 1 : {
    5487           0 :     OS << " [[clang::optnone]]";
    5488           0 :     break;
    5489             :   }
    5490             : }
    5491           0 : }
    5492             : 
    5493           0 : const char *OptimizeNoneAttr::getSpelling() const {
    5494           0 :   switch (SpellingListIndex) {
    5495           0 :   default:
    5496           0 :     llvm_unreachable("Unknown attribute spelling!");
    5497             :     return "(No spelling)";
    5498             :   case 0:
    5499             :     return "optnone";
    5500             :   case 1:
    5501             :     return "optnone";
    5502             :   }
    5503             : }
    5504             : 
    5505           0 : OverloadableAttr *OverloadableAttr::clone(ASTContext &C) const {
    5506           0 :   auto *A = new (C) OverloadableAttr(getLocation(), C, getSpellingListIndex());
    5507           0 :   A->Inherited = Inherited;
    5508           0 :   A->IsPackExpansion = IsPackExpansion;
    5509           0 :   A->Implicit = Implicit;
    5510           0 :   return A;
    5511             : }
    5512             : 
    5513           0 : void OverloadableAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    5514           0 :   switch (SpellingListIndex) {
    5515           0 :   default:
    5516           0 :     llvm_unreachable("Unknown attribute spelling!");
    5517             :     break;
    5518           0 :   case 0 : {
    5519           0 :     OS << " __attribute__((overloadable))";
    5520             :     break;
    5521             :   }
    5522             : }
    5523           0 : }
    5524             : 
    5525           0 : const char *OverloadableAttr::getSpelling() const {
    5526           0 :   switch (SpellingListIndex) {
    5527           0 :   default:
    5528           0 :     llvm_unreachable("Unknown attribute spelling!");
    5529             :     return "(No spelling)";
    5530           0 :   case 0:
    5531             :     return "overloadable";
    5532             :   }
    5533             : }
    5534             : 
    5535          19 : OverrideAttr *OverrideAttr::clone(ASTContext &C) const {
    5536          95 :   auto *A = new (C) OverrideAttr(getLocation(), C, getSpellingListIndex());
    5537          19 :   A->Inherited = Inherited;
    5538          19 :   A->IsPackExpansion = IsPackExpansion;
    5539          19 :   A->Implicit = Implicit;
    5540          19 :   return A;
    5541             : }
    5542             : 
    5543           0 : void OverrideAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    5544           0 :   switch (SpellingListIndex) {
    5545           0 :   default:
    5546           0 :     llvm_unreachable("Unknown attribute spelling!");
    5547             :     break;
    5548           0 :   case 0 : {
    5549           0 :     OS << " override";
    5550             :     break;
    5551             :   }
    5552             : }
    5553           0 : }
    5554             : 
    5555           0 : const char *OverrideAttr::getSpelling() const {
    5556           0 :   switch (SpellingListIndex) {
    5557           0 :   default:
    5558           0 :     llvm_unreachable("Unknown attribute spelling!");
    5559             :     return "(No spelling)";
    5560           0 :   case 0:
    5561             :     return "override";
    5562             :   }
    5563             : }
    5564             : 
    5565           0 : OwnershipAttr *OwnershipAttr::clone(ASTContext &C) const {
    5566           0 :   auto *A = new (C) OwnershipAttr(getLocation(), C, module, args_, args_Size, getSpellingListIndex());
    5567           0 :   A->Inherited = Inherited;
    5568           0 :   A->IsPackExpansion = IsPackExpansion;
    5569           0 :   A->Implicit = Implicit;
    5570           0 :   return A;
    5571             : }
    5572             : 
    5573           0 : void OwnershipAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    5574           0 :   switch (SpellingListIndex) {
    5575           0 :   default:
    5576           0 :     llvm_unreachable("Unknown attribute spelling!");
    5577             :     break;
    5578           0 :   case 0 : {
    5579           0 :     OS << " __attribute__((ownership_holds(";
    5580           0 :     OS << getModule()->getName();
    5581           0 :     OS << ", ";
    5582           0 :   bool isFirst = true;
    5583           0 :   for (const auto &Val : args()) {
    5584           0 :     if (isFirst) isFirst = false;
    5585           0 :     else OS << ", ";
    5586           0 :     OS << Val;
    5587             :   }
    5588           0 :   OS << ")))";
    5589           0 :     break;
    5590             :   }
    5591           0 :   case 1 : {
    5592           0 :     OS << " __attribute__((ownership_returns(";
    5593           0 :     OS << getModule()->getName();
    5594           0 :     OS << ", ";
    5595           0 :   bool isFirst = true;
    5596           0 :   for (const auto &Val : args()) {
    5597           0 :     if (isFirst) isFirst = false;
    5598           0 :     else OS << ", ";
    5599           0 :     OS << Val;
    5600             :   }
    5601           0 :   OS << ")))";
    5602           0 :     break;
    5603             :   }
    5604           0 :   case 2 : {
    5605           0 :     OS << " __attribute__((ownership_takes(";
    5606           0 :     OS << getModule()->getName();
    5607           0 :     OS << ", ";
    5608           0 :   bool isFirst = true;
    5609           0 :   for (const auto &Val : args()) {
    5610           0 :     if (isFirst) isFirst = false;
    5611           0 :     else OS << ", ";
    5612           0 :     OS << Val;
    5613             :   }
    5614           0 :   OS << ")))";
    5615           0 :     break;
    5616             :   }
    5617             : }
    5618           0 : }
    5619             : 
    5620           1 : const char *OwnershipAttr::getSpelling() const {
    5621           1 :   switch (SpellingListIndex) {
    5622           0 :   default:
    5623           0 :     llvm_unreachable("Unknown attribute spelling!");
    5624             :     return "(No spelling)";
    5625             :   case 0:
    5626             :     return "ownership_holds";
    5627           0 :   case 1:
    5628           0 :     return "ownership_returns";
    5629           1 :   case 2:
    5630           1 :     return "ownership_takes";
    5631             :   }
    5632             : }
    5633             : 
    5634           8 : PackedAttr *PackedAttr::clone(ASTContext &C) const {
    5635          40 :   auto *A = new (C) PackedAttr(getLocation(), C, getSpellingListIndex());
    5636           8 :   A->Inherited = Inherited;
    5637           8 :   A->IsPackExpansion = IsPackExpansion;
    5638           8 :   A->Implicit = Implicit;
    5639           8 :   return A;
    5640             : }
    5641             : 
    5642           0 : void PackedAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    5643           0 :   switch (SpellingListIndex) {
    5644           0 :   default:
    5645           0 :     llvm_unreachable("Unknown attribute spelling!");
    5646             :     break;
    5647           0 :   case 0 : {
    5648           0 :     OS << " __attribute__((packed))";
    5649           0 :     break;
    5650             :   }
    5651           0 :   case 1 : {
    5652           0 :     OS << " [[gnu::packed]]";
    5653           0 :     break;
    5654             :   }
    5655             : }
    5656           0 : }
    5657             : 
    5658           0 : const char *PackedAttr::getSpelling() const {
    5659           0 :   switch (SpellingListIndex) {
    5660           0 :   default:
    5661           0 :     llvm_unreachable("Unknown attribute spelling!");
    5662             :     return "(No spelling)";
    5663             :   case 0:
    5664             :     return "packed";
    5665             :   case 1:
    5666             :     return "packed";
    5667             :   }
    5668             : }
    5669             : 
    5670           0 : ParamTypestateAttr *ParamTypestateAttr::clone(ASTContext &C) const {
    5671           0 :   auto *A = new (C) ParamTypestateAttr(getLocation(), C, paramState, getSpellingListIndex());
    5672           0 :   A->Inherited = Inherited;
    5673           0 :   A->IsPackExpansion = IsPackExpansion;
    5674           0 :   A->Implicit = Implicit;
    5675           0 :   return A;
    5676             : }
    5677             : 
    5678           0 : void ParamTypestateAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    5679           0 :   switch (SpellingListIndex) {
    5680           0 :   default:
    5681           0 :     llvm_unreachable("Unknown attribute spelling!");
    5682             :     break;
    5683           0 :   case 0 : {
    5684           0 :     OS << " __attribute__((param_typestate(\"" << ParamTypestateAttr::ConvertConsumedStateToStr(getParamState()) << "\")))";
    5685             :     break;
    5686             :   }
    5687             : }
    5688           0 : }
    5689             : 
    5690           0 : const char *ParamTypestateAttr::getSpelling() const {
    5691           0 :   switch (SpellingListIndex) {
    5692           0 :   default:
    5693           0 :     llvm_unreachable("Unknown attribute spelling!");
    5694             :     return "(No spelling)";
    5695           0 :   case 0:
    5696             :     return "param_typestate";
    5697             :   }
    5698             : }
    5699             : 
    5700           0 : PascalAttr *PascalAttr::clone(ASTContext &C) const {
    5701           0 :   auto *A = new (C) PascalAttr(getLocation(), C, getSpellingListIndex());
    5702           0 :   A->Inherited = Inherited;
    5703           0 :   A->IsPackExpansion = IsPackExpansion;
    5704           0 :   A->Implicit = Implicit;
    5705           0 :   return A;
    5706             : }
    5707             : 
    5708           0 : void PascalAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    5709           0 :   switch (SpellingListIndex) {
    5710           0 :   default:
    5711           0 :     llvm_unreachable("Unknown attribute spelling!");
    5712             :     break;
    5713           0 :   case 0 : {
    5714           0 :     OS << " __attribute__((pascal))";
    5715           0 :     break;
    5716             :   }
    5717           0 :   case 1 : {
    5718           0 :     OS << " __pascal";
    5719           0 :     break;
    5720             :   }
    5721           0 :   case 2 : {
    5722           0 :     OS << " _pascal";
    5723           0 :     break;
    5724             :   }
    5725             : }
    5726           0 : }
    5727             : 
    5728           0 : const char *PascalAttr::getSpelling() const {
    5729           0 :   switch (SpellingListIndex) {
    5730           0 :   default:
    5731           0 :     llvm_unreachable("Unknown attribute spelling!");
    5732             :     return "(No spelling)";
    5733             :   case 0:
    5734             :     return "pascal";
    5735           0 :   case 1:
    5736           0 :     return "__pascal";
    5737           0 :   case 2:
    5738           0 :     return "_pascal";
    5739             :   }
    5740             : }
    5741             : 
    5742          31 : PassObjectSizeAttr *PassObjectSizeAttr::clone(ASTContext &C) const {
    5743         155 :   auto *A = new (C) PassObjectSizeAttr(getLocation(), C, type, getSpellingListIndex());
    5744          31 :   A->Inherited = Inherited;
    5745          31 :   A->IsPackExpansion = IsPackExpansion;
    5746          31 :   A->Implicit = Implicit;
    5747          31 :   return A;
    5748             : }
    5749             : 
    5750           0 : void PassObjectSizeAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    5751           0 :   switch (SpellingListIndex) {
    5752           0 :   default:
    5753           0 :     llvm_unreachable("Unknown attribute spelling!");
    5754             :     break;
    5755           0 :   case 0 : {
    5756           0 :     OS << " __attribute__((pass_object_size(" << getType() << ")))";
    5757             :     break;
    5758             :   }
    5759             : }
    5760           0 : }
    5761             : 
    5762           1 : const char *PassObjectSizeAttr::getSpelling() const {
    5763           1 :   switch (SpellingListIndex) {
    5764           0 :   default:
    5765           0 :     llvm_unreachable("Unknown attribute spelling!");
    5766             :     return "(No spelling)";
    5767           1 :   case 0:
    5768             :     return "pass_object_size";
    5769             :   }
    5770             : }
    5771             : 
    5772           0 : PcsAttr *PcsAttr::clone(ASTContext &C) const {
    5773           0 :   auto *A = new (C) PcsAttr(getLocation(), C, pCS, getSpellingListIndex());
    5774           0 :   A->Inherited = Inherited;
    5775           0 :   A->IsPackExpansion = IsPackExpansion;
    5776           0 :   A->Implicit = Implicit;
    5777           0 :   return A;
    5778             : }
    5779             : 
    5780           0 : void PcsAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    5781           0 :   switch (SpellingListIndex) {
    5782           0 :   default:
    5783           0 :     llvm_unreachable("Unknown attribute spelling!");
    5784             :     break;
    5785           0 :   case 0 : {
    5786           0 :     OS << " __attribute__((pcs(\"" << PcsAttr::ConvertPCSTypeToStr(getPCS()) << "\")))";
    5787           0 :     break;
    5788             :   }
    5789           0 :   case 1 : {
    5790           0 :     OS << " [[gnu::pcs(\"" << PcsAttr::ConvertPCSTypeToStr(getPCS()) << "\")]]";
    5791           0 :     break;
    5792             :   }
    5793             : }
    5794           0 : }
    5795             : 
    5796           0 : const char *PcsAttr::getSpelling() const {
    5797           0 :   switch (SpellingListIndex) {
    5798           0 :   default:
    5799           0 :     llvm_unreachable("Unknown attribute spelling!");
    5800             :     return "(No spelling)";
    5801             :   case 0:
    5802             :     return "pcs";
    5803             :   case 1:
    5804             :     return "pcs";
    5805             :   }
    5806             : }
    5807             : 
    5808           5 : PragmaClangBSSSectionAttr *PragmaClangBSSSectionAttr::clone(ASTContext &C) const {
    5809          30 :   auto *A = new (C) PragmaClangBSSSectionAttr(getLocation(), C, getName(), getSpellingListIndex());
    5810           5 :   A->Inherited = Inherited;
    5811           5 :   A->IsPackExpansion = IsPackExpansion;
    5812           5 :   A->Implicit = Implicit;
    5813           5 :   return A;
    5814             : }
    5815             : 
    5816           0 : void PragmaClangBSSSectionAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    5817           0 : }
    5818             : 
    5819           0 : const char *PragmaClangBSSSectionAttr::getSpelling() const {
    5820           0 :   return "(No spelling)";
    5821             : }
    5822             : 
    5823           0 : PragmaClangDataSectionAttr *PragmaClangDataSectionAttr::clone(ASTContext &C) const {
    5824           0 :   auto *A = new (C) PragmaClangDataSectionAttr(getLocation(), C, getName(), getSpellingListIndex());
    5825           0 :   A->Inherited = Inherited;
    5826           0 :   A->IsPackExpansion = IsPackExpansion;
    5827           0 :   A->Implicit = Implicit;
    5828           0 :   return A;
    5829             : }
    5830             : 
    5831           0 : void PragmaClangDataSectionAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    5832           0 : }
    5833             : 
    5834           0 : const char *PragmaClangDataSectionAttr::getSpelling() const {
    5835           0 :   return "(No spelling)";
    5836             : }
    5837             : 
    5838           2 : PragmaClangRodataSectionAttr *PragmaClangRodataSectionAttr::clone(ASTContext &C) const {
    5839          12 :   auto *A = new (C) PragmaClangRodataSectionAttr(getLocation(), C, getName(), getSpellingListIndex());
    5840           2 :   A->Inherited = Inherited;
    5841           2 :   A->IsPackExpansion = IsPackExpansion;
    5842           2 :   A->Implicit = Implicit;
    5843           2 :   return A;
    5844             : }
    5845             : 
    5846           0 : void PragmaClangRodataSectionAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    5847           0 : }
    5848             : 
    5849           0 : const char *PragmaClangRodataSectionAttr::getSpelling() const {
    5850           0 :   return "(No spelling)";
    5851             : }
    5852             : 
    5853           0 : PragmaClangTextSectionAttr *PragmaClangTextSectionAttr::clone(ASTContext &C) const {
    5854           0 :   auto *A = new (C) PragmaClangTextSectionAttr(getLocation(), C, getName(), getSpellingListIndex());
    5855           0 :   A->Inherited = Inherited;
    5856           0 :   A->IsPackExpansion = IsPackExpansion;
    5857           0 :   A->Implicit = Implicit;
    5858           0 :   return A;
    5859             : }
    5860             : 
    5861           0 : void PragmaClangTextSectionAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    5862           0 : }
    5863             : 
    5864           0 : const char *PragmaClangTextSectionAttr::getSpelling() const {
    5865           0 :   return "(No spelling)";
    5866             : }
    5867             : 
    5868           0 : PreserveAllAttr *PreserveAllAttr::clone(ASTContext &C) const {
    5869           0 :   auto *A = new (C) PreserveAllAttr(getLocation(), C, getSpellingListIndex());
    5870           0 :   A->Inherited = Inherited;
    5871           0 :   A->IsPackExpansion = IsPackExpansion;
    5872           0 :   A->Implicit = Implicit;
    5873           0 :   return A;
    5874             : }
    5875             : 
    5876           0 : void PreserveAllAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    5877           0 :   switch (SpellingListIndex) {
    5878           0 :   default:
    5879           0 :     llvm_unreachable("Unknown attribute spelling!");
    5880             :     break;
    5881           0 :   case 0 : {
    5882           0 :     OS << " __attribute__((preserve_all))";
    5883             :     break;
    5884             :   }
    5885             : }
    5886           0 : }
    5887             : 
    5888           0 : const char *PreserveAllAttr::getSpelling() const {
    5889           0 :   switch (SpellingListIndex) {
    5890           0 :   default:
    5891           0 :     llvm_unreachable("Unknown attribute spelling!");
    5892             :     return "(No spelling)";
    5893           0 :   case 0:
    5894             :     return "preserve_all";
    5895             :   }
    5896             : }
    5897             : 
    5898           0 : PreserveMostAttr *PreserveMostAttr::clone(ASTContext &C) const {
    5899           0 :   auto *A = new (C) PreserveMostAttr(getLocation(), C, getSpellingListIndex());
    5900           0 :   A->Inherited = Inherited;
    5901           0 :   A->IsPackExpansion = IsPackExpansion;
    5902           0 :   A->Implicit = Implicit;
    5903           0 :   return A;
    5904             : }
    5905             : 
    5906           0 : void PreserveMostAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    5907           0 :   switch (SpellingListIndex) {
    5908           0 :   default:
    5909           0 :     llvm_unreachable("Unknown attribute spelling!");
    5910             :     break;
    5911           0 :   case 0 : {
    5912           0 :     OS << " __attribute__((preserve_most))";
    5913             :     break;
    5914             :   }
    5915             : }
    5916           0 : }
    5917             : 
    5918           0 : const char *PreserveMostAttr::getSpelling() const {
    5919           0 :   switch (SpellingListIndex) {
    5920           0 :   default:
    5921           0 :     llvm_unreachable("Unknown attribute spelling!");
    5922             :     return "(No spelling)";
    5923           0 :   case 0:
    5924             :     return "preserve_most";
    5925             :   }
    5926             : }
    5927             : 
    5928           0 : PtGuardedByAttr *PtGuardedByAttr::clone(ASTContext &C) const {
    5929           0 :   auto *A = new (C) PtGuardedByAttr(getLocation(), C, arg, getSpellingListIndex());
    5930           0 :   A->Inherited = Inherited;
    5931           0 :   A->IsPackExpansion = IsPackExpansion;
    5932           0 :   A->Implicit = Implicit;
    5933           0 :   return A;
    5934             : }
    5935             : 
    5936           0 : void PtGuardedByAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    5937           0 :   switch (SpellingListIndex) {
    5938           0 :   default:
    5939           0 :     llvm_unreachable("Unknown attribute spelling!");
    5940             :     break;
    5941           0 :   case 0 : {
    5942           0 :     OS << " __attribute__((pt_guarded_by(" << getArg() << ")))";
    5943             :     break;
    5944             :   }
    5945             : }
    5946           0 : }
    5947             : 
    5948           0 : const char *PtGuardedByAttr::getSpelling() const {
    5949           0 :   switch (SpellingListIndex) {
    5950           0 :   default:
    5951           0 :     llvm_unreachable("Unknown attribute spelling!");
    5952             :     return "(No spelling)";
    5953           0 :   case 0:
    5954             :     return "pt_guarded_by";
    5955             :   }
    5956             : }
    5957             : 
    5958           0 : PtGuardedVarAttr *PtGuardedVarAttr::clone(ASTContext &C) const {
    5959           0 :   auto *A = new (C) PtGuardedVarAttr(getLocation(), C, getSpellingListIndex());
    5960           0 :   A->Inherited = Inherited;
    5961           0 :   A->IsPackExpansion = IsPackExpansion;
    5962           0 :   A->Implicit = Implicit;
    5963           0 :   return A;
    5964             : }
    5965             : 
    5966           0 : void PtGuardedVarAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    5967           0 :   switch (SpellingListIndex) {
    5968           0 :   default:
    5969           0 :     llvm_unreachable("Unknown attribute spelling!");
    5970             :     break;
    5971           0 :   case 0 : {
    5972           0 :     OS << " __attribute__((pt_guarded_var))";
    5973             :     break;
    5974             :   }
    5975             : }
    5976           0 : }
    5977             : 
    5978           0 : const char *PtGuardedVarAttr::getSpelling() const {
    5979           0 :   switch (SpellingListIndex) {
    5980           0 :   default:
    5981           0 :     llvm_unreachable("Unknown attribute spelling!");
    5982             :     return "(No spelling)";
    5983           0 :   case 0:
    5984             :     return "pt_guarded_var";
    5985             :   }
    5986             : }
    5987             : 
    5988         400 : PureAttr *PureAttr::clone(ASTContext &C) const {
    5989        2000 :   auto *A = new (C) PureAttr(getLocation(), C, getSpellingListIndex());
    5990         400 :   A->Inherited = Inherited;
    5991         400 :   A->IsPackExpansion = IsPackExpansion;
    5992         400 :   A->Implicit = Implicit;
    5993         400 :   return A;
    5994             : }
    5995             : 
    5996           5 : void PureAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    5997           5 :   switch (SpellingListIndex) {
    5998           0 :   default:
    5999           0 :     llvm_unreachable("Unknown attribute spelling!");
    6000             :     break;
    6001           3 :   case 0 : {
    6002           3 :     OS << " __attribute__((pure))";
    6003           3 :     break;
    6004             :   }
    6005           2 :   case 1 : {
    6006           2 :     OS << " [[gnu::pure]]";
    6007           2 :     break;
    6008             :   }
    6009             : }
    6010           5 : }
    6011             : 
    6012           0 : const char *PureAttr::getSpelling() const {
    6013           0 :   switch (SpellingListIndex) {
    6014           0 :   default:
    6015           0 :     llvm_unreachable("Unknown attribute spelling!");
    6016             :     return "(No spelling)";
    6017             :   case 0:
    6018             :     return "pure";
    6019             :   case 1:
    6020             :     return "pure";
    6021             :   }
    6022             : }
    6023             : 
    6024           0 : RegCallAttr *RegCallAttr::clone(ASTContext &C) const {
    6025           0 :   auto *A = new (C) RegCallAttr(getLocation(), C, getSpellingListIndex());
    6026           0 :   A->Inherited = Inherited;
    6027           0 :   A->IsPackExpansion = IsPackExpansion;
    6028           0 :   A->Implicit = Implicit;
    6029           0 :   return A;
    6030             : }
    6031             : 
    6032           0 : void RegCallAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    6033           0 :   switch (SpellingListIndex) {
    6034           0 :   default:
    6035           0 :     llvm_unreachable("Unknown attribute spelling!");
    6036             :     break;
    6037           0 :   case 0 : {
    6038           0 :     OS << " __attribute__((regcall))";
    6039           0 :     break;
    6040             :   }
    6041           0 :   case 1 : {
    6042           0 :     OS << " [[gnu::regcall]]";
    6043           0 :     break;
    6044             :   }
    6045           0 :   case 2 : {
    6046           0 :     OS << " __regcall";
    6047           0 :     break;
    6048             :   }
    6049             : }
    6050           0 : }
    6051             : 
    6052           0 : const char *RegCallAttr::getSpelling() const {
    6053           0 :   switch (SpellingListIndex) {
    6054           0 :   default:
    6055           0 :     llvm_unreachable("Unknown attribute spelling!");
    6056             :     return "(No spelling)";
    6057             :   case 0:
    6058             :     return "regcall";
    6059             :   case 1:
    6060             :     return "regcall";
    6061           0 :   case 2:
    6062           0 :     return "__regcall";
    6063             :   }
    6064             : }
    6065             : 
    6066          19 : ReleaseCapabilityAttr *ReleaseCapabilityAttr::clone(ASTContext &C) const {
    6067          95 :   auto *A = new (C) ReleaseCapabilityAttr(getLocation(), C, args_, args_Size, getSpellingListIndex());
    6068          19 :   A->Inherited = Inherited;
    6069          19 :   A->IsPackExpansion = IsPackExpansion;
    6070          19 :   A->Implicit = Implicit;
    6071          19 :   return A;
    6072             : }
    6073             : 
    6074           0 : void ReleaseCapabilityAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    6075           0 :   switch (SpellingListIndex) {
    6076           0 :   default:
    6077           0 :     llvm_unreachable("Unknown attribute spelling!");
    6078             :     break;
    6079           0 :   case 0 : {
    6080           0 :     OS << " __attribute__((release_capability(";
    6081           0 :   bool isFirst = true;
    6082           0 :   for (const auto &Val : args()) {
    6083           0 :     if (isFirst) isFirst = false;
    6084           0 :     else OS << ", ";
    6085           0 :     OS << Val;
    6086             :   }
    6087           0 :   OS << ")))";
    6088           0 :     break;
    6089             :   }
    6090           0 :   case 1 : {
    6091           0 :     OS << " [[clang::release_capability(";
    6092           0 :   bool isFirst = true;
    6093           0 :   for (const auto &Val : args()) {
    6094           0 :     if (isFirst) isFirst = false;
    6095           0 :     else OS << ", ";
    6096           0 :     OS << Val;
    6097             :   }
    6098           0 :   OS << ")]]";
    6099           0 :     break;
    6100             :   }
    6101           0 :   case 2 : {
    6102           0 :     OS << " __attribute__((release_shared_capability(";
    6103           0 :   bool isFirst = true;
    6104           0 :   for (const auto &Val : args()) {
    6105           0 :     if (isFirst) isFirst = false;
    6106           0 :     else OS << ", ";
    6107           0 :     OS << Val;
    6108             :   }
    6109           0 :   OS << ")))";
    6110           0 :     break;
    6111             :   }
    6112           0 :   case 3 : {
    6113           0 :     OS << " [[clang::release_shared_capability(";
    6114           0 :   bool isFirst = true;
    6115           0 :   for (const auto &Val : args()) {
    6116           0 :     if (isFirst) isFirst = false;
    6117           0 :     else OS << ", ";
    6118           0 :     OS << Val;
    6119             :   }
    6120           0 :   OS << ")]]";
    6121           0 :     break;
    6122             :   }
    6123           0 :   case 4 : {
    6124           0 :     OS << " __attribute__((release_generic_capability(";
    6125           0 :   bool isFirst = true;
    6126           0 :   for (const auto &Val : args()) {
    6127           0 :     if (isFirst) isFirst = false;
    6128           0 :     else OS << ", ";
    6129           0 :     OS << Val;
    6130             :   }
    6131           0 :   OS << ")))";
    6132           0 :     break;
    6133             :   }
    6134           0 :   case 5 : {
    6135           0 :     OS << " [[clang::release_generic_capability(";
    6136           0 :   bool isFirst = true;
    6137           0 :   for (const auto &Val : args()) {
    6138           0 :     if (isFirst) isFirst = false;
    6139           0 :     else OS << ", ";
    6140           0 :     OS << Val;
    6141             :   }
    6142           0 :   OS << ")]]";
    6143           0 :     break;
    6144             :   }
    6145           0 :   case 6 : {
    6146           0 :     OS << " __attribute__((unlock_function(";
    6147           0 :   bool isFirst = true;
    6148           0 :   for (const auto &Val : args()) {
    6149           0 :     if (isFirst) isFirst = false;
    6150           0 :     else OS << ", ";
    6151           0 :     OS << Val;
    6152             :   }
    6153           0 :   OS << ")))";
    6154           0 :     break;
    6155             :   }
    6156             : }
    6157           0 : }
    6158             : 
    6159           0 : const char *ReleaseCapabilityAttr::getSpelling() const {
    6160           0 :   switch (SpellingListIndex) {
    6161           0 :   default:
    6162           0 :     llvm_unreachable("Unknown attribute spelling!");
    6163             :     return "(No spelling)";
    6164             :   case 0:
    6165             :     return "release_capability";
    6166             :   case 1:
    6167             :     return "release_capability";
    6168           0 :   case 2:
    6169           0 :     return "release_shared_capability";
    6170           0 :   case 3:
    6171           0 :     return "release_shared_capability";
    6172           0 :   case 4:
    6173           0 :     return "release_generic_capability";
    6174           0 :   case 5:
    6175           0 :     return "release_generic_capability";
    6176           0 :   case 6:
    6177           0 :     return "unlock_function";
    6178             :   }
    6179             : }
    6180             : 
    6181           0 : RenderScriptKernelAttr *RenderScriptKernelAttr::clone(ASTContext &C) const {
    6182           0 :   auto *A = new (C) RenderScriptKernelAttr(getLocation(), C, getSpellingListIndex());
    6183           0 :   A->Inherited = Inherited;
    6184           0 :   A->IsPackExpansion = IsPackExpansion;
    6185           0 :   A->Implicit = Implicit;
    6186           0 :   return A;
    6187             : }
    6188             : 
    6189           0 : void RenderScriptKernelAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    6190           0 :   switch (SpellingListIndex) {
    6191           0 :   default:
    6192           0 :     llvm_unreachable("Unknown attribute spelling!");
    6193             :     break;
    6194           0 :   case 0 : {
    6195           0 :     OS << " __attribute__((kernel))";
    6196             :     break;
    6197             :   }
    6198             : }
    6199           0 : }
    6200             : 
    6201           0 : const char *RenderScriptKernelAttr::getSpelling() const {
    6202           0 :   switch (SpellingListIndex) {
    6203           0 :   default:
    6204           0 :     llvm_unreachable("Unknown attribute spelling!");
    6205             :     return "(No spelling)";
    6206           0 :   case 0:
    6207             :     return "kernel";
    6208             :   }
    6209             : }
    6210             : 
    6211           0 : ReqdWorkGroupSizeAttr *ReqdWorkGroupSizeAttr::clone(ASTContext &C) const {
    6212           0 :   auto *A = new (C) ReqdWorkGroupSizeAttr(getLocation(), C, xDim, yDim, zDim, getSpellingListIndex());
    6213           0 :   A->Inherited = Inherited;
    6214           0 :   A->IsPackExpansion = IsPackExpansion;
    6215           0 :   A->Implicit = Implicit;
    6216           0 :   return A;
    6217             : }
    6218             : 
    6219           0 : void ReqdWorkGroupSizeAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    6220           0 :   switch (SpellingListIndex) {
    6221           0 :   default:
    6222           0 :     llvm_unreachable("Unknown attribute spelling!");
    6223             :     break;
    6224           0 :   case 0 : {
    6225           0 :     OS << " __attribute__((reqd_work_group_size(" << getXDim() << ", " << getYDim() << ", " << getZDim() << ")))";
    6226             :     break;
    6227             :   }
    6228             : }
    6229           0 : }
    6230             : 
    6231           1 : const char *ReqdWorkGroupSizeAttr::getSpelling() const {
    6232           1 :   switch (SpellingListIndex) {
    6233           0 :   default:
    6234           0 :     llvm_unreachable("Unknown attribute spelling!");
    6235             :     return "(No spelling)";
    6236           1 :   case 0:
    6237             :     return "reqd_work_group_size";
    6238             :   }
    6239             : }
    6240             : 
    6241          22 : RequireConstantInitAttr *RequireConstantInitAttr::clone(ASTContext &C) const {
    6242         110 :   auto *A = new (C) RequireConstantInitAttr(getLocation(), C, getSpellingListIndex());
    6243          22 :   A->Inherited = Inherited;
    6244          22 :   A->IsPackExpansion = IsPackExpansion;
    6245          22 :   A->Implicit = Implicit;
    6246          22 :   return A;
    6247             : }
    6248             : 
    6249           0 : void RequireConstantInitAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    6250           0 :   switch (SpellingListIndex) {
    6251           0 :   default:
    6252           0 :     llvm_unreachable("Unknown attribute spelling!");
    6253             :     break;
    6254           0 :   case 0 : {
    6255           0 :     OS << " __attribute__((require_constant_initialization))";
    6256           0 :     break;
    6257             :   }
    6258           0 :   case 1 : {
    6259           0 :     OS << " [[clang::require_constant_initialization]]";
    6260           0 :     break;
    6261             :   }
    6262             : }
    6263           0 : }
    6264             : 
    6265           0 : const char *RequireConstantInitAttr::getSpelling() const {
    6266           0 :   switch (SpellingListIndex) {
    6267           0 :   default:
    6268           0 :     llvm_unreachable("Unknown attribute spelling!");
    6269             :     return "(No spelling)";
    6270             :   case 0:
    6271             :     return "require_constant_initialization";
    6272             :   case 1:
    6273             :     return "require_constant_initialization";
    6274             :   }
    6275             : }
    6276             : 
    6277          70 : RequiresCapabilityAttr *RequiresCapabilityAttr::clone(ASTContext &C) const {
    6278         350 :   auto *A = new (C) RequiresCapabilityAttr(getLocation(), C, args_, args_Size, getSpellingListIndex());
    6279          70 :   A->Inherited = Inherited;
    6280          70 :   A->IsPackExpansion = IsPackExpansion;
    6281          70 :   A->Implicit = Implicit;
    6282          70 :   return A;
    6283             : }
    6284             : 
    6285           0 : void RequiresCapabilityAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    6286           0 :   switch (SpellingListIndex) {
    6287           0 :   default:
    6288           0 :     llvm_unreachable("Unknown attribute spelling!");
    6289             :     break;
    6290           0 :   case 0 : {
    6291           0 :     OS << " __attribute__((requires_capability(";
    6292           0 :   bool isFirst = true;
    6293           0 :   for (const auto &Val : args()) {
    6294           0 :     if (isFirst) isFirst = false;
    6295           0 :     else OS << ", ";
    6296           0 :     OS << Val;
    6297             :   }
    6298           0 :   OS << ")))";
    6299           0 :     break;
    6300             :   }
    6301           0 :   case 1 : {
    6302           0 :     OS << " [[clang::requires_capability(";
    6303           0 :   bool isFirst = true;
    6304           0 :   for (const auto &Val : args()) {
    6305           0 :     if (isFirst) isFirst = false;
    6306           0 :     else OS << ", ";
    6307           0 :     OS << Val;
    6308             :   }
    6309           0 :   OS << ")]]";
    6310           0 :     break;
    6311             :   }
    6312           0 :   case 2 : {
    6313           0 :     OS << " __attribute__((exclusive_locks_required(";
    6314           0 :   bool isFirst = true;
    6315           0 :   for (const auto &Val : args()) {
    6316           0 :     if (isFirst) isFirst = false;
    6317           0 :     else OS << ", ";
    6318           0 :     OS << Val;
    6319             :   }
    6320           0 :   OS << ")))";
    6321           0 :     break;
    6322             :   }
    6323           0 :   case 3 : {
    6324           0 :     OS << " __attribute__((requires_shared_capability(";
    6325           0 :   bool isFirst = true;
    6326           0 :   for (const auto &Val : args()) {
    6327           0 :     if (isFirst) isFirst = false;
    6328           0 :     else OS << ", ";
    6329           0 :     OS << Val;
    6330             :   }
    6331           0 :   OS << ")))";
    6332           0 :     break;
    6333             :   }
    6334           0 :   case 4 : {
    6335           0 :     OS << " [[clang::requires_shared_capability(";
    6336           0 :   bool isFirst = true;
    6337           0 :   for (const auto &Val : args()) {
    6338           0 :     if (isFirst) isFirst = false;
    6339           0 :     else OS << ", ";
    6340           0 :     OS << Val;
    6341             :   }
    6342           0 :   OS << ")]]";
    6343           0 :     break;
    6344             :   }
    6345           0 :   case 5 : {
    6346           0 :     OS << " __attribute__((shared_locks_required(";
    6347           0 :   bool isFirst = true;
    6348           0 :   for (const auto &Val : args()) {
    6349           0 :     if (isFirst) isFirst = false;
    6350           0 :     else OS << ", ";
    6351           0 :     OS << Val;
    6352             :   }
    6353           0 :   OS << ")))";
    6354           0 :     break;
    6355             :   }
    6356             : }
    6357           0 : }
    6358             : 
    6359           0 : const char *RequiresCapabilityAttr::getSpelling() const {
    6360           0 :   switch (SpellingListIndex) {
    6361           0 :   default:
    6362           0 :     llvm_unreachable("Unknown attribute spelling!");
    6363             :     return "(No spelling)";
    6364             :   case 0:
    6365             :     return "requires_capability";
    6366             :   case 1:
    6367             :     return "requires_capability";
    6368           0 :   case 2:
    6369           0 :     return "exclusive_locks_required";
    6370           0 :   case 3:
    6371           0 :     return "requires_shared_capability";
    6372           0 :   case 4:
    6373           0 :     return "requires_shared_capability";
    6374           0 :   case 5:
    6375           0 :     return "shared_locks_required";
    6376             :   }
    6377             : }
    6378             : 
    6379           6 : RestrictAttr *RestrictAttr::clone(ASTContext &C) const {
    6380          30 :   auto *A = new (C) RestrictAttr(getLocation(), C, getSpellingListIndex());
    6381           6 :   A->Inherited = Inherited;
    6382           6 :   A->IsPackExpansion = IsPackExpansion;
    6383           6 :   A->Implicit = Implicit;
    6384           6 :   return A;
    6385             : }
    6386             : 
    6387           1 : void RestrictAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    6388           1 :   switch (SpellingListIndex) {
    6389           0 :   default:
    6390           0 :     llvm_unreachable("Unknown attribute spelling!");
    6391             :     break;
    6392           0 :   case 0 : {
    6393           0 :     OS << " __declspec(restrict)";
    6394           0 :     break;
    6395             :   }
    6396           1 :   case 1 : {
    6397           1 :     OS << " __attribute__((malloc))";
    6398           1 :     break;
    6399             :   }
    6400           0 :   case 2 : {
    6401           0 :     OS << " [[gnu::malloc]]";
    6402           0 :     break;
    6403             :   }
    6404             : }
    6405           1 : }
    6406             : 
    6407           0 : const char *RestrictAttr::getSpelling() const {
    6408           0 :   switch (SpellingListIndex) {
    6409           0 :   default:
    6410           0 :     llvm_unreachable("Unknown attribute spelling!");
    6411             :     return "(No spelling)";
    6412             :   case 0:
    6413             :     return "restrict";
    6414           0 :   case 1:
    6415           0 :     return "malloc";
    6416           0 :   case 2:
    6417           0 :     return "malloc";
    6418             :   }
    6419             : }
    6420             : 
    6421           6 : ReturnTypestateAttr *ReturnTypestateAttr::clone(ASTContext &C) const {
    6422          30 :   auto *A = new (C) ReturnTypestateAttr(getLocation(), C, state, getSpellingListIndex());
    6423           6 :   A->Inherited = Inherited;
    6424           6 :   A->IsPackExpansion = IsPackExpansion;
    6425           6 :   A->Implicit = Implicit;
    6426           6 :   return A;
    6427             : }
    6428             : 
    6429           0 : void ReturnTypestateAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    6430           0 :   switch (SpellingListIndex) {
    6431           0 :   default:
    6432           0 :     llvm_unreachable("Unknown attribute spelling!");
    6433             :     break;
    6434           0 :   case 0 : {
    6435           0 :     OS << " __attribute__((return_typestate(\"" << ReturnTypestateAttr::ConvertConsumedStateToStr(getState()) << "\")))";
    6436             :     break;
    6437             :   }
    6438             : }
    6439           0 : }
    6440             : 
    6441           0 : const char *ReturnTypestateAttr::getSpelling() const {
    6442           0 :   switch (SpellingListIndex) {
    6443           0 :   default:
    6444           0 :     llvm_unreachable("Unknown attribute spelling!");
    6445             :     return "(No spelling)";
    6446           0 :   case 0:
    6447             :     return "return_typestate";
    6448             :   }
    6449             : }
    6450             : 
    6451           1 : ReturnsNonNullAttr *ReturnsNonNullAttr::clone(ASTContext &C) const {
    6452           5 :   auto *A = new (C) ReturnsNonNullAttr(getLocation(), C, getSpellingListIndex());
    6453           1 :   A->Inherited = Inherited;
    6454           1 :   A->IsPackExpansion = IsPackExpansion;
    6455           1 :   A->Implicit = Implicit;
    6456           1 :   return A;
    6457             : }
    6458             : 
    6459           0 : void ReturnsNonNullAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    6460           0 :   switch (SpellingListIndex) {
    6461           0 :   default:
    6462           0 :     llvm_unreachable("Unknown attribute spelling!");
    6463             :     break;
    6464           0 :   case 0 : {
    6465           0 :     OS << " __attribute__((returns_nonnull))";
    6466           0 :     break;
    6467             :   }
    6468           0 :   case 1 : {
    6469           0 :     OS << " [[gnu::returns_nonnull]]";
    6470           0 :     break;
    6471             :   }
    6472             : }
    6473           0 : }
    6474             : 
    6475           0 : const char *ReturnsNonNullAttr::getSpelling() const {
    6476           0 :   switch (SpellingListIndex) {
    6477           0 :   default:
    6478           0 :     llvm_unreachable("Unknown attribute spelling!");
    6479             :     return "(No spelling)";
    6480             :   case 0:
    6481             :     return "returns_nonnull";
    6482             :   case 1:
    6483             :     return "returns_nonnull";
    6484             :   }
    6485             : }
    6486             : 
    6487          36 : ReturnsTwiceAttr *ReturnsTwiceAttr::clone(ASTContext &C) const {
    6488         180 :   auto *A = new (C) ReturnsTwiceAttr(getLocation(), C, getSpellingListIndex());
    6489          36 :   A->Inherited = Inherited;
    6490          36 :   A->IsPackExpansion = IsPackExpansion;
    6491          36 :   A->Implicit = Implicit;
    6492          36 :   return A;
    6493             : }
    6494             : 
    6495           0 : void ReturnsTwiceAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    6496           0 :   switch (SpellingListIndex) {
    6497           0 :   default:
    6498           0 :     llvm_unreachable("Unknown attribute spelling!");
    6499             :     break;
    6500           0 :   case 0 : {
    6501           0 :     OS << " __attribute__((returns_twice))";
    6502           0 :     break;
    6503             :   }
    6504           0 :   case 1 : {
    6505           0 :     OS << " [[gnu::returns_twice]]";
    6506           0 :     break;
    6507             :   }
    6508             : }
    6509           0 : }
    6510             : 
    6511           0 : const char *ReturnsTwiceAttr::getSpelling() const {
    6512           0 :   switch (SpellingListIndex) {
    6513           0 :   default:
    6514           0 :     llvm_unreachable("Unknown attribute spelling!");
    6515             :     return "(No spelling)";
    6516             :   case 0:
    6517             :     return "returns_twice";
    6518             :   case 1:
    6519             :     return "returns_twice";
    6520             :   }
    6521             : }
    6522             : 
    6523           0 : ScopedLockableAttr *ScopedLockableAttr::clone(ASTContext &C) const {
    6524           0 :   auto *A = new (C) ScopedLockableAttr(getLocation(), C, getSpellingListIndex());
    6525           0 :   A->Inherited = Inherited;
    6526           0 :   A->IsPackExpansion = IsPackExpansion;
    6527           0 :   A->Implicit = Implicit;
    6528           0 :   return A;
    6529             : }
    6530             : 
    6531           0 : void ScopedLockableAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    6532           0 :   switch (SpellingListIndex) {
    6533           0 :   default:
    6534           0 :     llvm_unreachable("Unknown attribute spelling!");
    6535             :     break;
    6536           0 :   case 0 : {
    6537           0 :     OS << " __attribute__((scoped_lockable))";
    6538             :     break;
    6539             :   }
    6540             : }
    6541           0 : }
    6542             : 
    6543           0 : const char *ScopedLockableAttr::getSpelling() const {
    6544           0 :   switch (SpellingListIndex) {
    6545           0 :   default:
    6546           0 :     llvm_unreachable("Unknown attribute spelling!");
    6547             :     return "(No spelling)";
    6548           0 :   case 0:
    6549             :     return "scoped_lockable";
    6550             :   }
    6551             : }
    6552             : 
    6553           0 : SectionAttr *SectionAttr::clone(ASTContext &C) const {
    6554           0 :   auto *A = new (C) SectionAttr(getLocation(), C, getName(), getSpellingListIndex());
    6555           0 :   A->Inherited = Inherited;
    6556           0 :   A->IsPackExpansion = IsPackExpansion;
    6557           0 :   A->Implicit = Implicit;
    6558           0 :   return A;
    6559             : }
    6560             : 
    6561           0 : void SectionAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    6562           0 :   switch (SpellingListIndex) {
    6563           0 :   default:
    6564           0 :     llvm_unreachable("Unknown attribute spelling!");
    6565             :     break;
    6566           0 :   case 0 : {
    6567           0 :     OS << " __attribute__((section(\"" << getName() << "\")))";
    6568           0 :     break;
    6569             :   }
    6570           0 :   case 1 : {
    6571           0 :     OS << " [[gnu::section(\"" << getName() << "\")]]";
    6572           0 :     break;
    6573             :   }
    6574           0 :   case 2 : {
    6575           0 :     OS << " __declspec(allocate(\"" << getName() << "\"))";
    6576           0 :     break;
    6577             :   }
    6578             : }
    6579           0 : }
    6580             : 
    6581           0 : const char *SectionAttr::getSpelling() const {
    6582           0 :   switch (SpellingListIndex) {
    6583           0 :   default:
    6584           0 :     llvm_unreachable("Unknown attribute spelling!");
    6585             :     return "(No spelling)";
    6586             :   case 0:
    6587             :     return "section";
    6588             :   case 1:
    6589             :     return "section";
    6590           0 :   case 2:
    6591           0 :     return "allocate";
    6592             :   }
    6593             : }
    6594             : 
    6595           1 : SelectAnyAttr *SelectAnyAttr::clone(ASTContext &C) const {
    6596           5 :   auto *A = new (C) SelectAnyAttr(getLocation(), C, getSpellingListIndex());
    6597           1 :   A->Inherited = Inherited;
    6598           1 :   A->IsPackExpansion = IsPackExpansion;
    6599           1 :   A->Implicit = Implicit;
    6600           1 :   return A;
    6601             : }
    6602             : 
    6603           0 : void SelectAnyAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    6604           0 :   switch (SpellingListIndex) {
    6605           0 :   default:
    6606           0 :     llvm_unreachable("Unknown attribute spelling!");
    6607             :     break;
    6608           0 :   case 0 : {
    6609           0 :     OS << " __declspec(selectany)";
    6610           0 :     break;
    6611             :   }
    6612           0 :   case 1 : {
    6613           0 :     OS << " __attribute__((selectany))";
    6614           0 :     break;
    6615             :   }
    6616           0 :   case 2 : {
    6617           0 :     OS << " [[gnu::selectany]]";
    6618           0 :     break;
    6619             :   }
    6620             : }
    6621           0 : }
    6622             : 
    6623           0 : const char *SelectAnyAttr::getSpelling() const {
    6624           0 :   switch (SpellingListIndex) {
    6625           0 :   default:
    6626           0 :     llvm_unreachable("Unknown attribute spelling!");
    6627             :     return "(No spelling)";
    6628             :   case 0:
    6629             :     return "selectany";
    6630             :   case 1:
    6631             :     return "selectany";
    6632             :   case 2:
    6633             :     return "selectany";
    6634             :   }
    6635             : }
    6636             : 
    6637           0 : SentinelAttr *SentinelAttr::clone(ASTContext &C) const {
    6638           0 :   auto *A = new (C) SentinelAttr(getLocation(), C, sentinel, nullPos, getSpellingListIndex());
    6639           0 :   A->Inherited = Inherited;
    6640           0 :   A->IsPackExpansion = IsPackExpansion;
    6641           0 :   A->Implicit = Implicit;
    6642           0 :   return A;
    6643             : }
    6644             : 
    6645           0 : void SentinelAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    6646           0 :   switch (SpellingListIndex) {
    6647           0 :   default:
    6648           0 :     llvm_unreachable("Unknown attribute spelling!");
    6649             :     break;
    6650           0 :   case 0 : {
    6651           0 :     OS << " __attribute__((sentinel(" << getSentinel() << ", " << getNullPos() << ")))";
    6652           0 :     break;
    6653             :   }
    6654           0 :   case 1 : {
    6655           0 :     OS << " [[gnu::sentinel(" << getSentinel() << ", " << getNullPos() << ")]]";
    6656           0 :     break;
    6657             :   }
    6658             : }
    6659           0 : }
    6660             : 
    6661           0 : const char *SentinelAttr::getSpelling() const {
    6662           0 :   switch (SpellingListIndex) {
    6663           0 :   default:
    6664           0 :     llvm_unreachable("Unknown attribute spelling!");
    6665             :     return "(No spelling)";
    6666             :   case 0:
    6667             :     return "sentinel";
    6668             :   case 1:
    6669             :     return "sentinel";
    6670             :   }
    6671             : }
    6672             : 
    6673           8 : SetTypestateAttr *SetTypestateAttr::clone(ASTContext &C) const {
    6674          40 :   auto *A = new (C) SetTypestateAttr(getLocation(), C, newState, getSpellingListIndex());
    6675           8 :   A->Inherited = Inherited;
    6676           8 :   A->IsPackExpansion = IsPackExpansion;
    6677           8 :   A->Implicit = Implicit;
    6678           8 :   return A;
    6679             : }
    6680             : 
    6681           0 : void SetTypestateAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    6682           0 :   switch (SpellingListIndex) {
    6683           0 :   default:
    6684           0 :     llvm_unreachable("Unknown attribute spelling!");
    6685             :     break;
    6686           0 :   case 0 : {
    6687           0 :     OS << " __attribute__((set_typestate(\"" << SetTypestateAttr::ConvertConsumedStateToStr(getNewState()) << "\")))";
    6688             :     break;
    6689             :   }
    6690             : }
    6691           0 : }
    6692             : 
    6693           0 : const char *SetTypestateAttr::getSpelling() const {
    6694           0 :   switch (SpellingListIndex) {
    6695           0 :   default:
    6696           0 :     llvm_unreachable("Unknown attribute spelling!");
    6697             :     return "(No spelling)";
    6698           0 :   case 0:
    6699             :     return "set_typestate";
    6700             :   }
    6701             : }
    6702             : 
    6703           7 : SharedTrylockFunctionAttr *SharedTrylockFunctionAttr::clone(ASTContext &C) const {
    6704          35 :   auto *A = new (C) SharedTrylockFunctionAttr(getLocation(), C, successValue, args_, args_Size, getSpellingListIndex());
    6705           7 :   A->Inherited = Inherited;
    6706           7 :   A->IsPackExpansion = IsPackExpansion;
    6707           7 :   A->Implicit = Implicit;
    6708           7 :   return A;
    6709             : }
    6710             : 
    6711           0 : void SharedTrylockFunctionAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    6712           0 :   switch (SpellingListIndex) {
    6713           0 :   default:
    6714           0 :     llvm_unreachable("Unknown attribute spelling!");
    6715             :     break;
    6716           0 :   case 0 : {
    6717           0 :     OS << " __attribute__((shared_trylock_function(" << getSuccessValue() << ", ";
    6718           0 :   bool isFirst = true;
    6719           0 :   for (const auto &Val : args()) {
    6720           0 :     if (isFirst) isFirst = false;
    6721           0 :     else OS << ", ";
    6722           0 :     OS << Val;
    6723             :   }
    6724           0 :   OS << ")))";
    6725             :     break;
    6726             :   }
    6727             : }
    6728           0 : }
    6729             : 
    6730           0 : const char *SharedTrylockFunctionAttr::getSpelling() const {
    6731           0 :   switch (SpellingListIndex) {
    6732           0 :   default:
    6733           0 :     llvm_unreachable("Unknown attribute spelling!");
    6734             :     return "(No spelling)";
    6735           0 :   case 0:
    6736             :     return "shared_trylock_function";
    6737             :   }
    6738             : }
    6739             : 
    6740           0 : StdCallAttr *StdCallAttr::clone(ASTContext &C) const {
    6741           0 :   auto *A = new (C) StdCallAttr(getLocation(), C, getSpellingListIndex());
    6742           0 :   A->Inherited = Inherited;
    6743           0 :   A->IsPackExpansion = IsPackExpansion;
    6744           0 :   A->Implicit = Implicit;
    6745           0 :   return A;
    6746             : }
    6747             : 
    6748           0 : void StdCallAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    6749           0 :   switch (SpellingListIndex) {
    6750           0 :   default:
    6751           0 :     llvm_unreachable("Unknown attribute spelling!");
    6752             :     break;
    6753           0 :   case 0 : {
    6754           0 :     OS << " __attribute__((stdcall))";
    6755           0 :     break;
    6756             :   }
    6757           0 :   case 1 : {
    6758           0 :     OS << " [[gnu::stdcall]]";
    6759           0 :     break;
    6760             :   }
    6761           0 :   case 2 : {
    6762           0 :     OS << " __stdcall";
    6763           0 :     break;
    6764             :   }
    6765           0 :   case 3 : {
    6766           0 :     OS << " _stdcall";
    6767           0 :     break;
    6768             :   }
    6769             : }
    6770           0 : }
    6771             : 
    6772           0 : const char *StdCallAttr::getSpelling() const {
    6773           0 :   switch (SpellingListIndex) {
    6774           0 :   default:
    6775           0 :     llvm_unreachable("Unknown attribute spelling!");
    6776             :     return "(No spelling)";
    6777             :   case 0:
    6778             :     return "stdcall";
    6779             :   case 1:
    6780             :     return "stdcall";
    6781           0 :   case 2:
    6782           0 :     return "__stdcall";
    6783           0 :   case 3:
    6784           0 :     return "_stdcall";
    6785             :   }
    6786             : }
    6787             : 
    6788           0 : SuppressAttr *SuppressAttr::clone(ASTContext &C) const {
    6789           0 :   auto *A = new (C) SuppressAttr(getLocation(), C, diagnosticIdentifiers_, diagnosticIdentifiers_Size, getSpellingListIndex());
    6790           0 :   A->Inherited = Inherited;
    6791           0 :   A->IsPackExpansion = IsPackExpansion;
    6792           0 :   A->Implicit = Implicit;
    6793           0 :   return A;
    6794             : }
    6795             : 
    6796           0 : void SuppressAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    6797           0 :   switch (SpellingListIndex) {
    6798           0 :   default:
    6799           0 :     llvm_unreachable("Unknown attribute spelling!");
    6800             :     break;
    6801           0 :   case 0 : {
    6802           0 :     OS << " [[gsl::suppress(";
    6803           0 :   bool isFirst = true;
    6804           0 :   for (const auto &Val : diagnosticIdentifiers()) {
    6805           0 :     if (isFirst) isFirst = false;
    6806           0 :     else OS << ", ";
    6807           0 :     OS << "\"" << Val << "\"";
    6808             :   }
    6809           0 :   OS << ")]]";
    6810             :     break;
    6811             :   }
    6812             : }
    6813           0 : }
    6814             : 
    6815           0 : const char *SuppressAttr::getSpelling() const {
    6816           0 :   switch (SpellingListIndex) {
    6817           0 :   default:
    6818           0 :     llvm_unreachable("Unknown attribute spelling!");
    6819             :     return "(No spelling)";
    6820           0 :   case 0:
    6821             :     return "suppress";
    6822             :   }
    6823             : }
    6824             : 
    6825           0 : SwiftCallAttr *SwiftCallAttr::clone(ASTContext &C) const {
    6826           0 :   auto *A = new (C) SwiftCallAttr(getLocation(), C, getSpellingListIndex());
    6827           0 :   A->Inherited = Inherited;
    6828           0 :   A->IsPackExpansion = IsPackExpansion;
    6829           0 :   A->Implicit = Implicit;
    6830           0 :   return A;
    6831             : }
    6832             : 
    6833           0 : void SwiftCallAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    6834           0 :   switch (SpellingListIndex) {
    6835           0 :   default:
    6836           0 :     llvm_unreachable("Unknown attribute spelling!");
    6837             :     break;
    6838           0 :   case 0 : {
    6839           0 :     OS << " __attribute__((swiftcall))";
    6840           0 :     break;
    6841             :   }
    6842           0 :   case 1 : {
    6843           0 :     OS << " [[gnu::swiftcall]]";
    6844           0 :     break;
    6845             :   }
    6846             : }
    6847           0 : }
    6848             : 
    6849           0 : const char *SwiftCallAttr::getSpelling() const {
    6850           0 :   switch (SpellingListIndex) {
    6851           0 :   default:
    6852           0 :     llvm_unreachable("Unknown attribute spelling!");
    6853             :     return "(No spelling)";
    6854             :   case 0:
    6855             :     return "swiftcall";
    6856             :   case 1:
    6857             :     return "swiftcall";
    6858             :   }
    6859             : }
    6860             : 
    6861           0 : SwiftContextAttr *SwiftContextAttr::clone(ASTContext &C) const {
    6862           0 :   auto *A = new (C) SwiftContextAttr(getLocation(), C, getSpellingListIndex());
    6863           0 :   A->Inherited = Inherited;
    6864           0 :   A->IsPackExpansion = IsPackExpansion;
    6865           0 :   A->Implicit = Implicit;
    6866           0 :   return A;
    6867             : }
    6868             : 
    6869           0 : void SwiftContextAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    6870           0 :   switch (SpellingListIndex) {
    6871           0 :   default:
    6872           0 :     llvm_unreachable("Unknown attribute spelling!");
    6873             :     break;
    6874           0 :   case 0 : {
    6875           0 :     OS << " __attribute__((swift_context))";
    6876           0 :     break;
    6877             :   }
    6878           0 :   case 1 : {
    6879           0 :     OS << " [[gnu::swift_context]]";
    6880           0 :     break;
    6881             :   }
    6882             : }
    6883           0 : }
    6884             : 
    6885           0 : const char *SwiftContextAttr::getSpelling() const {
    6886           0 :   switch (SpellingListIndex) {
    6887           0 :   default:
    6888           0 :     llvm_unreachable("Unknown attribute spelling!");
    6889             :     return "(No spelling)";
    6890             :   case 0:
    6891             :     return "swift_context";
    6892             :   case 1:
    6893             :     return "swift_context";
    6894             :   }
    6895             : }
    6896             : 
    6897           0 : SwiftErrorResultAttr *SwiftErrorResultAttr::clone(ASTContext &C) const {
    6898           0 :   auto *A = new (C) SwiftErrorResultAttr(getLocation(), C, getSpellingListIndex());
    6899           0 :   A->Inherited = Inherited;
    6900           0 :   A->IsPackExpansion = IsPackExpansion;
    6901           0 :   A->Implicit = Implicit;
    6902           0 :   return A;
    6903             : }
    6904             : 
    6905           0 : void SwiftErrorResultAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    6906           0 :   switch (SpellingListIndex) {
    6907           0 :   default:
    6908           0 :     llvm_unreachable("Unknown attribute spelling!");
    6909             :     break;
    6910           0 :   case 0 : {
    6911           0 :     OS << " __attribute__((swift_error_result))";
    6912           0 :     break;
    6913             :   }
    6914           0 :   case 1 : {
    6915           0 :     OS << " [[gnu::swift_error_result]]";
    6916           0 :     break;
    6917             :   }
    6918             : }
    6919           0 : }
    6920             : 
    6921           0 : const char *SwiftErrorResultAttr::getSpelling() const {
    6922           0 :   switch (SpellingListIndex) {
    6923           0 :   default:
    6924           0 :     llvm_unreachable("Unknown attribute spelling!");
    6925             :     return "(No spelling)";
    6926             :   case 0:
    6927             :     return "swift_error_result";
    6928             :   case 1:
    6929             :     return "swift_error_result";
    6930             :   }
    6931             : }
    6932             : 
    6933           0 : SwiftIndirectResultAttr *SwiftIndirectResultAttr::clone(ASTContext &C) const {
    6934           0 :   auto *A = new (C) SwiftIndirectResultAttr(getLocation(), C, getSpellingListIndex());
    6935           0 :   A->Inherited = Inherited;
    6936           0 :   A->IsPackExpansion = IsPackExpansion;
    6937           0 :   A->Implicit = Implicit;
    6938           0 :   return A;
    6939             : }
    6940             : 
    6941           0 : void SwiftIndirectResultAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    6942           0 :   switch (SpellingListIndex) {
    6943           0 :   default:
    6944           0 :     llvm_unreachable("Unknown attribute spelling!");
    6945             :     break;
    6946           0 :   case 0 : {
    6947           0 :     OS << " __attribute__((swift_indirect_result))";
    6948           0 :     break;
    6949             :   }
    6950           0 :   case 1 : {
    6951           0 :     OS << " [[gnu::swift_indirect_result]]";
    6952           0 :     break;
    6953             :   }
    6954             : }
    6955           0 : }
    6956             : 
    6957           0 : const char *SwiftIndirectResultAttr::getSpelling() const {
    6958           0 :   switch (SpellingListIndex) {
    6959           0 :   default:
    6960           0 :     llvm_unreachable("Unknown attribute spelling!");
    6961             :     return "(No spelling)";
    6962             :   case 0:
    6963             :     return "swift_indirect_result";
    6964             :   case 1:
    6965             :     return "swift_indirect_result";
    6966             :   }
    6967             : }
    6968             : 
    6969           0 : SysVABIAttr *SysVABIAttr::clone(ASTContext &C) const {
    6970           0 :   auto *A = new (C) SysVABIAttr(getLocation(), C, getSpellingListIndex());
    6971           0 :   A->Inherited = Inherited;
    6972           0 :   A->IsPackExpansion = IsPackExpansion;
    6973           0 :   A->Implicit = Implicit;
    6974           0 :   return A;
    6975             : }
    6976             : 
    6977           0 : void SysVABIAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    6978           0 :   switch (SpellingListIndex) {
    6979           0 :   default:
    6980           0 :     llvm_unreachable("Unknown attribute spelling!");
    6981             :     break;
    6982           0 :   case 0 : {
    6983           0 :     OS << " __attribute__((sysv_abi))";
    6984           0 :     break;
    6985             :   }
    6986           0 :   case 1 : {
    6987           0 :     OS << " [[gnu::sysv_abi]]";
    6988           0 :     break;
    6989             :   }
    6990             : }
    6991           0 : }
    6992             : 
    6993           0 : const char *SysVABIAttr::getSpelling() const {
    6994           0 :   switch (SpellingListIndex) {
    6995           0 :   default:
    6996           0 :     llvm_unreachable("Unknown attribute spelling!");
    6997             :     return "(No spelling)";
    6998             :   case 0:
    6999             :     return "sysv_abi";
    7000             :   case 1:
    7001             :     return "sysv_abi";
    7002             :   }
    7003             : }
    7004             : 
    7005           3 : TLSModelAttr *TLSModelAttr::clone(ASTContext &C) const {
    7006          18 :   auto *A = new (C) TLSModelAttr(getLocation(), C, getModel(), getSpellingListIndex());
    7007           3 :   A->Inherited = Inherited;
    7008           3 :   A->IsPackExpansion = IsPackExpansion;
    7009           3 :   A->Implicit = Implicit;
    7010           3 :   return A;
    7011             : }
    7012             : 
    7013           0 : void TLSModelAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    7014           0 :   switch (SpellingListIndex) {
    7015           0 :   default:
    7016           0 :     llvm_unreachable("Unknown attribute spelling!");
    7017             :     break;
    7018           0 :   case 0 : {
    7019           0 :     OS << " __attribute__((tls_model(\"" << getModel() << "\")))";
    7020           0 :     break;
    7021             :   }
    7022           0 :   case 1 : {
    7023           0 :     OS << " [[gnu::tls_model(\"" << getModel() << "\")]]";
    7024           0 :     break;
    7025             :   }
    7026             : }
    7027           0 : }
    7028             : 
    7029           0 : const char *TLSModelAttr::getSpelling() const {
    7030           0 :   switch (SpellingListIndex) {
    7031           0 :   default:
    7032           0 :     llvm_unreachable("Unknown attribute spelling!");
    7033             :     return "(No spelling)";
    7034             :   case 0:
    7035             :     return "tls_model";
    7036             :   case 1:
    7037             :     return "tls_model";
    7038             :   }
    7039             : }
    7040             : 
    7041           5 : TargetAttr *TargetAttr::clone(ASTContext &C) const {
    7042          30 :   auto *A = new (C) TargetAttr(getLocation(), C, getFeaturesStr(), getSpellingListIndex());
    7043           5 :   A->Inherited = Inherited;
    7044           5 :   A->IsPackExpansion = IsPackExpansion;
    7045           5 :   A->Implicit = Implicit;
    7046           5 :   return A;
    7047             : }
    7048             : 
    7049           0 : void TargetAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    7050           0 :   switch (SpellingListIndex) {
    7051           0 :   default:
    7052           0 :     llvm_unreachable("Unknown attribute spelling!");
    7053             :     break;
    7054           0 :   case 0 : {
    7055           0 :     OS << " __attribute__((target(\"" << getFeaturesStr() << "\")))";
    7056           0 :     break;
    7057             :   }
    7058           0 :   case 1 : {
    7059           0 :     OS << " [[gnu::target(\"" << getFeaturesStr() << "\")]]";
    7060           0 :     break;
    7061             :   }
    7062             : }
    7063           0 : }
    7064             : 
    7065           0 : const char *TargetAttr::getSpelling() const {
    7066           0 :   switch (SpellingListIndex) {
    7067           0 :   default:
    7068           0 :     llvm_unreachable("Unknown attribute spelling!");
    7069             :     return "(No spelling)";
    7070             :   case 0:
    7071             :     return "target";
    7072             :   case 1:
    7073             :     return "target";
    7074             :   }
    7075             : }
    7076             : 
    7077           8 : TestTypestateAttr *TestTypestateAttr::clone(ASTContext &C) const {
    7078          40 :   auto *A = new (C) TestTypestateAttr(getLocation(), C, testState, getSpellingListIndex());
    7079           8 :   A->Inherited = Inherited;
    7080           8 :   A->IsPackExpansion = IsPackExpansion;
    7081           8 :   A->Implicit = Implicit;
    7082           8 :   return A;
    7083             : }
    7084             : 
    7085           0 : void TestTypestateAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    7086           0 :   switch (SpellingListIndex) {
    7087           0 :   default:
    7088           0 :     llvm_unreachable("Unknown attribute spelling!");
    7089             :     break;
    7090           0 :   case 0 : {
    7091           0 :     OS << " __attribute__((test_typestate(\"" << TestTypestateAttr::ConvertConsumedStateToStr(getTestState()) << "\")))";
    7092             :     break;
    7093             :   }
    7094             : }
    7095           0 : }
    7096             : 
    7097           0 : const char *TestTypestateAttr::getSpelling() const {
    7098           0 :   switch (SpellingListIndex) {
    7099           0 :   default:
    7100           0 :     llvm_unreachable("Unknown attribute spelling!");
    7101             :     return "(No spelling)";
    7102           0 :   case 0:
    7103             :     return "test_typestate";
    7104             :   }
    7105             : }
    7106             : 
    7107           0 : ThisCallAttr *ThisCallAttr::clone(ASTContext &C) const {
    7108           0 :   auto *A = new (C) ThisCallAttr(getLocation(), C, getSpellingListIndex());
    7109           0 :   A->Inherited = Inherited;
    7110           0 :   A->IsPackExpansion = IsPackExpansion;
    7111           0 :   A->Implicit = Implicit;
    7112           0 :   return A;
    7113             : }
    7114             : 
    7115           0 : void ThisCallAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    7116           0 :   switch (SpellingListIndex) {
    7117           0 :   default:
    7118           0 :     llvm_unreachable("Unknown attribute spelling!");
    7119             :     break;
    7120           0 :   case 0 : {
    7121           0 :     OS << " __attribute__((thiscall))";
    7122           0 :     break;
    7123             :   }
    7124           0 :   case 1 : {
    7125           0 :     OS << " [[gnu::thiscall]]";
    7126           0 :     break;
    7127             :   }
    7128           0 :   case 2 : {
    7129           0 :     OS << " __thiscall";
    7130           0 :     break;
    7131             :   }
    7132           0 :   case 3 : {
    7133           0 :     OS << " _thiscall";
    7134           0 :     break;
    7135             :   }
    7136             : }
    7137           0 : }
    7138             : 
    7139           0 : const char *ThisCallAttr::getSpelling() const {
    7140           0 :   switch (SpellingListIndex) {
    7141           0 :   default:
    7142           0 :     llvm_unreachable("Unknown attribute spelling!");
    7143             :     return "(No spelling)";
    7144             :   case 0:
    7145             :     return "thiscall";
    7146             :   case 1:
    7147             :     return "thiscall";
    7148           0 :   case 2:
    7149           0 :     return "__thiscall";
    7150           0 :   case 3:
    7151           0 :     return "_thiscall";
    7152             :   }
    7153             : }
    7154             : 
    7155           0 : ThreadAttr *ThreadAttr::clone(ASTContext &C) const {
    7156           0 :   auto *A = new (C) ThreadAttr(getLocation(), C, getSpellingListIndex());
    7157           0 :   A->Inherited = Inherited;
    7158           0 :   A->IsPackExpansion = IsPackExpansion;
    7159           0 :   A->Implicit = Implicit;
    7160           0 :   return A;
    7161             : }
    7162             : 
    7163           1 : void ThreadAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    7164           1 :   switch (SpellingListIndex) {
    7165           0 :   default:
    7166           0 :     llvm_unreachable("Unknown attribute spelling!");
    7167             :     break;
    7168           1 :   case 0 : {
    7169           1 :     OS << " __declspec(thread)";
    7170             :     break;
    7171             :   }
    7172             : }
    7173           1 : }
    7174             : 
    7175           0 : const char *ThreadAttr::getSpelling() const {
    7176           0 :   switch (SpellingListIndex) {
    7177           0 :   default:
    7178           0 :     llvm_unreachable("Unknown attribute spelling!");
    7179             :     return "(No spelling)";
    7180           0 :   case 0:
    7181             :     return "thread";
    7182             :   }
    7183             : }
    7184             : 
    7185           0 : TransparentUnionAttr *TransparentUnionAttr::clone(ASTContext &C) const {
    7186           0 :   auto *A = new (C) TransparentUnionAttr(getLocation(), C, getSpellingListIndex());
    7187           0 :   A->Inherited = Inherited;
    7188           0 :   A->IsPackExpansion = IsPackExpansion;
    7189           0 :   A->Implicit = Implicit;
    7190           0 :   return A;
    7191             : }
    7192             : 
    7193           0 : void TransparentUnionAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    7194           0 :   switch (SpellingListIndex) {
    7195           0 :   default:
    7196           0 :     llvm_unreachable("Unknown attribute spelling!");
    7197             :     break;
    7198           0 :   case 0 : {
    7199           0 :     OS << " __attribute__((transparent_union))";
    7200           0 :     break;
    7201             :   }
    7202           0 :   case 1 : {
    7203           0 :     OS << " [[gnu::transparent_union]]";
    7204           0 :     break;
    7205             :   }
    7206             : }
    7207           0 : }
    7208             : 
    7209           0 : const char *TransparentUnionAttr::getSpelling() const {
    7210           0 :   switch (SpellingListIndex) {
    7211           0 :   default:
    7212           0 :     llvm_unreachable("Unknown attribute spelling!");
    7213             :     return "(No spelling)";
    7214             :   case 0:
    7215             :     return "transparent_union";
    7216             :   case 1:
    7217             :     return "transparent_union";
    7218             :   }
    7219             : }
    7220             : 
    7221           0 : TryAcquireCapabilityAttr *TryAcquireCapabilityAttr::clone(ASTContext &C) const {
    7222           0 :   auto *A = new (C) TryAcquireCapabilityAttr(getLocation(), C, successValue, args_, args_Size, getSpellingListIndex());
    7223           0 :   A->Inherited = Inherited;
    7224           0 :   A->IsPackExpansion = IsPackExpansion;
    7225           0 :   A->Implicit = Implicit;
    7226           0 :   return A;
    7227             : }
    7228             : 
    7229           0 : void TryAcquireCapabilityAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    7230           0 :   switch (SpellingListIndex) {
    7231           0 :   default:
    7232           0 :     llvm_unreachable("Unknown attribute spelling!");
    7233             :     break;
    7234           0 :   case 0 : {
    7235           0 :     OS << " __attribute__((try_acquire_capability(" << getSuccessValue() << ", ";
    7236           0 :   bool isFirst = true;
    7237           0 :   for (const auto &Val : args()) {
    7238           0 :     if (isFirst) isFirst = false;
    7239           0 :     else OS << ", ";
    7240           0 :     OS << Val;
    7241             :   }
    7242           0 :   OS << ")))";
    7243           0 :     break;
    7244             :   }
    7245           0 :   case 1 : {
    7246           0 :     OS << " [[clang::try_acquire_capability(" << getSuccessValue() << ", ";
    7247           0 :   bool isFirst = true;
    7248           0 :   for (const auto &Val : args()) {
    7249           0 :     if (isFirst) isFirst = false;
    7250           0 :     else OS << ", ";
    7251           0 :     OS << Val;
    7252             :   }
    7253           0 :   OS << ")]]";
    7254           0 :     break;
    7255             :   }
    7256           0 :   case 2 : {
    7257           0 :     OS << " __attribute__((try_acquire_shared_capability(" << getSuccessValue() << ", ";
    7258           0 :   bool isFirst = true;
    7259           0 :   for (const auto &Val : args()) {
    7260           0 :     if (isFirst) isFirst = false;
    7261           0 :     else OS << ", ";
    7262           0 :     OS << Val;
    7263             :   }
    7264           0 :   OS << ")))";
    7265           0 :     break;
    7266             :   }
    7267           0 :   case 3 : {
    7268           0 :     OS << " [[clang::try_acquire_shared_capability(" << getSuccessValue() << ", ";
    7269           0 :   bool isFirst = true;
    7270           0 :   for (const auto &Val : args()) {
    7271           0 :     if (isFirst) isFirst = false;
    7272           0 :     else OS << ", ";
    7273           0 :     OS << Val;
    7274             :   }
    7275           0 :   OS << ")]]";
    7276           0 :     break;
    7277             :   }
    7278             : }
    7279           0 : }
    7280             : 
    7281           0 : const char *TryAcquireCapabilityAttr::getSpelling() const {
    7282           0 :   switch (SpellingListIndex) {
    7283           0 :   default:
    7284           0 :     llvm_unreachable("Unknown attribute spelling!");
    7285             :     return "(No spelling)";
    7286             :   case 0:
    7287             :     return "try_acquire_capability";
    7288             :   case 1:
    7289             :     return "try_acquire_capability";
    7290           0 :   case 2:
    7291           0 :     return "try_acquire_shared_capability";
    7292           0 :   case 3:
    7293           0 :     return "try_acquire_shared_capability";
    7294             :   }
    7295             : }
    7296             : 
    7297           0 : TypeTagForDatatypeAttr *TypeTagForDatatypeAttr::clone(ASTContext &C) const {
    7298           0 :   auto *A = new (C) TypeTagForDatatypeAttr(getLocation(), C, argumentKind, matchingCType, layoutCompatible, mustBeNull, getSpellingListIndex());
    7299           0 :   A->Inherited = Inherited;
    7300           0 :   A->IsPackExpansion = IsPackExpansion;
    7301           0 :   A->Implicit = Implicit;
    7302           0 :   return A;
    7303             : }
    7304             : 
    7305           0 : void TypeTagForDatatypeAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    7306           0 :   switch (SpellingListIndex) {
    7307           0 :   default:
    7308           0 :     llvm_unreachable("Unknown attribute spelling!");
    7309             :     break;
    7310           0 :   case 0 : {
    7311           0 :     OS << " __attribute__((type_tag_for_datatype(";
    7312           0 :     OS << getArgumentKind()->getName();
    7313           0 :     OS << ", " << getMatchingCType().getAsString() << ", " << getLayoutCompatible() << ", " << getMustBeNull() << ")))";
    7314             :     break;
    7315             :   }
    7316             : }
    7317           0 : }
    7318             : 
    7319           0 : const char *TypeTagForDatatypeAttr::getSpelling() const {
    7320           0 :   switch (SpellingListIndex) {
    7321           0 :   default:
    7322           0 :     llvm_unreachable("Unknown attribute spelling!");
    7323             :     return "(No spelling)";
    7324           0 :   case 0:
    7325             :     return "type_tag_for_datatype";
    7326             :   }
    7327             : }
    7328             : 
    7329         104 : TypeVisibilityAttr *TypeVisibilityAttr::clone(ASTContext &C) const {
    7330         520 :   auto *A = new (C) TypeVisibilityAttr(getLocation(), C, visibility, getSpellingListIndex());
    7331         104 :   A->Inherited = Inherited;
    7332         104 :   A->IsPackExpansion = IsPackExpansion;
    7333         104 :   A->Implicit = Implicit;
    7334         104 :   return A;
    7335             : }
    7336             : 
    7337           0 : void TypeVisibilityAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    7338           0 :   switch (SpellingListIndex) {
    7339           0 :   default:
    7340           0 :     llvm_unreachable("Unknown attribute spelling!");
    7341             :     break;
    7342           0 :   case 0 : {
    7343           0 :     OS << " __attribute__((type_visibility(\"" << TypeVisibilityAttr::ConvertVisibilityTypeToStr(getVisibility()) << "\")))";
    7344           0 :     break;
    7345             :   }
    7346           0 :   case 1 : {
    7347           0 :     OS << " [[clang::type_visibility(\"" << TypeVisibilityAttr::ConvertVisibilityTypeToStr(getVisibility()) << "\")]]";
    7348           0 :     break;
    7349             :   }
    7350             : }
    7351           0 : }
    7352             : 
    7353           0 : const char *TypeVisibilityAttr::getSpelling() const {
    7354           0 :   switch (SpellingListIndex) {
    7355           0 :   default:
    7356           0 :     llvm_unreachable("Unknown attribute spelling!");
    7357             :     return "(No spelling)";
    7358             :   case 0:
    7359             :     return "type_visibility";
    7360             :   case 1:
    7361             :     return "type_visibility";
    7362             :   }
    7363             : }
    7364             : 
    7365          56 : UnavailableAttr *UnavailableAttr::clone(ASTContext &C) const {
    7366         336 :   auto *A = new (C) UnavailableAttr(getLocation(), C, getMessage(), implicitReason, getSpellingListIndex());
    7367          56 :   A->Inherited = Inherited;
    7368          56 :   A->IsPackExpansion = IsPackExpansion;
    7369          56 :   A->Implicit = Implicit;
    7370          56 :   return A;
    7371             : }
    7372             : 
    7373           2 : void UnavailableAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    7374           2 :   switch (SpellingListIndex) {
    7375           0 :   default:
    7376           0 :     llvm_unreachable("Unknown attribute spelling!");
    7377             :     break;
    7378           2 :   case 0 : {
    7379           4 :     OS << " __attribute__((unavailable(\"" << getMessage() << "\")))";
    7380             :     break;
    7381             :   }
    7382             : }
    7383           2 : }
    7384             : 
    7385           0 : const char *UnavailableAttr::getSpelling() const {
    7386           0 :   switch (SpellingListIndex) {
    7387           0 :   default:
    7388           0 :     llvm_unreachable("Unknown attribute spelling!");
    7389             :     return "(No spelling)";
    7390           0 :   case 0:
    7391             :     return "unavailable";
    7392             :   }
    7393             : }
    7394             : 
    7395         316 : UnusedAttr *UnusedAttr::clone(ASTContext &C) const {
    7396        1580 :   auto *A = new (C) UnusedAttr(getLocation(), C, getSpellingListIndex());
    7397         316 :   A->Inherited = Inherited;
    7398         316 :   A->IsPackExpansion = IsPackExpansion;
    7399         316 :   A->Implicit = Implicit;
    7400         316 :   return A;
    7401             : }
    7402             : 
    7403           0 : void UnusedAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    7404           0 :   switch (SpellingListIndex) {
    7405           0 :   default:
    7406           0 :     llvm_unreachable("Unknown attribute spelling!");
    7407             :     break;
    7408           0 :   case 0 : {
    7409           0 :     OS << " [[maybe_unused]]";
    7410           0 :     break;
    7411             :   }
    7412           0 :   case 1 : {
    7413           0 :     OS << " __attribute__((unused))";
    7414           0 :     break;
    7415             :   }
    7416           0 :   case 2 : {
    7417           0 :     OS << " [[gnu::unused]]";
    7418           0 :     break;
    7419             :   }
    7420             : }
    7421           0 : }
    7422             : 
    7423           4 : const char *UnusedAttr::getSpelling() const {
    7424           4 :   switch (SpellingListIndex) {
    7425           0 :   default:
    7426           0 :     llvm_unreachable("Unknown attribute spelling!");
    7427             :     return "(No spelling)";
    7428             :   case 0:
    7429             :     return "maybe_unused";
    7430           4 :   case 1:
    7431           4 :     return "unused";
    7432           0 :   case 2:
    7433           0 :     return "unused";
    7434             :   }
    7435             : }
    7436             : 
    7437          27 : UsedAttr *UsedAttr::clone(ASTContext &C) const {
    7438         135 :   auto *A = new (C) UsedAttr(getLocation(), C, getSpellingListIndex());
    7439          27 :   A->Inherited = Inherited;
    7440          27 :   A->IsPackExpansion = IsPackExpansion;
    7441          27 :   A->Implicit = Implicit;
    7442          27 :   return A;
    7443             : }
    7444             : 
    7445           0 : void UsedAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    7446           0 :   switch (SpellingListIndex) {
    7447           0 :   default:
    7448           0 :     llvm_unreachable("Unknown attribute spelling!");
    7449             :     break;
    7450           0 :   case 0 : {
    7451           0 :     OS << " __attribute__((used))";
    7452           0 :     break;
    7453             :   }
    7454           0 :   case 1 : {
    7455           0 :     OS << " [[gnu::used]]";
    7456           0 :     break;
    7457             :   }
    7458             : }
    7459           0 : }
    7460             : 
    7461           4 : const char *UsedAttr::getSpelling() const {
    7462           4 :   switch (SpellingListIndex) {
    7463           0 :   default:
    7464           0 :     llvm_unreachable("Unknown attribute spelling!");
    7465             :     return "(No spelling)";
    7466             :   case 0:
    7467             :     return "used";
    7468             :   case 1:
    7469             :     return "used";
    7470             :   }
    7471             : }
    7472             : 
    7473           0 : UuidAttr *UuidAttr::clone(ASTContext &C) const {
    7474           0 :   auto *A = new (C) UuidAttr(getLocation(), C, getGuid(), getSpellingListIndex());
    7475           0 :   A->Inherited = Inherited;
    7476           0 :   A->IsPackExpansion = IsPackExpansion;
    7477           0 :   A->Implicit = Implicit;
    7478           0 :   return A;
    7479             : }
    7480             : 
    7481           0 : void UuidAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    7482           0 :   switch (SpellingListIndex) {
    7483           0 :   default:
    7484           0 :     llvm_unreachable("Unknown attribute spelling!");
    7485             :     break;
    7486           0 :   case 0 : {
    7487           0 :     OS << " __declspec(uuid(\"" << getGuid() << "\"))";
    7488           0 :     break;
    7489             :   }
    7490           0 :   case 1 : {
    7491           0 :     OS << "[uuid(\"" << getGuid() << "\")]";
    7492           0 :     break;
    7493             :   }
    7494             : }
    7495           0 : }
    7496             : 
    7497           0 : const char *UuidAttr::getSpelling() const {
    7498           0 :   switch (SpellingListIndex) {
    7499           0 :   default:
    7500           0 :     llvm_unreachable("Unknown attribute spelling!");
    7501             :     return "(No spelling)";
    7502             :   case 0:
    7503             :     return "uuid";
    7504             :   case 1:
    7505             :     return "uuid";
    7506             :   }
    7507             : }
    7508             : 
    7509           0 : VecReturnAttr *VecReturnAttr::clone(ASTContext &C) const {
    7510           0 :   auto *A = new (C) VecReturnAttr(getLocation(), C, getSpellingListIndex());
    7511           0 :   A->Inherited = Inherited;
    7512           0 :   A->IsPackExpansion = IsPackExpansion;
    7513           0 :   A->Implicit = Implicit;
    7514           0 :   return A;
    7515             : }
    7516             : 
    7517           0 : void VecReturnAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    7518           0 :   switch (SpellingListIndex) {
    7519           0 :   default:
    7520           0 :     llvm_unreachable("Unknown attribute spelling!");
    7521             :     break;
    7522           0 :   case 0 : {
    7523           0 :     OS << " __attribute__((vecreturn))";
    7524             :     break;
    7525             :   }
    7526             : }
    7527           0 : }
    7528             : 
    7529           1 : const char *VecReturnAttr::getSpelling() const {
    7530           1 :   switch (SpellingListIndex) {
    7531           0 :   default:
    7532           0 :     llvm_unreachable("Unknown attribute spelling!");
    7533             :     return "(No spelling)";
    7534           1 :   case 0:
    7535             :     return "vecreturn";
    7536             :   }
    7537             : }
    7538             : 
    7539           0 : VecTypeHintAttr *VecTypeHintAttr::clone(ASTContext &C) const {
    7540           0 :   auto *A = new (C) VecTypeHintAttr(getLocation(), C, typeHint, getSpellingListIndex());
    7541           0 :   A->Inherited = Inherited;
    7542           0 :   A->IsPackExpansion = IsPackExpansion;
    7543           0 :   A->Implicit = Implicit;
    7544           0 :   return A;
    7545             : }
    7546             : 
    7547           0 : void VecTypeHintAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    7548           0 :   switch (SpellingListIndex) {
    7549           0 :   default:
    7550           0 :     llvm_unreachable("Unknown attribute spelling!");
    7551             :     break;
    7552           0 :   case 0 : {
    7553           0 :     OS << " __attribute__((vec_type_hint(" << getTypeHint().getAsString() << ")))";
    7554             :     break;
    7555             :   }
    7556             : }
    7557           0 : }
    7558             : 
    7559           1 : const char *VecTypeHintAttr::getSpelling() const {
    7560           1 :   switch (SpellingListIndex) {
    7561           0 :   default:
    7562           0 :     llvm_unreachable("Unknown attribute spelling!");
    7563             :     return "(No spelling)";
    7564           1 :   case 0:
    7565             :     return "vec_type_hint";
    7566             :   }
    7567             : }
    7568             : 
    7569           0 : VectorCallAttr *VectorCallAttr::clone(ASTContext &C) const {
    7570           0 :   auto *A = new (C) VectorCallAttr(getLocation(), C, getSpellingListIndex());
    7571           0 :   A->Inherited = Inherited;
    7572           0 :   A->IsPackExpansion = IsPackExpansion;
    7573           0 :   A->Implicit = Implicit;
    7574           0 :   return A;
    7575             : }
    7576             : 
    7577           0 : void VectorCallAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    7578           0 :   switch (SpellingListIndex) {
    7579           0 :   default:
    7580           0 :     llvm_unreachable("Unknown attribute spelling!");
    7581             :     break;
    7582           0 :   case 0 : {
    7583           0 :     OS << " __attribute__((vectorcall))";
    7584           0 :     break;
    7585             :   }
    7586           0 :   case 1 : {
    7587           0 :     OS << " __vectorcall";
    7588           0 :     break;
    7589             :   }
    7590           0 :   case 2 : {
    7591           0 :     OS << " _vectorcall";
    7592           0 :     break;
    7593             :   }
    7594             : }
    7595           0 : }
    7596             : 
    7597           0 : const char *VectorCallAttr::getSpelling() const {
    7598           0 :   switch (SpellingListIndex) {
    7599           0 :   default:
    7600           0 :     llvm_unreachable("Unknown attribute spelling!");
    7601             :     return "(No spelling)";
    7602             :   case 0:
    7603             :     return "vectorcall";
    7604           0 :   case 1:
    7605           0 :     return "__vectorcall";
    7606           0 :   case 2:
    7607           0 :     return "_vectorcall";
    7608             :   }
    7609             : }
    7610             : 
    7611           8 : VisibilityAttr *VisibilityAttr::clone(ASTContext &C) const {
    7612          40 :   auto *A = new (C) VisibilityAttr(getLocation(), C, visibility, getSpellingListIndex());
    7613           8 :   A->Inherited = Inherited;
    7614           8 :   A->IsPackExpansion = IsPackExpansion;
    7615           8 :   A->Implicit = Implicit;
    7616           8 :   return A;
    7617             : }
    7618             : 
    7619           4 : void VisibilityAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    7620           4 :   switch (SpellingListIndex) {
    7621           0 :   default:
    7622           0 :     llvm_unreachable("Unknown attribute spelling!");
    7623             :     break;
    7624           3 :   case 0 : {
    7625           6 :     OS << " __attribute__((visibility(\"" << VisibilityAttr::ConvertVisibilityTypeToStr(getVisibility()) << "\")))";
    7626           3 :     break;
    7627             :   }
    7628           1 :   case 1 : {
    7629           2 :     OS << " [[gnu::visibility(\"" << VisibilityAttr::ConvertVisibilityTypeToStr(getVisibility()) << "\")]]";
    7630           1 :     break;
    7631             :   }
    7632             : }
    7633           4 : }
    7634             : 
    7635           0 : const char *VisibilityAttr::getSpelling() const {
    7636           0 :   switch (SpellingListIndex) {
    7637           0 :   default:
    7638           0 :     llvm_unreachable("Unknown attribute spelling!");
    7639             :     return "(No spelling)";
    7640             :   case 0:
    7641             :     return "visibility";
    7642             :   case 1:
    7643             :     return "visibility";
    7644             :   }
    7645             : }
    7646             : 
    7647           0 : WarnUnusedAttr *WarnUnusedAttr::clone(ASTContext &C) const {
    7648           0 :   auto *A = new (C) WarnUnusedAttr(getLocation(), C, getSpellingListIndex());
    7649           0 :   A->Inherited = Inherited;
    7650           0 :   A->IsPackExpansion = IsPackExpansion;
    7651           0 :   A->Implicit = Implicit;
    7652           0 :   return A;
    7653             : }
    7654             : 
    7655           0 : void WarnUnusedAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    7656           0 :   switch (SpellingListIndex) {
    7657           0 :   default:
    7658           0 :     llvm_unreachable("Unknown attribute spelling!");
    7659             :     break;
    7660           0 :   case 0 : {
    7661           0 :     OS << " __attribute__((warn_unused))";
    7662             :     break;
    7663             :   }
    7664             : }
    7665           0 : }
    7666             : 
    7667           0 : const char *WarnUnusedAttr::getSpelling() const {
    7668           0 :   switch (SpellingListIndex) {
    7669           0 :   default:
    7670           0 :     llvm_unreachable("Unknown attribute spelling!");
    7671             :     return "(No spelling)";
    7672           0 :   case 0:
    7673             :     return "warn_unused";
    7674             :   }
    7675             : }
    7676             : 
    7677         284 : WarnUnusedResultAttr *WarnUnusedResultAttr::clone(ASTContext &C) const {
    7678        1420 :   auto *A = new (C) WarnUnusedResultAttr(getLocation(), C, getSpellingListIndex());
    7679         284 :   A->Inherited = Inherited;
    7680         284 :   A->IsPackExpansion = IsPackExpansion;
    7681         284 :   A->Implicit = Implicit;
    7682         284 :   return A;
    7683             : }
    7684             : 
    7685           3 : void WarnUnusedResultAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    7686           3 :   switch (SpellingListIndex) {
    7687           0 :   default:
    7688           0 :     llvm_unreachable("Unknown attribute spelling!");
    7689             :     break;
    7690           0 :   case 0 : {
    7691           0 :     OS << " [[nodiscard]]";
    7692           0 :     break;
    7693             :   }
    7694           1 :   case 1 : {
    7695           1 :     OS << " [[clang::warn_unused_result]]";
    7696           1 :     break;
    7697             :   }
    7698           1 :   case 2 : {
    7699           1 :     OS << " __attribute__((warn_unused_result))";
    7700           1 :     break;
    7701             :   }
    7702           1 :   case 3 : {
    7703           1 :     OS << " [[gnu::warn_unused_result]]";
    7704           1 :     break;
    7705             :   }
    7706             : }
    7707           3 : }
    7708             : 
    7709          38 : const char *WarnUnusedResultAttr::getSpelling() const {
    7710          38 :   switch (SpellingListIndex) {
    7711           0 :   default:
    7712           0 :     llvm_unreachable("Unknown attribute spelling!");
    7713             :     return "(No spelling)";
    7714             :   case 0:
    7715             :     return "nodiscard";
    7716          16 :   case 1:
    7717          16 :     return "warn_unused_result";
    7718          15 :   case 2:
    7719          15 :     return "warn_unused_result";
    7720           0 :   case 3:
    7721           0 :     return "warn_unused_result";
    7722             :   }
    7723             : }
    7724             : 
    7725          42 : WeakAttr *WeakAttr::clone(ASTContext &C) const {
    7726         210 :   auto *A = new (C) WeakAttr(getLocation(), C, getSpellingListIndex());
    7727          42 :   A->Inherited = Inherited;
    7728          42 :   A->IsPackExpansion = IsPackExpansion;
    7729          42 :   A->Implicit = Implicit;
    7730          42 :   return A;
    7731             : }
    7732             : 
    7733           0 : void WeakAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    7734           0 :   switch (SpellingListIndex) {
    7735           0 :   default:
    7736           0 :     llvm_unreachable("Unknown attribute spelling!");
    7737             :     break;
    7738           0 :   case 0 : {
    7739           0 :     OS << " __attribute__((weak))";
    7740           0 :     break;
    7741             :   }
    7742           0 :   case 1 : {
    7743           0 :     OS << " [[gnu::weak]]";
    7744           0 :     break;
    7745             :   }
    7746             : }
    7747           0 : }
    7748             : 
    7749           0 : const char *WeakAttr::getSpelling() const {
    7750           0 :   switch (SpellingListIndex) {
    7751           0 :   default:
    7752           0 :     llvm_unreachable("Unknown attribute spelling!");
    7753             :     return "(No spelling)";
    7754             :   case 0:
    7755             :     return "weak";
    7756             :   case 1:
    7757             :     return "weak";
    7758             :   }
    7759             : }
    7760             : 
    7761           8 : WeakImportAttr *WeakImportAttr::clone(ASTContext &C) const {
    7762          40 :   auto *A = new (C) WeakImportAttr(getLocation(), C, getSpellingListIndex());
    7763           8 :   A->Inherited = Inherited;
    7764           8 :   A->IsPackExpansion = IsPackExpansion;
    7765           8 :   A->Implicit = Implicit;
    7766           8 :   return A;
    7767             : }
    7768             : 
    7769           0 : void WeakImportAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    7770           0 :   switch (SpellingListIndex) {
    7771           0 :   default:
    7772           0 :     llvm_unreachable("Unknown attribute spelling!");
    7773             :     break;
    7774           0 :   case 0 : {
    7775           0 :     OS << " __attribute__((weak_import))";
    7776             :     break;
    7777             :   }
    7778             : }
    7779           0 : }
    7780             : 
    7781           0 : const char *WeakImportAttr::getSpelling() const {
    7782           0 :   switch (SpellingListIndex) {
    7783           0 :   default:
    7784           0 :     llvm_unreachable("Unknown attribute spelling!");
    7785             :     return "(No spelling)";
    7786           0 :   case 0:
    7787             :     return "weak_import";
    7788             :   }
    7789             : }
    7790             : 
    7791           0 : WeakRefAttr *WeakRefAttr::clone(ASTContext &C) const {
    7792           0 :   auto *A = new (C) WeakRefAttr(getLocation(), C, getAliasee(), getSpellingListIndex());
    7793           0 :   A->Inherited = Inherited;
    7794           0 :   A->IsPackExpansion = IsPackExpansion;
    7795           0 :   A->Implicit = Implicit;
    7796           0 :   return A;
    7797             : }
    7798             : 
    7799           0 : void WeakRefAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    7800           0 :   switch (SpellingListIndex) {
    7801           0 :   default:
    7802           0 :     llvm_unreachable("Unknown attribute spelling!");
    7803             :     break;
    7804           0 :   case 0 : {
    7805           0 :     OS << " __attribute__((weakref(\"" << getAliasee() << "\")))";
    7806           0 :     break;
    7807             :   }
    7808           0 :   case 1 : {
    7809           0 :     OS << " [[gnu::weakref(\"" << getAliasee() << "\")]]";
    7810           0 :     break;
    7811             :   }
    7812             : }
    7813           0 : }
    7814             : 
    7815           0 : const char *WeakRefAttr::getSpelling() const {
    7816           0 :   switch (SpellingListIndex) {
    7817           0 :   default:
    7818           0 :     llvm_unreachable("Unknown attribute spelling!");
    7819             :     return "(No spelling)";
    7820             :   case 0:
    7821             :     return "weakref";
    7822             :   case 1:
    7823             :     return "weakref";
    7824             :   }
    7825             : }
    7826             : 
    7827           0 : WorkGroupSizeHintAttr *WorkGroupSizeHintAttr::clone(ASTContext &C) const {
    7828           0 :   auto *A = new (C) WorkGroupSizeHintAttr(getLocation(), C, xDim, yDim, zDim, getSpellingListIndex());
    7829           0 :   A->Inherited = Inherited;
    7830           0 :   A->IsPackExpansion = IsPackExpansion;
    7831           0 :   A->Implicit = Implicit;
    7832           0 :   return A;
    7833             : }
    7834             : 
    7835           0 : void WorkGroupSizeHintAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    7836           0 :   switch (SpellingListIndex) {
    7837           0 :   default:
    7838           0 :     llvm_unreachable("Unknown attribute spelling!");
    7839             :     break;
    7840           0 :   case 0 : {
    7841           0 :     OS << " __attribute__((work_group_size_hint(" << getXDim() << ", " << getYDim() << ", " << getZDim() << ")))";
    7842             :     break;
    7843             :   }
    7844             : }
    7845           0 : }
    7846             : 
    7847           1 : const char *WorkGroupSizeHintAttr::getSpelling() const {
    7848           1 :   switch (SpellingListIndex) {
    7849           0 :   default:
    7850           0 :     llvm_unreachable("Unknown attribute spelling!");
    7851             :     return "(No spelling)";
    7852           1 :   case 0:
    7853             :     return "work_group_size_hint";
    7854             :   }
    7855             : }
    7856             : 
    7857           1 : X86ForceAlignArgPointerAttr *X86ForceAlignArgPointerAttr::clone(ASTContext &C) const {
    7858           5 :   auto *A = new (C) X86ForceAlignArgPointerAttr(getLocation(), C, getSpellingListIndex());
    7859           1 :   A->Inherited = Inherited;
    7860           1 :   A->IsPackExpansion = IsPackExpansion;
    7861           1 :   A->Implicit = Implicit;
    7862           1 :   return A;
    7863             : }
    7864             : 
    7865           0 : void X86ForceAlignArgPointerAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    7866           0 :   switch (SpellingListIndex) {
    7867           0 :   default:
    7868           0 :     llvm_unreachable("Unknown attribute spelling!");
    7869             :     break;
    7870           0 :   case 0 : {
    7871           0 :     OS << " __attribute__((force_align_arg_pointer))";
    7872           0 :     break;
    7873             :   }
    7874           0 :   case 1 : {
    7875           0 :     OS << " [[gnu::force_align_arg_pointer]]";
    7876           0 :     break;
    7877             :   }
    7878             : }
    7879           0 : }
    7880             : 
    7881           0 : const char *X86ForceAlignArgPointerAttr::getSpelling() const {
    7882           0 :   switch (SpellingListIndex) {
    7883           0 :   default:
    7884           0 :     llvm_unreachable("Unknown attribute spelling!");
    7885             :     return "(No spelling)";
    7886             :   case 0:
    7887             :     return "force_align_arg_pointer";
    7888             :   case 1:
    7889             :     return "force_align_arg_pointer";
    7890             :   }
    7891             : }
    7892             : 
    7893           0 : XRayInstrumentAttr *XRayInstrumentAttr::clone(ASTContext &C) const {
    7894           0 :   auto *A = new (C) XRayInstrumentAttr(getLocation(), C, getSpellingListIndex());
    7895           0 :   A->Inherited = Inherited;
    7896           0 :   A->IsPackExpansion = IsPackExpansion;
    7897           0 :   A->Implicit = Implicit;
    7898           0 :   return A;
    7899             : }
    7900             : 
    7901           0 : void XRayInstrumentAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    7902           0 :   switch (SpellingListIndex) {
    7903           0 :   default:
    7904           0 :     llvm_unreachable("Unknown attribute spelling!");
    7905             :     break;
    7906           0 :   case 0 : {
    7907           0 :     OS << " __attribute__((xray_always_instrument))";
    7908           0 :     break;
    7909             :   }
    7910           0 :   case 1 : {
    7911           0 :     OS << " [[clang::xray_always_instrument]]";
    7912           0 :     break;
    7913             :   }
    7914           0 :   case 2 : {
    7915           0 :     OS << " __attribute__((xray_never_instrument))";
    7916           0 :     break;
    7917             :   }
    7918           0 :   case 3 : {
    7919           0 :     OS << " [[clang::xray_never_instrument]]";
    7920           0 :     break;
    7921             :   }
    7922             : }
    7923           0 : }
    7924             : 
    7925           0 : const char *XRayInstrumentAttr::getSpelling() const {
    7926           0 :   switch (SpellingListIndex) {
    7927           0 :   default:
    7928           0 :     llvm_unreachable("Unknown attribute spelling!");
    7929             :     return "(No spelling)";
    7930             :   case 0:
    7931             :     return "xray_always_instrument";
    7932             :   case 1:
    7933             :     return "xray_always_instrument";
    7934           0 :   case 2:
    7935           0 :     return "xray_never_instrument";
    7936           0 :   case 3:
    7937           0 :     return "xray_never_instrument";
    7938             :   }
    7939             : }
    7940             : 
    7941           0 : XRayLogArgsAttr *XRayLogArgsAttr::clone(ASTContext &C) const {
    7942           0 :   auto *A = new (C) XRayLogArgsAttr(getLocation(), C, argumentCount, getSpellingListIndex());
    7943           0 :   A->Inherited = Inherited;
    7944           0 :   A->IsPackExpansion = IsPackExpansion;
    7945           0 :   A->Implicit = Implicit;
    7946           0 :   return A;
    7947             : }
    7948             : 
    7949           0 : void XRayLogArgsAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    7950           0 :   switch (SpellingListIndex) {
    7951           0 :   default:
    7952           0 :     llvm_unreachable("Unknown attribute spelling!");
    7953             :     break;
    7954           0 :   case 0 : {
    7955           0 :     OS << " __attribute__((xray_log_args(" << getArgumentCount() << ")))";
    7956           0 :     break;
    7957             :   }
    7958           0 :   case 1 : {
    7959           0 :     OS << " [[clang::xray_log_args(" << getArgumentCount() << ")]]";
    7960           0 :     break;
    7961             :   }
    7962             : }
    7963           0 : }
    7964             : 
    7965           0 : const char *XRayLogArgsAttr::getSpelling() const {
    7966           0 :   switch (SpellingListIndex) {
    7967           0 :   default:
    7968           0 :     llvm_unreachable("Unknown attribute spelling!");
    7969             :     return "(No spelling)";
    7970             :   case 0:
    7971             :     return "xray_log_args";
    7972             :   case 1:
    7973             :     return "xray_log_args";
    7974             :   }
    7975             : }
    7976             : 
    7977        1386 : const char *Attr::getSpelling() const {
    7978        1386 :   switch (getKind()) {
    7979          12 :   case attr::AMDGPUFlatWorkGroupSize:
    7980          12 :     return cast<AMDGPUFlatWorkGroupSizeAttr>(this)->getSpelling();
    7981           3 :   case attr::AMDGPUNumSGPR:
    7982           3 :     return cast<AMDGPUNumSGPRAttr>(this)->getSpelling();
    7983           2 :   case attr::AMDGPUNumVGPR:
    7984           2 :     return cast<AMDGPUNumVGPRAttr>(this)->getSpelling();
    7985           8 :   case attr::AMDGPUWavesPerEU:
    7986           8 :     return cast<AMDGPUWavesPerEUAttr>(this)->getSpelling();
    7987           0 :   case attr::ARMInterrupt:
    7988           0 :     return cast<ARMInterruptAttr>(this)->getSpelling();
    7989           0 :   case attr::AVRInterrupt:
    7990           0 :     return cast<AVRInterruptAttr>(this)->getSpelling();
    7991           0 :   case attr::AVRSignal:
    7992           0 :     return cast<AVRSignalAttr>(this)->getSpelling();
    7993           0 :   case attr::AbiTag:
    7994           0 :     return cast<AbiTagAttr>(this)->getSpelling();
    7995           0 :   case attr::AcquireCapability:
    7996           0 :     return cast<AcquireCapabilityAttr>(this)->getSpelling();
    7997           0 :   case attr::AcquiredAfter:
    7998           0 :     return cast<AcquiredAfterAttr>(this)->getSpelling();
    7999           0 :   case attr::AcquiredBefore:
    8000           0 :     return cast<AcquiredBeforeAttr>(this)->getSpelling();
    8001           0 :   case attr::Alias:
    8002           0 :     return cast<AliasAttr>(this)->getSpelling();
    8003           0 :   case attr::AlignMac68k:
    8004           0 :     return cast<AlignMac68kAttr>(this)->getSpelling();
    8005           1 :   case attr::AlignValue:
    8006           1 :     return cast<AlignValueAttr>(this)->getSpelling();
    8007          37 :   case attr::Aligned:
    8008          37 :     return cast<AlignedAttr>(this)->getSpelling();
    8009          10 :   case attr::AllocAlign:
    8010          10 :     return cast<AllocAlignAttr>(this)->getSpelling();
    8011           0 :   case attr::AllocSize:
    8012           0 :     return cast<AllocSizeAttr>(this)->getSpelling();
    8013           8 :   case attr::AlwaysInline:
    8014           8 :     return cast<AlwaysInlineAttr>(this)->getSpelling();
    8015           0 :   case attr::AnalyzerNoReturn:
    8016           0 :     return cast<AnalyzerNoReturnAttr>(this)->getSpelling();
    8017           0 :   case attr::Annotate:
    8018           0 :     return cast<AnnotateAttr>(this)->getSpelling();
    8019           0 :   case attr::AnyX86Interrupt:
    8020           0 :     return cast<AnyX86InterruptAttr>(this)->getSpelling();
    8021           2 :   case attr::AnyX86NoCallerSavedRegisters:
    8022           2 :     return cast<AnyX86NoCallerSavedRegistersAttr>(this)->getSpelling();
    8023           0 :   case attr::ArcWeakrefUnavailable:
    8024           0 :     return cast<ArcWeakrefUnavailableAttr>(this)->getSpelling();
    8025           3 :   case attr::ArgumentWithTypeTag:
    8026           3 :     return cast<ArgumentWithTypeTagAttr>(this)->getSpelling();
    8027           0 :   case attr::AsmLabel:
    8028           0 :     return cast<AsmLabelAttr>(this)->getSpelling();
    8029           0 :   case attr::AssertCapability:
    8030           0 :     return cast<AssertCapabilityAttr>(this)->getSpelling();
    8031           0 :   case attr::AssertExclusiveLock:
    8032           0 :     return cast<AssertExclusiveLockAttr>(this)->getSpelling();
    8033           0 :   case attr::AssertSharedLock:
    8034           0 :     return cast<AssertSharedLockAttr>(this)->getSpelling();
    8035           3 :   case attr::AssumeAligned:
    8036           3 :     return cast<AssumeAlignedAttr>(this)->getSpelling();
    8037           0 :   case attr::Availability:
    8038           0 :     return cast<AvailabilityAttr>(this)->getSpelling();
    8039           0 :   case attr::Blocks:
    8040           0 :     return cast<BlocksAttr>(this)->getSpelling();
    8041           0 :   case attr::C11NoReturn:
    8042           0 :     return cast<C11NoReturnAttr>(this)->getSpelling();
    8043           0 :   case attr::CDecl:
    8044           0 :     return cast<CDeclAttr>(this)->getSpelling();
    8045           0 :   case attr::CFAuditedTransfer:
    8046           0 :     return cast<CFAuditedTransferAttr>(this)->getSpelling();
    8047           0 :   case attr::CFConsumed:
    8048           0 :     return cast<CFConsumedAttr>(this)->getSpelling();
    8049           0 :   case attr::CFReturnsNotRetained:
    8050           0 :     return cast<CFReturnsNotRetainedAttr>(this)->getSpelling();
    8051           0 :   case attr::CFReturnsRetained:
    8052           0 :     return cast<CFReturnsRetainedAttr>(this)->getSpelling();
    8053           0 :   case attr::CFUnknownTransfer:
    8054           0 :     return cast<CFUnknownTransferAttr>(this)->getSpelling();
    8055           2 :   case attr::CUDAConstant:
    8056           2 :     return cast<CUDAConstantAttr>(this)->getSpelling();
    8057           2 :   case attr::CUDADevice:
    8058           2 :     return cast<CUDADeviceAttr>(this)->getSpelling();
    8059           4 :   case attr::CUDAGlobal:
    8060           4 :     return cast<CUDAGlobalAttr>(this)->getSpelling();
    8061           2 :   case attr::CUDAHost:
    8062           2 :     return cast<CUDAHostAttr>(this)->getSpelling();
    8063           0 :   case attr::CUDAInvalidTarget:
    8064           0 :     return cast<CUDAInvalidTargetAttr>(this)->getSpelling();
    8065           7 :   case attr::CUDALaunchBounds:
    8066           7 :     return cast<CUDALaunchBoundsAttr>(this)->getSpelling();
    8067           4 :   case attr::CUDAShared:
    8068           4 :     return cast<CUDASharedAttr>(this)->getSpelling();
    8069           0 :   case attr::CXX11NoReturn:
    8070           0 :     return cast<CXX11NoReturnAttr>(this)->getSpelling();
    8071           0 :   case attr::CallableWhen:
    8072           0 :     return cast<CallableWhenAttr>(this)->getSpelling();
    8073           1 :   case attr::Capability:
    8074           1 :     return cast<CapabilityAttr>(this)->getSpelling();
    8075           0 :   case attr::CapturedRecord:
    8076           0 :     return cast<CapturedRecordAttr>(this)->getSpelling();
    8077           0 :   case attr::CarriesDependency:
    8078           0 :     return cast<CarriesDependencyAttr>(this)->getSpelling();
    8079           0 :   case attr::Cleanup:
    8080           0 :     return cast<CleanupAttr>(this)->getSpelling();
    8081           1 :   case attr::Cold:
    8082           1 :     return cast<ColdAttr>(this)->getSpelling();
    8083           2 :   case attr::Common:
    8084           2 :     return cast<CommonAttr>(this)->getSpelling();
    8085           0 :   case attr::Const:
    8086           0 :     return cast<ConstAttr>(this)->getSpelling();
    8087           0 :   case attr::Constructor:
    8088           0 :     return cast<ConstructorAttr>(this)->getSpelling();
    8089           0 :   case attr::Consumable:
    8090           0 :     return cast<ConsumableAttr>(this)->getSpelling();
    8091           0 :   case attr::ConsumableAutoCast:
    8092           0 :     return cast<ConsumableAutoCastAttr>(this)->getSpelling();
    8093           0 :   case attr::ConsumableSetOnRead:
    8094           0 :     return cast<ConsumableSetOnReadAttr>(this)->getSpelling();
    8095           0 :   case attr::Convergent:
    8096           0 :     return cast<ConvergentAttr>(this)->getSpelling();
    8097         365 :   case attr::DLLExport:
    8098         365 :     return cast<DLLExportAttr>(this)->getSpelling();
    8099         830 :   case attr::DLLImport:
    8100         830 :     return cast<DLLImportAttr>(this)->getSpelling();
    8101           0 :   case attr::Deprecated:
    8102           0 :     return cast<DeprecatedAttr>(this)->getSpelling();
    8103           0 :   case attr::Destructor:
    8104           0 :     return cast<DestructorAttr>(this)->getSpelling();
    8105           0 :   case attr::DiagnoseIf:
    8106           0 :     return cast<DiagnoseIfAttr>(this)->getSpelling();
    8107           1 :   case attr::DisableTailCalls:
    8108           1 :     return cast<DisableTailCallsAttr>(this)->getSpelling();
    8109           0 :   case attr::EmptyBases:
    8110           0 :     return cast<EmptyBasesAttr>(this)->getSpelling();
    8111           0 :   case attr::EnableIf:
    8112           0 :     return cast<EnableIfAttr>(this)->getSpelling();
    8113           0 :   case attr::EnumExtensibility:
    8114           0 :     return cast<EnumExtensibilityAttr>(this)->getSpelling();
    8115           0 :   case attr::ExclusiveTrylockFunction:
    8116           0 :     return cast<ExclusiveTrylockFunctionAttr>(this)->getSpelling();
    8117           0 :   case attr::ExternalSourceSymbol:
    8118           0 :     return cast<ExternalSourceSymbolAttr>(this)->getSpelling();
    8119           1 :   case attr::FallThrough:
    8120           1 :     return cast<FallThroughAttr>(this)->getSpelling();
    8121           0 :   case attr::FastCall:
    8122           0 :     return cast<FastCallAttr>(this)->getSpelling();
    8123           0 :   case attr::Final:
    8124           0 :     return cast<FinalAttr>(this)->getSpelling();
    8125           0 :   case attr::FlagEnum:
    8126           0 :     return cast<FlagEnumAttr>(this)->getSpelling();
    8127           0 :   case attr::Flatten:
    8128           0 :     return cast<FlattenAttr>(this)->getSpelling();
    8129           0 :   case attr::Format:
    8130           0 :     return cast<FormatAttr>(this)->getSpelling();
    8131           0 :   case attr::FormatArg:
    8132           0 :     return cast<FormatArgAttr>(this)->getSpelling();
    8133           0 :   case attr::GNUInline:
    8134           0 :     return cast<GNUInlineAttr>(this)->getSpelling();
    8135           0 :   case attr::GuardedBy:
    8136           0 :     return cast<GuardedByAttr>(this)->getSpelling();
    8137           0 :   case attr::GuardedVar:
    8138           0 :     return cast<GuardedVarAttr>(this)->getSpelling();
    8139           1 :   case attr::Hot:
    8140           1 :     return cast<HotAttr>(this)->getSpelling();
    8141           0 :   case attr::IBAction:
    8142           0 :     return cast<IBActionAttr>(this)->getSpelling();
    8143           0 :   case attr::IBOutlet:
    8144           0 :     return cast<IBOutletAttr>(this)->getSpelling();
    8145           0 :   case attr::IBOutletCollection:
    8146           0 :     return cast<IBOutletCollectionAttr>(this)->getSpelling();
    8147           0 :   case attr::IFunc:
    8148           0 :     return cast<IFuncAttr>(this)->getSpelling();
    8149           0 :   case attr::InitPriority:
    8150           0 :     return cast<InitPriorityAttr>(this)->getSpelling();
    8151           0 :   case attr::InitSeg:
    8152           0 :     return cast<InitSegAttr>(this)->getSpelling();
    8153           0 :   case attr::IntelOclBicc:
    8154           0 :     return cast<IntelOclBiccAttr>(this)->getSpelling();
    8155           2 :   case attr::InternalLinkage:
    8156           2 :     return cast<InternalLinkageAttr>(this)->getSpelling();
    8157           0 :   case attr::LTOVisibilityPublic:
    8158           0 :     return cast<LTOVisibilityPublicAttr>(this)->getSpelling();
    8159           0 :   case attr::LayoutVersion:
    8160           0 :     return cast<LayoutVersionAttr>(this)->getSpelling();
    8161           0 :   case attr::LockReturned:
    8162           0 :     return cast<LockReturnedAttr>(this)->getSpelling();
    8163           0 :   case attr::LocksExcluded:
    8164           0 :     return cast<LocksExcludedAttr>(this)->getSpelling();
    8165           0 :   case attr::LoopHint:
    8166           0 :     return cast<LoopHintAttr>(this)->getSpelling();
    8167           0 :   case attr::MSABI:
    8168           0 :     return cast<MSABIAttr>(this)->getSpelling();
    8169           0 :   case attr::MSInheritance:
    8170           0 :     return cast<MSInheritanceAttr>(this)->getSpelling();
    8171           0 :   case attr::MSNoVTable:
    8172           0 :     return cast<MSNoVTableAttr>(this)->getSpelling();
    8173           0 :   case attr::MSP430Interrupt:
    8174           0 :     return cast<MSP430InterruptAttr>(this)->getSpelling();
    8175           0 :   case attr::MSStruct:
    8176           0 :     return cast<MSStructAttr>(this)->getSpelling();
    8177           0 :   case attr::MSVtorDisp:
    8178           0 :     return cast<MSVtorDispAttr>(this)->getSpelling();
    8179           0 :   case attr::MaxFieldAlignment:
    8180           0 :     return cast<MaxFieldAlignmentAttr>(this)->getSpelling();
    8181           0 :   case attr::MayAlias:
    8182           0 :     return cast<MayAliasAttr>(this)->getSpelling();
    8183           1 :   case attr::MicroMips:
    8184           1 :     return cast<MicroMipsAttr>(this)->getSpelling();
    8185           3 :   case attr::MinSize:
    8186           3 :     return cast<MinSizeAttr>(this)->getSpelling();
    8187           4 :   case attr::Mips16:
    8188           4 :     return cast<Mips16Attr>(this)->getSpelling();
    8189           2 :   case attr::MipsInterrupt:
    8190           2 :     return cast<MipsInterruptAttr>(this)->getSpelling();
    8191           2 :   case attr::MipsLongCall:
    8192           2 :     return cast<MipsLongCallAttr>(this)->getSpelling();
    8193           2 :   case attr::MipsShortCall:
    8194           2 :     return cast<MipsShortCallAttr>(this)->getSpelling();
    8195           0 :   case attr::Mode:
    8196           0 :     return cast<ModeAttr>(this)->getSpelling();
    8197           0 :   case attr::NSConsumed:
    8198           0 :     return cast<NSConsumedAttr>(this)->getSpelling();
    8199           0 :   case attr::NSConsumesSelf:
    8200           0 :     return cast<NSConsumesSelfAttr>(this)->getSpelling();
    8201           0 :   case attr::NSReturnsAutoreleased:
    8202           0 :     return cast<NSReturnsAutoreleasedAttr>(this)->getSpelling();
    8203           0 :   case attr::NSReturnsNotRetained:
    8204           0 :     return cast<NSReturnsNotRetainedAttr>(this)->getSpelling();
    8205           0 :   case attr::NSReturnsRetained:
    8206           0 :     return cast<NSReturnsRetainedAttr>(this)->getSpelling();
    8207           1 :   case attr::Naked:
    8208           1 :     return cast<NakedAttr>(this)->getSpelling();
    8209           0 :   case attr::NoAlias:
    8210           0 :     return cast<NoAliasAttr>(this)->getSpelling();
    8211           0 :   case attr::NoCommon:
    8212           0 :     return cast<NoCommonAttr>(this)->getSpelling();
    8213           0 :   case attr::NoDebug:
    8214           0 :     return cast<NoDebugAttr>(this)->getSpelling();
    8215           0 :   case attr::NoDuplicate:
    8216           0 :     return cast<NoDuplicateAttr>(this)->getSpelling();
    8217           0 :   case attr::NoInline:
    8218           0 :     return cast<NoInlineAttr>(this)->getSpelling();
    8219           0 :   case attr::NoInstrumentFunction:
    8220           0 :     return cast<NoInstrumentFunctionAttr>(this)->getSpelling();
    8221           0 :   case attr::NoMicroMips:
    8222           0 :     return cast<NoMicroMipsAttr>(this)->getSpelling();
    8223           0 :   case attr::NoMips16:
    8224           0 :     return cast<NoMips16Attr>(this)->getSpelling();
    8225           0 :   case attr::NoReturn:
    8226           0 :     return cast<NoReturnAttr>(this)->getSpelling();
    8227           0 :   case attr::NoSanitize:
    8228           0 :     return cast<NoSanitizeAttr>(this)->getSpelling();
    8229           0 :   case attr::NoSplitStack:
    8230           0 :     return cast<NoSplitStackAttr>(this)->getSpelling();
    8231           0 :   case attr::NoThreadSafetyAnalysis:
    8232           0 :     return cast<NoThreadSafetyAnalysisAttr>(this)->getSpelling();
    8233           0 :   case attr::NoThrow:
    8234           0 :     return cast<NoThrowAttr>(this)->getSpelling();
    8235           0 :   case attr::NonNull:
    8236           0 :     return cast<NonNullAttr>(this)->getSpelling();
    8237           3 :   case attr::NotTailCalled:
    8238           3 :     return cast<NotTailCalledAttr>(this)->getSpelling();
    8239           0 :   case attr::OMPCaptureKind:
    8240           0 :     return cast<OMPCaptureKindAttr>(this)->getSpelling();
    8241           0 :   case attr::OMPCaptureNoInit:
    8242           0 :     return cast<OMPCaptureNoInitAttr>(this)->getSpelling();
    8243           0 :   case attr::OMPDeclareSimdDecl:
    8244           0 :     return cast<OMPDeclareSimdDeclAttr>(this)->getSpelling();
    8245           0 :   case attr::OMPDeclareTargetDecl:
    8246           0 :     return cast<OMPDeclareTargetDeclAttr>(this)->getSpelling();
    8247           0 :   case attr::OMPThreadPrivateDecl:
    8248           0 :     return cast<OMPThreadPrivateDeclAttr>(this)->getSpelling();
    8249           0 :   case attr::ObjCBoxable:
    8250           0 :     return cast<ObjCBoxableAttr>(this)->getSpelling();
    8251           0 :   case attr::ObjCBridge:
    8252           0 :     return cast<ObjCBridgeAttr>(this)->getSpelling();
    8253           0 :   case attr::ObjCBridgeMutable:
    8254           0 :     return cast<ObjCBridgeMutableAttr>(this)->getSpelling();
    8255           0 :   case attr::ObjCBridgeRelated:
    8256           0 :     return cast<ObjCBridgeRelatedAttr>(this)->getSpelling();
    8257           0 :   case attr::ObjCDesignatedInitializer:
    8258           0 :     return cast<ObjCDesignatedInitializerAttr>(this)->getSpelling();
    8259           0 :   case attr::ObjCException:
    8260           0 :     return cast<ObjCExceptionAttr>(this)->getSpelling();
    8261           0 :   case attr::ObjCExplicitProtocolImpl:
    8262           0 :     return cast<ObjCExplicitProtocolImplAttr>(this)->getSpelling();
    8263           0 :   case attr::ObjCIndependentClass:
    8264           0 :     return cast<ObjCIndependentClassAttr>(this)->getSpelling();
    8265           0 :   case attr::ObjCMethodFamily:
    8266           0 :     return cast<ObjCMethodFamilyAttr>(this)->getSpelling();
    8267           0 :   case attr::ObjCNSObject:
    8268           0 :     return cast<ObjCNSObjectAttr>(this)->getSpelling();
    8269           0 :   case attr::ObjCPreciseLifetime:
    8270           0 :     return cast<ObjCPreciseLifetimeAttr>(this)->getSpelling();
    8271           0 :   case attr::ObjCRequiresPropertyDefs:
    8272           0 :     return cast<ObjCRequiresPropertyDefsAttr>(this)->getSpelling();
    8273           0 :   case attr::ObjCRequiresSuper:
    8274           0 :     return cast<ObjCRequiresSuperAttr>(this)->getSpelling();
    8275           0 :   case attr::ObjCReturnsInnerPointer:
    8276           0 :     return cast<ObjCReturnsInnerPointerAttr>(this)->getSpelling();
    8277           0 :   case attr::ObjCRootClass:
    8278           0 :     return cast<ObjCRootClassAttr>(this)->getSpelling();
    8279           0 :   case attr::ObjCRuntimeName:
    8280           0 :     return cast<ObjCRuntimeNameAttr>(this)->getSpelling();
    8281           0 :   case attr::ObjCRuntimeVisible:
    8282           0 :     return cast<ObjCRuntimeVisibleAttr>(this)->getSpelling();
    8283           0 :   case attr::ObjCSubclassingRestricted:
    8284           0 :     return cast<ObjCSubclassingRestrictedAttr>(this)->getSpelling();
    8285           2 :   case attr::OpenCLAccess:
    8286           2 :     return cast<OpenCLAccessAttr>(this)->getSpelling();
    8287           1 :   case attr::OpenCLIntelReqdSubGroupSize:
    8288           1 :     return cast<OpenCLIntelReqdSubGroupSizeAttr>(this)->getSpelling();
    8289           0 :   case attr::OpenCLKernel:
    8290           0 :     return cast<OpenCLKernelAttr>(this)->getSpelling();
    8291           0 :   case attr::OpenCLUnrollHint:
    8292           0 :     return cast<OpenCLUnrollHintAttr>(this)->getSpelling();
    8293           0 :   case attr::OptimizeNone:
    8294           0 :     return cast<OptimizeNoneAttr>(this)->getSpelling();
    8295           0 :   case attr::Overloadable:
    8296           0 :     return cast<OverloadableAttr>(this)->getSpelling();
    8297           0 :   case attr::Override:
    8298           0 :     return cast<OverrideAttr>(this)->getSpelling();
    8299           1 :   case attr::Ownership:
    8300           1 :     return cast<OwnershipAttr>(this)->getSpelling();
    8301           0 :   case attr::Packed:
    8302           0 :     return cast<PackedAttr>(this)->getSpelling();
    8303           0 :   case attr::ParamTypestate:
    8304           0 :     return cast<ParamTypestateAttr>(this)->getSpelling();
    8305           0 :   case attr::Pascal:
    8306           0 :     return cast<PascalAttr>(this)->getSpelling();
    8307           0 :   case attr::PassObjectSize:
    8308           0 :     return cast<PassObjectSizeAttr>(this)->getSpelling();
    8309           0 :   case attr::Pcs:
    8310           0 :     return cast<PcsAttr>(this)->getSpelling();
    8311           0 :   case attr::PragmaClangBSSSection:
    8312           0 :     return cast<PragmaClangBSSSectionAttr>(this)->getSpelling();
    8313           0 :   case attr::PragmaClangDataSection:
    8314           0 :     return cast<PragmaClangDataSectionAttr>(this)->getSpelling();
    8315           0 :   case attr::PragmaClangRodataSection:
    8316           0 :     return cast<PragmaClangRodataSectionAttr>(this)->getSpelling();
    8317           0 :   case attr::PragmaClangTextSection:
    8318           0 :     return cast<PragmaClangTextSectionAttr>(this)->getSpelling();
    8319           0 :   case attr::PreserveAll:
    8320           0 :     return cast<PreserveAllAttr>(this)->getSpelling();
    8321           0 :   case attr::PreserveMost:
    8322           0 :     return cast<PreserveMostAttr>(this)->getSpelling();
    8323           0 :   case attr::PtGuardedBy:
    8324           0 :     return cast<PtGuardedByAttr>(this)->getSpelling();
    8325           0 :   case attr::PtGuardedVar:
    8326           0 :     return cast<PtGuardedVarAttr>(this)->getSpelling();
    8327           0 :   case attr::Pure:
    8328           0 :     return cast<PureAttr>(this)->getSpelling();
    8329           0 :   case attr::RegCall:
    8330           0 :     return cast<RegCallAttr>(this)->getSpelling();
    8331           0 :   case attr::ReleaseCapability:
    8332           0 :     return cast<ReleaseCapabilityAttr>(this)->getSpelling();
    8333           0 :   case attr::RenderScriptKernel:
    8334           0 :     return cast<RenderScriptKernelAttr>(this)->getSpelling();
    8335           1 :   case attr::ReqdWorkGroupSize:
    8336           1 :     return cast<ReqdWorkGroupSizeAttr>(this)->getSpelling();
    8337           0 :   case attr::RequireConstantInit:
    8338           0 :     return cast<RequireConstantInitAttr>(this)->getSpelling();
    8339           0 :   case attr::RequiresCapability:
    8340           0 :     return cast<RequiresCapabilityAttr>(this)->getSpelling();
    8341           0 :   case attr::Restrict:
    8342           0 :     return cast<RestrictAttr>(this)->getSpelling();
    8343           0 :   case attr::ReturnTypestate:
    8344           0 :     return cast<ReturnTypestateAttr>(this)->getSpelling();
    8345           0 :   case attr::ReturnsNonNull:
    8346           0 :     return cast<ReturnsNonNullAttr>(this)->getSpelling();
    8347           0 :   case attr::ReturnsTwice:
    8348           0 :     return cast<ReturnsTwiceAttr>(this)->getSpelling();
    8349           0 :   case attr::ScopedLockable:
    8350           0 :     return cast<ScopedLockableAttr>(this)->getSpelling();
    8351           0 :   case attr::Section:
    8352           0 :     return cast<SectionAttr>(this)->getSpelling();
    8353           0 :   case attr::SelectAny:
    8354           0 :     return cast<SelectAnyAttr>(this)->getSpelling();
    8355           0 :   case attr::Sentinel:
    8356           0 :     return cast<SentinelAttr>(this)->getSpelling();
    8357           0 :   case attr::SetTypestate:
    8358           0 :     return cast<SetTypestateAttr>(this)->getSpelling();
    8359           0 :   case attr::SharedTrylockFunction:
    8360           0 :     return cast<SharedTrylockFunctionAttr>(this)->getSpelling();
    8361           0 :   case attr::StdCall:
    8362           0 :     return cast<StdCallAttr>(this)->getSpelling();
    8363           0 :   case attr::Suppress:
    8364           0 :     return cast<SuppressAttr>(this)->getSpelling();
    8365           0 :   case attr::SwiftCall:
    8366           0 :     return cast<SwiftCallAttr>(this)->getSpelling();
    8367           0 :   case attr::SwiftContext:
    8368           0 :     return cast<SwiftContextAttr>(this)->getSpelling();
    8369           0 :   case attr::SwiftErrorResult:
    8370           0 :     return cast<SwiftErrorResultAttr>(this)->getSpelling();
    8371           0 :   case attr::SwiftIndirectResult:
    8372           0 :     return cast<SwiftIndirectResultAttr>(this)->getSpelling();
    8373           0 :   case attr::SysVABI:
    8374           0 :     return cast<SysVABIAttr>(this)->getSpelling();
    8375           0 :   case attr::TLSModel:
    8376           0 :     return cast<TLSModelAttr>(this)->getSpelling();
    8377           0 :   case attr::Target:
    8378           0 :     return cast<TargetAttr>(this)->getSpelling();
    8379           0 :   case attr::TestTypestate:
    8380           0 :     return cast<TestTypestateAttr>(this)->getSpelling();
    8381           0 :   case attr::ThisCall:
    8382           0 :     return cast<ThisCallAttr>(this)->getSpelling();
    8383           0 :   case attr::Thread:
    8384           0 :     return cast<ThreadAttr>(this)->getSpelling();
    8385           0 :   case attr::TransparentUnion:
    8386           0 :     return cast<TransparentUnionAttr>(this)->getSpelling();
    8387           0 :   case attr::TryAcquireCapability:
    8388           0 :     return cast<TryAcquireCapabilityAttr>(this)->getSpelling();
    8389           0 :   case attr::TypeTagForDatatype:
    8390           0 :     return cast<TypeTagForDatatypeAttr>(this)->getSpelling();
    8391           0 :   case attr::TypeVisibility:
    8392           0 :     return cast<TypeVisibilityAttr>(this)->getSpelling();
    8393           0 :   case attr::Unavailable:
    8394           0 :     return cast<UnavailableAttr>(this)->getSpelling();
    8395           4 :   case attr::Unused:
    8396           4 :     return cast<UnusedAttr>(this)->getSpelling();
    8397           4 :   case attr::Used:
    8398           4 :     return cast<UsedAttr>(this)->getSpelling();
    8399           0 :   case attr::Uuid:
    8400           0 :     return cast<UuidAttr>(this)->getSpelling();
    8401           1 :   case attr::VecReturn:
    8402           1 :     return cast<VecReturnAttr>(this)->getSpelling();
    8403           1 :   case attr::VecTypeHint:
    8404           1 :     return cast<VecTypeHintAttr>(this)->getSpelling();
    8405           0 :   case attr::VectorCall:
    8406           0 :     return cast<VectorCallAttr>(this)->getSpelling();
    8407           0 :   case attr::Visibility:
    8408           0 :     return cast<VisibilityAttr>(this)->getSpelling();
    8409           0 :   case attr::WarnUnused:
    8410           0 :     return cast<WarnUnusedAttr>(this)->getSpelling();
    8411          38 :   case attr::WarnUnusedResult:
    8412          38 :     return cast<WarnUnusedResultAttr>(this)->getSpelling();
    8413           0 :   case attr::Weak:
    8414           0 :     return cast<WeakAttr>(this)->getSpelling();
    8415           0 :   case attr::WeakImport:
    8416           0 :     return cast<WeakImportAttr>(this)->getSpelling();
    8417           0 :   case attr::WeakRef:
    8418           0 :     return cast<WeakRefAttr>(this)->getSpelling();
    8419           1 :   case attr::WorkGroupSizeHint:
    8420           1 :     return cast<WorkGroupSizeHintAttr>(this)->getSpelling();
    8421           0 :   case attr::X86ForceAlignArgPointer:
    8422           0 :     return cast<X86ForceAlignArgPointerAttr>(this)->getSpelling();
    8423           0 :   case attr::XRayInstrument:
    8424           0 :     return cast<XRayInstrumentAttr>(this)->getSpelling();
    8425           0 :   case attr::XRayLogArgs:
    8426           0 :     return cast<XRayLogArgsAttr>(this)->getSpelling();
    8427             :   }
    8428           0 :   llvm_unreachable("Unexpected attribute kind!");
    8429             : }
    8430             : 
    8431        8520 : Attr *Attr::clone(ASTContext &C) const {
    8432        8520 :   switch (getKind()) {
    8433           0 :   case attr::AMDGPUFlatWorkGroupSize:
    8434           0 :     return cast<AMDGPUFlatWorkGroupSizeAttr>(this)->clone(C);
    8435           0 :   case attr::AMDGPUNumSGPR:
    8436           0 :     return cast<AMDGPUNumSGPRAttr>(this)->clone(C);
    8437           0 :   case attr::AMDGPUNumVGPR:
    8438           0 :     return cast<AMDGPUNumVGPRAttr>(this)->clone(C);
    8439           0 :   case attr::AMDGPUWavesPerEU:
    8440           0 :     return cast<AMDGPUWavesPerEUAttr>(this)->clone(C);
    8441           0 :   case attr::ARMInterrupt:
    8442           0 :     return cast<ARMInterruptAttr>(this)->clone(C);
    8443           0 :   case attr::AVRInterrupt:
    8444           0 :     return cast<AVRInterruptAttr>(this)->clone(C);
    8445           0 :   case attr::AVRSignal:
    8446           0 :     return cast<AVRSignalAttr>(this)->clone(C);
    8447           0 :   case attr::AbiTag:
    8448           0 :     return cast<AbiTagAttr>(this)->clone(C);
    8449          28 :   case attr::AcquireCapability:
    8450          28 :     return cast<AcquireCapabilityAttr>(this)->clone(C);
    8451           0 :   case attr::AcquiredAfter:
    8452           0 :     return cast<AcquiredAfterAttr>(this)->clone(C);
    8453           0 :   case attr::AcquiredBefore:
    8454           0 :     return cast<AcquiredBeforeAttr>(this)->clone(C);
    8455           0 :   case attr::Alias:
    8456           0 :     return cast<AliasAttr>(this)->clone(C);
    8457           0 :   case attr::AlignMac68k:
    8458           0 :     return cast<AlignMac68kAttr>(this)->clone(C);
    8459           0 :   case attr::AlignValue:
    8460           0 :     return cast<AlignValueAttr>(this)->clone(C);
    8461           4 :   case attr::Aligned:
    8462           4 :     return cast<AlignedAttr>(this)->clone(C);
    8463           0 :   case attr::AllocAlign:
    8464           0 :     return cast<AllocAlignAttr>(this)->clone(C);
    8465           0 :   case attr::AllocSize:
    8466           0 :     return cast<AllocSizeAttr>(this)->clone(C);
    8467           1 :   case attr::AlwaysInline:
    8468           1 :     return cast<AlwaysInlineAttr>(this)->clone(C);
    8469           0 :   case attr::AnalyzerNoReturn:
    8470           0 :     return cast<AnalyzerNoReturnAttr>(this)->clone(C);
    8471          42 :   case attr::Annotate:
    8472          42 :     return cast<AnnotateAttr>(this)->clone(C);
    8473           0 :   case attr::AnyX86Interrupt:
    8474           0 :     return cast<AnyX86InterruptAttr>(this)->clone(C);
    8475           0 :   case attr::AnyX86NoCallerSavedRegisters:
    8476           0 :     return cast<AnyX86NoCallerSavedRegistersAttr>(this)->clone(C);
    8477           0 :   case attr::ArcWeakrefUnavailable:
    8478           0 :     return cast<ArcWeakrefUnavailableAttr>(this)->clone(C);
    8479           0 :   case attr::ArgumentWithTypeTag:
    8480           0 :     return cast<ArgumentWithTypeTagAttr>(this)->clone(C);
    8481          13 :   case attr::AsmLabel:
    8482          13 :     return cast<AsmLabelAttr>(this)->clone(C);
    8483           6 :   case attr::AssertCapability:
    8484           6 :     return cast<AssertCapabilityAttr>(this)->clone(C);
    8485           3 :   case attr::AssertExclusiveLock:
    8486           3 :     return cast<AssertExclusiveLockAttr>(this)->clone(C);
    8487           3 :   case attr::AssertSharedLock:
    8488           3 :     return cast<AssertSharedLockAttr>(this)->clone(C);
    8489           4 :   case attr::AssumeAligned:
    8490           4 :     return cast<AssumeAlignedAttr>(this)->clone(C);
    8491         110 :   case attr::Availability:
    8492         110 :     return cast<AvailabilityAttr>(this)->clone(C);
    8493           0 :   case attr::Blocks:
    8494           0 :     return cast<BlocksAttr>(this)->clone(C);
    8495           7 :   case attr::C11NoReturn:
    8496           7 :     return cast<C11NoReturnAttr>(this)->clone(C);
    8497           0 :   case attr::CDecl:
    8498           0 :     return cast<CDeclAttr>(this)->clone(C);
    8499           0 :   case attr::CFAuditedTransfer:
    8500           0 :     return cast<CFAuditedTransferAttr>(this)->clone(C);
    8501           5 :   case attr::CFConsumed:
    8502           5 :     return cast<CFConsumedAttr>(this)->clone(C);
    8503           5 :   case attr::CFReturnsNotRetained:
    8504           5 :     return cast<CFReturnsNotRetainedAttr>(this)->clone(C);
    8505          16 :   case attr::CFReturnsRetained:
    8506          16 :     return cast<CFReturnsRetainedAttr>(this)->clone(C);
    8507           0 :   case attr::CFUnknownTransfer:
    8508           0 :     return cast<CFUnknownTransferAttr>(this)->clone(C);
    8509           0 :   case attr::CUDAConstant:
    8510           0 :     return cast<CUDAConstantAttr>(this)->clone(C);
    8511           0 :   case attr::CUDADevice:
    8512           0 :     return cast<CUDADeviceAttr>(this)->clone(C);
    8513           0 :   case attr::CUDAGlobal:
    8514           0 :     return cast<CUDAGlobalAttr>(this)->clone(C);
    8515           0 :   case attr::CUDAHost:
    8516           0 :     return cast<CUDAHostAttr>(this)->clone(C);
    8517           0 :   case attr::CUDAInvalidTarget:
    8518           0 :     return cast<CUDAInvalidTargetAttr>(this)->clone(C);
    8519           0 :   case attr::CUDALaunchBounds:
    8520           0 :     return cast<CUDALaunchBoundsAttr>(this)->clone(C);
    8521           0 :   case attr::CUDAShared:
    8522           0 :     return cast<CUDASharedAttr>(this)->clone(C);
    8523           3 :   case attr::CXX11NoReturn:
    8524           3 :     return cast<CXX11NoReturnAttr>(this)->clone(C);
    8525           0 :   case attr::CallableWhen:
    8526           0 :     return cast<CallableWhenAttr>(this)->clone(C);
    8527           0 :   case attr::Capability:
    8528           0 :     return cast<CapabilityAttr>(this)->clone(C);
    8529           0 :   case attr::CapturedRecord:
    8530           0 :     return cast<CapturedRecordAttr>(this)->clone(C);
    8531           5 :   case attr::CarriesDependency:
    8532           5 :     return cast<CarriesDependencyAttr>(this)->clone(C);
    8533           0 :   case attr::Cleanup:
    8534           0 :     return cast<CleanupAttr>(this)->clone(C);
    8535           1 :   case attr::Cold:
    8536           1 :     return cast<ColdAttr>(this)->clone(C);
    8537           0 :   case attr::Common:
    8538           0 :     return cast<CommonAttr>(this)->clone(C);
    8539         524 :   case attr::Const:
    8540         524 :     return cast<ConstAttr>(this)->clone(C);
    8541          13 :   case attr::Constructor:
    8542          13 :     return cast<ConstructorAttr>(this)->clone(C);
    8543           0 :   case attr::Consumable:
    8544           0 :     return cast<ConsumableAttr>(this)->clone(C);
    8545           0 :   case attr::ConsumableAutoCast:
    8546           0 :     return cast<ConsumableAutoCastAttr>(this)->clone(C);
    8547           0 :   case attr::ConsumableSetOnRead:
    8548           0 :     return cast<ConsumableSetOnReadAttr>(this)->clone(C);
    8549           0 :   case attr::Convergent:
    8550           0 :     return cast<ConvergentAttr>(this)->clone(C);
    8551        1721 :   case attr::DLLExport:
    8552        1721 :     return cast<DLLExportAttr>(this)->clone(C);
    8553        1842 :   case attr::DLLImport:
    8554        1842 :     return cast<DLLImportAttr>(this)->clone(C);
    8555         129 :   case attr::Deprecated:
    8556         129 :     return cast<DeprecatedAttr>(this)->clone(C);
    8557           7 :   case attr::Destructor:
    8558           7 :     return cast<DestructorAttr>(this)->clone(C);
    8559           4 :   case attr::DiagnoseIf:
    8560           4 :     return cast<DiagnoseIfAttr>(this)->clone(C);
    8561           0 :   case attr::DisableTailCalls:
    8562           0 :     return cast<DisableTailCallsAttr>(this)->clone(C);
    8563           0 :   case attr::EmptyBases:
    8564           0 :     return cast<EmptyBasesAttr>(this)->clone(C);
    8565           0 :   case attr::EnableIf:
    8566           0 :     return cast<EnableIfAttr>(this)->clone(C);
    8567           0 :   case attr::EnumExtensibility:
    8568           0 :     return cast<EnumExtensibilityAttr>(this)->clone(C);
    8569           9 :   case attr::ExclusiveTrylockFunction:
    8570           9 :     return cast<ExclusiveTrylockFunctionAttr>(this)->clone(C);
    8571           0 :   case attr::ExternalSourceSymbol:
    8572           0 :     return cast<ExternalSourceSymbolAttr>(this)->clone(C);
    8573           0 :   case attr::FallThrough:
    8574           0 :     return cast<FallThroughAttr>(this)->clone(C);
    8575           0 :   case attr::FastCall:
    8576           0 :     return cast<FastCallAttr>(this)->clone(C);
    8577          11 :   case attr::Final:
    8578          11 :     return cast<FinalAttr>(this)->clone(C);
    8579           0 :   case attr::FlagEnum:
    8580           0 :     return cast<FlagEnumAttr>(this)->clone(C);
    8581           0 :   case attr::Flatten:
    8582           0 :     return cast<FlattenAttr>(this)->clone(C);
    8583           0 :   case attr::Format:
    8584           0 :     return cast<FormatAttr>(this)->clone(C);
    8585           0 :   case attr::FormatArg:
    8586           0 :     return cast<FormatArgAttr>(this)->clone(C);
    8587           3 :   case attr::GNUInline:
    8588           3 :     return cast<GNUInlineAttr>(this)->clone(C);
    8589           0 :   case attr::GuardedBy:
    8590           0 :     return cast<GuardedByAttr>(this)->clone(C);
    8591           0 :   case attr::GuardedVar:
    8592           0 :     return cast<GuardedVarAttr>(this)->clone(C);
    8593           0 :   case attr::Hot:
    8594           0 :     return cast<HotAttr>(this)->clone(C);
    8595           0 :   case attr::IBAction:
    8596           0 :     return cast<IBActionAttr>(this)->clone(C);
    8597           0 :   case attr::IBOutlet:
    8598           0 :     return cast<IBOutletAttr>(this)->clone(C);
    8599           0 :   case attr::IBOutletCollection:
    8600           0 :     return cast<IBOutletCollectionAttr>(this)->clone(C);
    8601           0 :   case attr::IFunc:
    8602           0 :     return cast<IFuncAttr>(this)->clone(C);
    8603           0 :   case attr::InitPriority:
    8604           0 :     return cast<InitPriorityAttr>(this)->clone(C);
    8605           0 :   case attr::InitSeg:
    8606           0 :     return cast<InitSegAttr>(this)->clone(C);
    8607           0 :   case attr::IntelOclBicc:
    8608           0 :     return cast<IntelOclBiccAttr>(this)->clone(C);
    8609           0 :   case attr::InternalLinkage:
    8610           0 :     return cast<InternalLinkageAttr>(this)->clone(C);
    8611           0 :   case attr::LTOVisibilityPublic:
    8612           0 :     return cast<LTOVisibilityPublicAttr>(this)->clone(C);
    8613           0 :   case attr::LayoutVersion:
    8614           0 :     return cast<LayoutVersionAttr>(this)->clone(C);
    8615           3 :   case attr::LockReturned:
    8616           3 :     return cast<LockReturnedAttr>(this)->clone(C);
    8617          11 :   case attr::LocksExcluded:
    8618          11 :     return cast<LocksExcludedAttr>(this)->clone(C);
    8619           0 :   case attr::LoopHint:
    8620           0 :     return cast<LoopHintAttr>(this)->clone(C);
    8621           0 :   case attr::MSABI:
    8622           0 :     return cast<MSABIAttr>(this)->clone(C);
    8623           0 :   case attr::MSInheritance:
    8624           0 :     return cast<MSInheritanceAttr>(this)->clone(C);
    8625           0 :   case attr::MSNoVTable:
    8626           0 :     return cast<MSNoVTableAttr>(this)->clone(C);
    8627           0 :   case attr::MSP430Interrupt:
    8628           0 :     return cast<MSP430InterruptAttr>(this)->clone(C);
    8629           0 :   case attr::MSStruct:
    8630           0 :     return cast<MSStructAttr>(this)->clone(C);
    8631           0 :   case attr::MSVtorDisp:
    8632           0 :     return cast<MSVtorDispAttr>(this)->clone(C);
    8633           0 :   case attr::MaxFieldAlignment:
    8634           0 :     return cast<MaxFieldAlignmentAttr>(this)->clone(C);
    8635           0 :   case attr::MayAlias:
    8636           0 :     return cast<MayAliasAttr>(this)->clone(C);
    8637           0 :   case attr::MicroMips:
    8638           0 :     return cast<MicroMipsAttr>(this)->clone(C);
    8639           0 :   case attr::MinSize:
    8640           0 :     return cast<MinSizeAttr>(this)->clone(C);
    8641           1 :   case attr::Mips16:
    8642           1 :     return cast<Mips16Attr>(this)->clone(C);
    8643           0 :   case attr::MipsInterrupt:
    8644           0 :     return cast<MipsInterruptAttr>(this)->clone(C);
    8645           0 :   case attr::MipsLongCall:
    8646           0 :     return cast<MipsLongCallAttr>(this)->clone(C);
    8647           0 :   case attr::MipsShortCall:
    8648           0 :     return cast<MipsShortCallAttr>(this)->clone(C);
    8649           0 :   case attr::Mode:
    8650           0 :     return cast<ModeAttr>(this)->clone(C);
    8651           6 :   case attr::NSConsumed:
    8652           6 :     return cast<NSConsumedAttr>(this)->clone(C);
    8653         137 :   case attr::NSConsumesSelf:
    8654         137 :     return cast<NSConsumesSelfAttr>(this)->clone(C);
    8655           0 :   case attr::NSReturnsAutoreleased:
    8656           0 :     return cast<NSReturnsAutoreleasedAttr>(this)->clone(C);
    8657           8 :   case attr::NSReturnsNotRetained:
    8658           8 :     return cast<NSReturnsNotRetainedAttr>(this)->clone(C);
    8659         174 :   case attr::NSReturnsRetained:
    8660         174 :     return cast<NSReturnsRetainedAttr>(this)->clone(C);
    8661           1 :   case attr::Naked:
    8662           1 :     return cast<NakedAttr>(this)->clone(C);
    8663           0 :   case attr::NoAlias:
    8664           0 :     return cast<NoAliasAttr>(this)->clone(C);
    8665           0 :   case attr::NoCommon:
    8666           0 :     return cast<NoCommonAttr>(this)->clone(C);
    8667           3 :   case attr::NoDebug:
    8668           3 :     return cast<NoDebugAttr>(this)->clone(C);
    8669           0 :   case attr::NoDuplicate:
    8670           0 :     return cast<NoDuplicateAttr>(this)->clone(C);
    8671          26 :   case attr::NoInline:
    8672          26 :     return cast<NoInlineAttr>(this)->clone(C);
    8673           2 :   case attr::NoInstrumentFunction:
    8674           2 :     return cast<NoInstrumentFunctionAttr>(this)->clone(C);
    8675           0 :   case attr::NoMicroMips:
    8676           0 :     return cast<NoMicroMipsAttr>(this)->clone(C);
    8677           2 :   case attr::NoMips16:
    8678           2 :     return cast<NoMips16Attr>(this)->clone(C);
    8679           0 :   case attr::NoReturn:
    8680           0 :     return cast<NoReturnAttr>(this)->clone(C);
    8681          18 :   case attr::NoSanitize:
    8682          18 :     return cast<NoSanitizeAttr>(this)->clone(C);
    8683           0 :   case attr::NoSplitStack:
    8684           0 :     return cast<NoSplitStackAttr>(this)->clone(C);
    8685           5 :   case attr::NoThreadSafetyAnalysis:
    8686           5 :     return cast<NoThreadSafetyAnalysisAttr>(this)->clone(C);
    8687         772 :   case attr::NoThrow:
    8688         772 :     return cast<NoThrowAttr>(this)->clone(C);
    8689        1381 :   case attr::NonNull:
    8690        1381 :     return cast<NonNullAttr>(this)->clone(C);
    8691           0 :   case attr::NotTailCalled:
    8692           0 :     return cast<NotTailCalledAttr>(this)->clone(C);
    8693           0 :   case attr::OMPCaptureKind:
    8694           0 :     return cast<OMPCaptureKindAttr>(this)->clone(C);
    8695           0 :   case attr::OMPCaptureNoInit:
    8696           0 :     return cast<OMPCaptureNoInitAttr>(this)->clone(C);
    8697           0 :   case attr::OMPDeclareSimdDecl:
    8698           0 :     return cast<OMPDeclareSimdDeclAttr>(this)->clone(C);
    8699           0 :   case attr::OMPDeclareTargetDecl:
    8700           0 :     return cast<OMPDeclareTargetDeclAttr>(this)->clone(C);
    8701          20 :   case attr::OMPThreadPrivateDecl:
    8702          20 :     return cast<OMPThreadPrivateDeclAttr>(this)->clone(C);
    8703           0 :   case attr::ObjCBoxable:
    8704           0 :     return cast<ObjCBoxableAttr>(this)->clone(C);
    8705           4 :   case attr::ObjCBridge:
    8706           4 :     return cast<ObjCBridgeAttr>(this)->clone(C);
    8707           1 :   case attr::ObjCBridgeMutable:
    8708           1 :     return cast<ObjCBridgeMutableAttr>(this)->clone(C);
    8709           0 :   case attr::ObjCBridgeRelated:
    8710           0 :     return cast<ObjCBridgeRelatedAttr>(this)->clone(C);
    8711           0 :   case attr::ObjCDesignatedInitializer:
    8712           0 :     return cast<ObjCDesignatedInitializerAttr>(this)->clone(C);
    8713           0 :   case attr::ObjCException:
    8714           0 :     return cast<ObjCExceptionAttr>(this)->clone(C);
    8715           0 :   case attr::ObjCExplicitProtocolImpl:
    8716           0 :     return cast<ObjCExplicitProtocolImplAttr>(this)->clone(C);
    8717           0 :   case attr::ObjCIndependentClass:
    8718           0 :     return cast<ObjCIndependentClassAttr>(this)->clone(C);
    8719           9 :   case attr::ObjCMethodFamily:
    8720           9 :     return cast<ObjCMethodFamilyAttr>(this)->clone(C);
    8721           0 :   case attr::ObjCNSObject:
    8722           0 :     return cast<ObjCNSObjectAttr>(this)->clone(C);
    8723           0 :   case attr::ObjCPreciseLifetime:
    8724           0 :     return cast<ObjCPreciseLifetimeAttr>(this)->clone(C);
    8725           0 :   case attr::ObjCRequiresPropertyDefs:
    8726           0 :     return cast<ObjCRequiresPropertyDefsAttr>(this)->clone(C);
    8727          12 :   case attr::ObjCRequiresSuper:
    8728          12 :     return cast<ObjCRequiresSuperAttr>(this)->clone(C);
    8729           0 :   case attr::ObjCReturnsInnerPointer:
    8730           0 :     return cast<ObjCReturnsInnerPointerAttr>(this)->clone(C);
    8731           0 :   case attr::ObjCRootClass:
    8732           0 :     return cast<ObjCRootClassAttr>(this)->clone(C);
    8733           0 :   case attr::ObjCRuntimeName:
    8734           0 :     return cast<ObjCRuntimeNameAttr>(this)->clone(C);
    8735           0 :   case attr::ObjCRuntimeVisible:
    8736           0 :     return cast<ObjCRuntimeVisibleAttr>(this)->clone(C);
    8737           0 :   case attr::ObjCSubclassingRestricted:
    8738           0 :     return cast<ObjCSubclassingRestrictedAttr>(this)->clone(C);
    8739           0 :   case attr::OpenCLAccess:
    8740           0 :     return cast<OpenCLAccessAttr>(this)->clone(C);
    8741           0 :   case attr::OpenCLIntelReqdSubGroupSize:
    8742           0 :     return cast<OpenCLIntelReqdSubGroupSizeAttr>(this)->clone(C);
    8743           0 :   case attr::OpenCLKernel:
    8744           0 :     return cast<OpenCLKernelAttr>(this)->clone(C);
    8745           0 :   case attr::OpenCLUnrollHint:
    8746           0 :     return cast<OpenCLUnrollHintAttr>(this)->clone(C);
    8747           0 :   case attr::OptimizeNone:
    8748           0 :     return cast<OptimizeNoneAttr>(this)->clone(C);
    8749           0 :   case attr::Overloadable:
    8750           0 :     return cast<OverloadableAttr>(this)->clone(C);
    8751           5 :   case attr::Override:
    8752           5 :     return cast<OverrideAttr>(this)->clone(C);
    8753           0 :   case attr::Ownership:
    8754           0 :     return cast<OwnershipAttr>(this)->clone(C);
    8755           0 :   case attr::Packed:
    8756           0 :     return cast<PackedAttr>(this)->clone(C);
    8757           0 :   case attr::ParamTypestate:
    8758           0 :     return cast<ParamTypestateAttr>(this)->clone(C);
    8759           0 :   case attr::Pascal:
    8760           0 :     return cast<PascalAttr>(this)->clone(C);
    8761          20 :   case attr::PassObjectSize:
    8762          20 :     return cast<PassObjectSizeAttr>(this)->clone(C);
    8763           0 :   case attr::Pcs:
    8764           0 :     return cast<PcsAttr>(this)->clone(C);
    8765           5 :   case attr::PragmaClangBSSSection:
    8766           5 :     return cast<PragmaClangBSSSectionAttr>(this)->clone(C);
    8767           0 :   case attr::PragmaClangDataSection:
    8768           0 :     return cast<PragmaClangDataSectionAttr>(this)->clone(C);
    8769           2 :   case attr::PragmaClangRodataSection:
    8770           2 :     return cast<PragmaClangRodataSectionAttr>(this)->clone(C);
    8771           0 :   case attr::PragmaClangTextSection:
    8772           0 :     return cast<PragmaClangTextSectionAttr>(this)->clone(C);
    8773           0 :   case attr::PreserveAll:
    8774           0 :     return cast<PreserveAllAttr>(this)->clone(C);
    8775           0 :   case attr::PreserveMost:
    8776           0 :     return cast<PreserveMostAttr>(this)->clone(C);
    8777           0 :   case attr::PtGuardedBy:
    8778           0 :     return cast<PtGuardedByAttr>(this)->clone(C);
    8779           0 :   case attr::PtGuardedVar:
    8780           0 :     return cast<PtGuardedVarAttr>(this)->clone(C);
    8781         398 :   case attr::Pure:
    8782         398 :     return cast<PureAttr>(this)->clone(C);
    8783           0 :   case attr::RegCall:
    8784           0 :     return cast<RegCallAttr>(this)->clone(C);
    8785          19 :   case attr::ReleaseCapability:
    8786          19 :     return cast<ReleaseCapabilityAttr>(this)->clone(C);
    8787           0 :   case attr::RenderScriptKernel:
    8788           0 :     return cast<RenderScriptKernelAttr>(this)->clone(C);
    8789           0 :   case attr::ReqdWorkGroupSize:
    8790           0 :     return cast<ReqdWorkGroupSizeAttr>(this)->clone(C);
    8791          22 :   case attr::RequireConstantInit:
    8792          22 :     return cast<RequireConstantInitAttr>(this)->clone(C);
    8793          70 :   case attr::RequiresCapability:
    8794          70 :     return cast<RequiresCapabilityAttr>(this)->clone(C);
    8795           6 :   case attr::Restrict:
    8796           6 :     return cast<RestrictAttr>(this)->clone(C);
    8797           2 :   case attr::ReturnTypestate:
    8798           2 :     return cast<ReturnTypestateAttr>(this)->clone(C);
    8799           1 :   case attr::ReturnsNonNull:
    8800           1 :     return cast<ReturnsNonNullAttr>(this)->clone(C);
    8801          36 :   case attr::ReturnsTwice:
    8802          36 :     return cast<ReturnsTwiceAttr>(this)->clone(C);
    8803           0 :   case attr::ScopedLockable:
    8804           0 :     return cast<ScopedLockableAttr>(this)->clone(C);
    8805           0 :   case attr::Section:
    8806           0 :     return cast<SectionAttr>(this)->clone(C);
    8807           1 :   case attr::SelectAny:
    8808           1 :     return cast<SelectAnyAttr>(this)->clone(C);
    8809           0 :   case attr::Sentinel:
    8810           0 :     return cast<SentinelAttr>(this)->clone(C);
    8811           0 :   case attr::SetTypestate:
    8812           0 :     return cast<SetTypestateAttr>(this)->clone(C);
    8813           7 :   case attr::SharedTrylockFunction:
    8814           7 :     return cast<SharedTrylockFunctionAttr>(this)->clone(C);
    8815           0 :   case attr::StdCall:
    8816           0 :     return cast<StdCallAttr>(this)->clone(C);
    8817           0 :   case attr::Suppress:
    8818           0 :     return cast<SuppressAttr>(this)->clone(C);
    8819           0 :   case attr::SwiftCall:
    8820           0 :     return cast<SwiftCallAttr>(this)->clone(C);
    8821           0 :   case attr::SwiftContext:
    8822           0 :     return cast<SwiftContextAttr>(this)->clone(C);
    8823           0 :   case attr::SwiftErrorResult:
    8824           0 :     return cast<SwiftErrorResultAttr>(this)->clone(C);
    8825           0 :   case attr::SwiftIndirectResult:
    8826           0 :     return cast<SwiftIndirectResultAttr>(this)->clone(C);
    8827           0 :   case attr::SysVABI:
    8828           0 :     return cast<SysVABIAttr>(this)->clone(C);
    8829           3 :   case attr::TLSModel:
    8830           3 :     return cast<TLSModelAttr>(this)->clone(C);
    8831           1 :   case attr::Target:
    8832           1 :     return cast<TargetAttr>(this)->clone(C);
    8833           0 :   case attr::TestTypestate:
    8834           0 :     return cast<TestTypestateAttr>(this)->clone(C);
    8835           0 :   case attr::ThisCall:
    8836           0 :     return cast<ThisCallAttr>(this)->clone(C);
    8837           0 :   case attr::Thread:
    8838           0 :     return cast<ThreadAttr>(this)->clone(C);
    8839           0 :   case attr::TransparentUnion:
    8840           0 :     return cast<TransparentUnionAttr>(this)->clone(C);
    8841           0 :   case attr::TryAcquireCapability:
    8842           0 :     return cast<TryAcquireCapabilityAttr>(this)->clone(C);
    8843           0 :   case attr::TypeTagForDatatype:
    8844           0 :     return cast<TypeTagForDatatypeAttr>(this)->clone(C);
    8845         104 :   case attr::TypeVisibility:
    8846         104 :     return cast<TypeVisibilityAttr>(this)->clone(C);
    8847          53 :   case attr::Unavailable:
    8848          53 :     return cast<UnavailableAttr>(this)->clone(C);
    8849         314 :   case attr::Unused:
    8850         314 :     return cast<UnusedAttr>(this)->clone(C);
    8851           0 :   case attr::Used:
    8852           0 :     return cast<UsedAttr>(this)->clone(C);
    8853           0 :   case attr::Uuid:
    8854           0 :     return cast<UuidAttr>(this)->clone(C);
    8855           0 :   case attr::VecReturn:
    8856           0 :     return cast<VecReturnAttr>(this)->clone(C);
    8857           0 :   case attr::VecTypeHint:
    8858           0 :     return cast<VecTypeHintAttr>(this)->clone(C);
    8859           0 :   case attr::VectorCall:
    8860           0 :     return cast<VectorCallAttr>(this)->clone(C);
    8861           8 :   case attr::Visibility:
    8862           8 :     return cast<VisibilityAttr>(this)->clone(C);
    8863           0 :   case attr::WarnUnused:
    8864           0 :     return cast<WarnUnusedAttr>(this)->clone(C);
    8865         283 :   case attr::WarnUnusedResult:
    8866         283 :     return cast<WarnUnusedResultAttr>(this)->clone(C);
    8867          36 :   case attr::Weak:
    8868          36 :     return cast<WeakAttr>(this)->clone(C);
    8869           8 :   case attr::WeakImport:
    8870           8 :     return cast<WeakImportAttr>(this)->clone(C);
    8871           0 :   case attr::WeakRef:
    8872           0 :     return cast<WeakRefAttr>(this)->clone(C);
    8873           0 :   case attr::WorkGroupSizeHint:
    8874           0 :     return cast<WorkGroupSizeHintAttr>(this)->clone(C);
    8875           1 :   case attr::X86ForceAlignArgPointer:
    8876           1 :     return cast<X86ForceAlignArgPointerAttr>(this)->clone(C);
    8877           0 :   case attr::XRayInstrument:
    8878           0 :     return cast<XRayInstrumentAttr>(this)->clone(C);
    8879           0 :   case attr::XRayLogArgs:
    8880           0 :     return cast<XRayLogArgsAttr>(this)->clone(C);
    8881             :   }
    8882           0 :   llvm_unreachable("Unexpected attribute kind!");
    8883             : }
    8884             : 
    8885         352 : void Attr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    8886         352 :   switch (getKind()) {
    8887           0 :   case attr::AMDGPUFlatWorkGroupSize:
    8888           0 :     return cast<AMDGPUFlatWorkGroupSizeAttr>(this)->printPretty(OS, Policy);
    8889           0 :   case attr::AMDGPUNumSGPR:
    8890           0 :     return cast<AMDGPUNumSGPRAttr>(this)->printPretty(OS, Policy);
    8891           0 :   case attr::AMDGPUNumVGPR:
    8892           0 :     return cast<AMDGPUNumVGPRAttr>(this)->printPretty(OS, Policy);
    8893           0 :   case attr::AMDGPUWavesPerEU:
    8894           0 :     return cast<AMDGPUWavesPerEUAttr>(this)->printPretty(OS, Policy);
    8895           0 :   case attr::ARMInterrupt:
    8896           0 :     return cast<ARMInterruptAttr>(this)->printPretty(OS, Policy);
    8897           0 :   case attr::AVRInterrupt:
    8898           0 :     return cast<AVRInterruptAttr>(this)->printPretty(OS, Policy);
    8899           0 :   case attr::AVRSignal:
    8900           0 :     return cast<AVRSignalAttr>(this)->printPretty(OS, Policy);
    8901           0 :   case attr::AbiTag:
    8902           0 :     return cast<AbiTagAttr>(this)->printPretty(OS, Policy);
    8903           0 :   case attr::AcquireCapability:
    8904           0 :     return cast<AcquireCapabilityAttr>(this)->printPretty(OS, Policy);
    8905           0 :   case attr::AcquiredAfter:
    8906           0 :     return cast<AcquiredAfterAttr>(this)->printPretty(OS, Policy);
    8907           0 :   case attr::AcquiredBefore:
    8908           0 :     return cast<AcquiredBeforeAttr>(this)->printPretty(OS, Policy);
    8909           0 :   case attr::Alias:
    8910           0 :     return cast<AliasAttr>(this)->printPretty(OS, Policy);
    8911           0 :   case attr::AlignMac68k:
    8912           0 :     return cast<AlignMac68kAttr>(this)->printPretty(OS, Policy);
    8913           0 :   case attr::AlignValue:
    8914           0 :     return cast<AlignValueAttr>(this)->printPretty(OS, Policy);
    8915          20 :   case attr::Aligned:
    8916          20 :     return cast<AlignedAttr>(this)->printPretty(OS, Policy);
    8917           0 :   case attr::AllocAlign:
    8918           0 :     return cast<AllocAlignAttr>(this)->printPretty(OS, Policy);
    8919           0 :   case attr::AllocSize:
    8920           0 :     return cast<AllocSizeAttr>(this)->printPretty(OS, Policy);
    8921           0 :   case attr::AlwaysInline:
    8922           0 :     return cast<AlwaysInlineAttr>(this)->printPretty(OS, Policy);
    8923           0 :   case attr::AnalyzerNoReturn:
    8924           0 :     return cast<AnalyzerNoReturnAttr>(this)->printPretty(OS, Policy);
    8925           0 :   case attr::Annotate:
    8926           0 :     return cast<AnnotateAttr>(this)->printPretty(OS, Policy);
    8927           0 :   case attr::AnyX86Interrupt:
    8928           0 :     return cast<AnyX86InterruptAttr>(this)->printPretty(OS, Policy);
    8929           0 :   case attr::AnyX86NoCallerSavedRegisters:
    8930           0 :     return cast<AnyX86NoCallerSavedRegistersAttr>(this)->printPretty(OS, Policy);
    8931           0 :   case attr::ArcWeakrefUnavailable:
    8932           0 :     return cast<ArcWeakrefUnavailableAttr>(this)->printPretty(OS, Policy);
    8933           0 :   case attr::ArgumentWithTypeTag:
    8934           0 :     return cast<ArgumentWithTypeTagAttr>(this)->printPretty(OS, Policy);
    8935           0 :   case attr::AsmLabel:
    8936           0 :     return cast<AsmLabelAttr>(this)->printPretty(OS, Policy);
    8937           0 :   case attr::AssertCapability:
    8938           0 :     return cast<AssertCapabilityAttr>(this)->printPretty(OS, Policy);
    8939           0 :   case attr::AssertExclusiveLock:
    8940           0 :     return cast<AssertExclusiveLockAttr>(this)->printPretty(OS, Policy);
    8941           0 :   case attr::AssertSharedLock:
    8942           0 :     return cast<AssertSharedLockAttr>(this)->printPretty(OS, Policy);
    8943           0 :   case attr::AssumeAligned:
    8944           0 :     return cast<AssumeAlignedAttr>(this)->printPretty(OS, Policy);
    8945           6 :   case attr::Availability:
    8946           6 :     return cast<AvailabilityAttr>(this)->printPretty(OS, Policy);
    8947           1 :   case attr::Blocks:
    8948           1 :     return cast<BlocksAttr>(this)->printPretty(OS, Policy);
    8949           0 :   case attr::C11NoReturn:
    8950           0 :     return cast<C11NoReturnAttr>(this)->printPretty(OS, Policy);
    8951           0 :   case attr::CDecl:
    8952           0 :     return cast<CDeclAttr>(this)->printPretty(OS, Policy);
    8953           0 :   case attr::CFAuditedTransfer:
    8954           0 :     return cast<CFAuditedTransferAttr>(this)->printPretty(OS, Policy);
    8955           0 :   case attr::CFConsumed:
    8956           0 :     return cast<CFConsumedAttr>(this)->printPretty(OS, Policy);
    8957           0 :   case attr::CFReturnsNotRetained:
    8958           0 :     return cast<CFReturnsNotRetainedAttr>(this)->printPretty(OS, Policy);
    8959           0 :   case attr::CFReturnsRetained:
    8960           0 :     return cast<CFReturnsRetainedAttr>(this)->printPretty(OS, Policy);
    8961           0 :   case attr::CFUnknownTransfer:
    8962           0 :     return cast<CFUnknownTransferAttr>(this)->printPretty(OS, Policy);
    8963           0 :   case attr::CUDAConstant:
    8964           0 :     return cast<CUDAConstantAttr>(this)->printPretty(OS, Policy);
    8965           0 :   case attr::CUDADevice:
    8966           0 :     return cast<CUDADeviceAttr>(this)->printPretty(OS, Policy);
    8967           0 :   case attr::CUDAGlobal:
    8968           0 :     return cast<CUDAGlobalAttr>(this)->printPretty(OS, Policy);
    8969           0 :   case attr::CUDAHost:
    8970           0 :     return cast<CUDAHostAttr>(this)->printPretty(OS, Policy);
    8971           0 :   case attr::CUDAInvalidTarget:
    8972           0 :     return cast<CUDAInvalidTargetAttr>(this)->printPretty(OS, Policy);
    8973           0 :   case attr::CUDALaunchBounds:
    8974           0 :     return cast<CUDALaunchBoundsAttr>(this)->printPretty(OS, Policy);
    8975           0 :   case attr::CUDAShared:
    8976           0 :     return cast<CUDASharedAttr>(this)->printPretty(OS, Policy);
    8977           1 :   case attr::CXX11NoReturn:
    8978           1 :     return cast<CXX11NoReturnAttr>(this)->printPretty(OS, Policy);
    8979           1 :   case attr::CallableWhen:
    8980           1 :     return cast<CallableWhenAttr>(this)->printPretty(OS, Policy);
    8981           0 :   case attr::Capability:
    8982           0 :     return cast<CapabilityAttr>(this)->printPretty(OS, Policy);
    8983           0 :   case attr::CapturedRecord:
    8984           0 :     return cast<CapturedRecordAttr>(this)->printPretty(OS, Policy);
    8985           0 :   case attr::CarriesDependency:
    8986           0 :     return cast<CarriesDependencyAttr>(this)->printPretty(OS, Policy);
    8987           0 :   case attr::Cleanup:
    8988           0 :     return cast<CleanupAttr>(this)->printPretty(OS, Policy);
    8989           6 :   case attr::Cold:
    8990           6 :     return cast<ColdAttr>(this)->printPretty(OS, Policy);
    8991           0 :   case attr::Common:
    8992           0 :     return cast<CommonAttr>(this)->printPretty(OS, Policy);
    8993           6 :   case attr::Const:
    8994           6 :     return cast<ConstAttr>(this)->printPretty(OS, Policy);
    8995           0 :   case attr::Constructor:
    8996           0 :     return cast<ConstructorAttr>(this)->printPretty(OS, Policy);
    8997           1 :   case attr::Consumable:
    8998           1 :     return cast<ConsumableAttr>(this)->printPretty(OS, Policy);
    8999           0 :   case attr::ConsumableAutoCast:
    9000           0 :     return cast<ConsumableAutoCastAttr>(this)->printPretty(OS, Policy);
    9001           0 :   case attr::ConsumableSetOnRead:
    9002           0 :     return cast<ConsumableSetOnReadAttr>(this)->printPretty(OS, Policy);
    9003           0 :   case attr::Convergent:
    9004           0 :     return cast<ConvergentAttr>(this)->printPretty(OS, Policy);
    9005           0 :   case attr::DLLExport:
    9006           0 :     return cast<DLLExportAttr>(this)->printPretty(OS, Policy);
    9007           0 :   case attr::DLLImport:
    9008           0 :     return cast<DLLImportAttr>(this)->printPretty(OS, Policy);
    9009           9 :   case attr::Deprecated:
    9010           9 :     return cast<DeprecatedAttr>(this)->printPretty(OS, Policy);
    9011           0 :   case attr::Destructor:
    9012           0 :     return cast<DestructorAttr>(this)->printPretty(OS, Policy);
    9013           0 :   case attr::DiagnoseIf:
    9014           0 :     return cast<DiagnoseIfAttr>(this)->printPretty(OS, Policy);
    9015           0 :   case attr::DisableTailCalls:
    9016           0 :     return cast<DisableTailCallsAttr>(this)->printPretty(OS, Policy);
    9017           0 :   case attr::EmptyBases:
    9018           0 :     return cast<EmptyBasesAttr>(this)->printPretty(OS, Policy);
    9019           0 :   case attr::EnableIf:
    9020           0 :     return cast<EnableIfAttr>(this)->printPretty(OS, Policy);
    9021           0 :   case attr::EnumExtensibility:
    9022           0 :     return cast<EnumExtensibilityAttr>(this)->printPretty(OS, Policy);
    9023           0 :   case attr::ExclusiveTrylockFunction:
    9024           0 :     return cast<ExclusiveTrylockFunctionAttr>(this)->printPretty(OS, Policy);
    9025           0 :   case attr::ExternalSourceSymbol:
    9026           0 :     return cast<ExternalSourceSymbolAttr>(this)->printPretty(OS, Policy);
    9027           3 :   case attr::FallThrough:
    9028           3 :     return cast<FallThroughAttr>(this)->printPretty(OS, Policy);
    9029           0 :   case attr::FastCall:
    9030           0 :     return cast<FastCallAttr>(this)->printPretty(OS, Policy);
    9031           0 :   case attr::Final:
    9032           0 :     return cast<FinalAttr>(this)->printPretty(OS, Policy);
    9033           0 :   case attr::FlagEnum:
    9034           0 :     return cast<FlagEnumAttr>(this)->printPretty(OS, Policy);
    9035           0 :   case attr::Flatten:
    9036           0 :     return cast<FlattenAttr>(this)->printPretty(OS, Policy);
    9037           1 :   case attr::Format:
    9038           1 :     return cast<FormatAttr>(this)->printPretty(OS, Policy);
    9039           0 :   case attr::FormatArg:
    9040           0 :     return cast<FormatArgAttr>(this)->printPretty(OS, Policy);
    9041           2 :   case attr::GNUInline:
    9042           2 :     return cast<GNUInlineAttr>(this)->printPretty(OS, Policy);
    9043           0 :   case attr::GuardedBy:
    9044           0 :     return cast<GuardedByAttr>(this)->printPretty(OS, Policy);
    9045           0 :   case attr::GuardedVar:
    9046           0 :     return cast<GuardedVarAttr>(this)->printPretty(OS, Policy);
    9047           0 :   case attr::Hot:
    9048           0 :     return cast<HotAttr>(this)->printPretty(OS, Policy);
    9049           0 :   case attr::IBAction:
    9050           0 :     return cast<IBActionAttr>(this)->printPretty(OS, Policy);
    9051           0 :   case attr::IBOutlet:
    9052           0 :     return cast<IBOutletAttr>(this)->printPretty(OS, Policy);
    9053           0 :   case attr::IBOutletCollection:
    9054           0 :     return cast<IBOutletCollectionAttr>(this)->printPretty(OS, Policy);
    9055           0 :   case attr::IFunc:
    9056           0 :     return cast<IFuncAttr>(this)->printPretty(OS, Policy);
    9057           0 :   case attr::InitPriority:
    9058           0 :     return cast<InitPriorityAttr>(this)->printPretty(OS, Policy);
    9059           1 :   case attr::InitSeg:
    9060           1 :     return cast<InitSegAttr>(this)->printPretty(OS, Policy);
    9061           0 :   case attr::IntelOclBicc:
    9062           0 :     return cast<IntelOclBiccAttr>(this)->printPretty(OS, Policy);
    9063           0 :   case attr::InternalLinkage:
    9064           0 :     return cast<InternalLinkageAttr>(this)->printPretty(OS, Policy);
    9065           0 :   case attr::LTOVisibilityPublic:
    9066           0 :     return cast<LTOVisibilityPublicAttr>(this)->printPretty(OS, Policy);
    9067           0 :   case attr::LayoutVersion:
    9068           0 :     return cast<LayoutVersionAttr>(this)->printPretty(OS, Policy);
    9069           0 :   case attr::LockReturned:
    9070           0 :     return cast<LockReturnedAttr>(this)->printPretty(OS, Policy);
    9071           0 :   case attr::LocksExcluded:
    9072           0 :     return cast<LocksExcludedAttr>(this)->printPretty(OS, Policy);
    9073          42 :   case attr::LoopHint:
    9074          42 :     return cast<LoopHintAttr>(this)->printPretty(OS, Policy);
    9075           0 :   case attr::MSABI:
    9076           0 :     return cast<MSABIAttr>(this)->printPretty(OS, Policy);
    9077           0 :   case attr::MSInheritance:
    9078           0 :     return cast<MSInheritanceAttr>(this)->printPretty(OS, Policy);
    9079           0 :   case attr::MSNoVTable:
    9080           0 :     return cast<MSNoVTableAttr>(this)->printPretty(OS, Policy);
    9081           0 :   case attr::MSP430Interrupt:
    9082           0 :     return cast<MSP430InterruptAttr>(this)->printPretty(OS, Policy);
    9083           0 :   case attr::MSStruct:
    9084           0 :     return cast<MSStructAttr>(this)->printPretty(OS, Policy);
    9085           0 :   case attr::MSVtorDisp:
    9086           0 :     return cast<MSVtorDispAttr>(this)->printPretty(OS, Policy);
    9087           0 :   case attr::MaxFieldAlignment:
    9088           0 :     return cast<MaxFieldAlignmentAttr>(this)->printPretty(OS, Policy);
    9089           0 :   case attr::MayAlias:
    9090           0 :     return cast<MayAliasAttr>(this)->printPretty(OS, Policy);
    9091           0 :   case attr::MicroMips:
    9092           0 :     return cast<MicroMipsAttr>(this)->printPretty(OS, Policy);
    9093           0 :   case attr::MinSize:
    9094           0 :     return cast<MinSizeAttr>(this)->printPretty(OS, Policy);
    9095           0 :   case attr::Mips16:
    9096           0 :     return cast<Mips16Attr>(this)->printPretty(OS, Policy);
    9097           0 :   case attr::MipsInterrupt:
    9098           0 :     return cast<MipsInterruptAttr>(this)->printPretty(OS, Policy);
    9099           0 :   case attr::MipsLongCall:
    9100           0 :     return cast<MipsLongCallAttr>(this)->printPretty(OS, Policy);
    9101           0 :   case attr::MipsShortCall:
    9102           0 :     return cast<MipsShortCallAttr>(this)->printPretty(OS, Policy);
    9103           3 :   case attr::Mode:
    9104           3 :     return cast<ModeAttr>(this)->printPretty(OS, Policy);
    9105           0 :   case attr::NSConsumed:
    9106           0 :     return cast<NSConsumedAttr>(this)->printPretty(OS, Policy);
    9107           0 :   case attr::NSConsumesSelf:
    9108           0 :     return cast<NSConsumesSelfAttr>(this)->printPretty(OS, Policy);
    9109           0 :   case attr::NSReturnsAutoreleased:
    9110           0 :     return cast<NSReturnsAutoreleasedAttr>(this)->printPretty(OS, Policy);
    9111           0 :   case attr::NSReturnsNotRetained:
    9112           0 :     return cast<NSReturnsNotRetainedAttr>(this)->printPretty(OS, Policy);
    9113           0 :   case attr::NSReturnsRetained:
    9114           0 :     return cast<NSReturnsRetainedAttr>(this)->printPretty(OS, Policy);
    9115           0 :   case attr::Naked:
    9116           0 :     return cast<NakedAttr>(this)->printPretty(OS, Policy);
    9117           0 :   case attr::NoAlias:
    9118           0 :     return cast<NoAliasAttr>(this)->printPretty(OS, Policy);
    9119           0 :   case attr::NoCommon:
    9120           0 :     return cast<NoCommonAttr>(this)->printPretty(OS, Policy);
    9121           0 :   case attr::NoDebug:
    9122           0 :     return cast<NoDebugAttr>(this)->printPretty(OS, Policy);
    9123           0 :   case attr::NoDuplicate:
    9124           0 :     return cast<NoDuplicateAttr>(this)->printPretty(OS, Policy);
    9125           1 :   case attr::NoInline:
    9126           1 :     return cast<NoInlineAttr>(this)->printPretty(OS, Policy);
    9127           0 :   case attr::NoInstrumentFunction:
    9128           0 :     return cast<NoInstrumentFunctionAttr>(this)->printPretty(OS, Policy);
    9129           0 :   case attr::NoMicroMips:
    9130           0 :     return cast<NoMicroMipsAttr>(this)->printPretty(OS, Policy);
    9131           0 :   case attr::NoMips16:
    9132           0 :     return cast<NoMips16Attr>(this)->printPretty(OS, Policy);
    9133           0 :   case attr::NoReturn:
    9134           0 :     return cast<NoReturnAttr>(this)->printPretty(OS, Policy);
    9135           4 :   case attr::NoSanitize:
    9136           4 :     return cast<NoSanitizeAttr>(this)->printPretty(OS, Policy);
    9137           0 :   case attr::NoSplitStack:
    9138           0 :     return cast<NoSplitStackAttr>(this)->printPretty(OS, Policy);
    9139           0 :   case attr::NoThreadSafetyAnalysis:
    9140           0 :     return cast<NoThreadSafetyAnalysisAttr>(this)->printPretty(OS, Policy);
    9141           0 :   case attr::NoThrow:
    9142           0 :     return cast<NoThrowAttr>(this)->printPretty(OS, Policy);
    9143           0 :   case attr::NonNull:
    9144           0 :     return cast<NonNullAttr>(this)->printPretty(OS, Policy);
    9145           0 :   case attr::NotTailCalled:
    9146           0 :     return cast<NotTailCalledAttr>(this)->printPretty(OS, Policy);
    9147           0 :   case attr::OMPCaptureKind:
    9148           0 :     return cast<OMPCaptureKindAttr>(this)->printPretty(OS, Policy);
    9149           0 :   case attr::OMPCaptureNoInit:
    9150           0 :     return cast<OMPCaptureNoInitAttr>(this)->printPretty(OS, Policy);
    9151          46 :   case attr::OMPDeclareSimdDecl:
    9152          46 :     return cast<OMPDeclareSimdDeclAttr>(this)->printPretty(OS, Policy);
    9153          46 :   case attr::OMPDeclareTargetDecl:
    9154          46 :     return cast<OMPDeclareTargetDeclAttr>(this)->printPretty(OS, Policy);
    9155         135 :   case attr::OMPThreadPrivateDecl:
    9156         135 :     return cast<OMPThreadPrivateDeclAttr>(this)->printPretty(OS, Policy);
    9157           0 :   case attr::ObjCBoxable:
    9158           0 :     return cast<ObjCBoxableAttr>(this)->printPretty(OS, Policy);
    9159           0 :   case attr::ObjCBridge:
    9160           0 :     return cast<ObjCBridgeAttr>(this)->printPretty(OS, Policy);
    9161           0 :   case attr::ObjCBridgeMutable:
    9162           0 :     return cast<ObjCBridgeMutableAttr>(this)->printPretty(OS, Policy);
    9163           1 :   case attr::ObjCBridgeRelated:
    9164           1 :     return cast<ObjCBridgeRelatedAttr>(this)->printPretty(OS, Policy);
    9165           0 :   case attr::ObjCDesignatedInitializer:
    9166           0 :     return cast<ObjCDesignatedInitializerAttr>(this)->printPretty(OS, Policy);
    9167           0 :   case attr::ObjCException:
    9168           0 :     return cast<ObjCExceptionAttr>(this)->printPretty(OS, Policy);
    9169           0 :   case attr::ObjCExplicitProtocolImpl:
    9170           0 :     return cast<ObjCExplicitProtocolImplAttr>(this)->printPretty(OS, Policy);
    9171           0 :   case attr::ObjCIndependentClass:
    9172           0 :     return cast<ObjCIndependentClassAttr>(this)->printPretty(OS, Policy);
    9173           0 :   case attr::ObjCMethodFamily:
    9174           0 :     return cast<ObjCMethodFamilyAttr>(this)->printPretty(OS, Policy);
    9175           0 :   case attr::ObjCNSObject:
    9176           0 :     return cast<ObjCNSObjectAttr>(this)->printPretty(OS, Policy);
    9177           0 :   case attr::ObjCPreciseLifetime:
    9178           0 :     return cast<ObjCPreciseLifetimeAttr>(this)->printPretty(OS, Policy);
    9179           0 :   case attr::ObjCRequiresPropertyDefs:
    9180           0 :     return cast<ObjCRequiresPropertyDefsAttr>(this)->printPretty(OS, Policy);
    9181           0 :   case attr::ObjCRequiresSuper:
    9182           0 :     return cast<ObjCRequiresSuperAttr>(this)->printPretty(OS, Policy);
    9183           0 :   case attr::ObjCReturnsInnerPointer:
    9184           0 :     return cast<ObjCReturnsInnerPointerAttr>(this)->printPretty(OS, Policy);
    9185           0 :   case attr::ObjCRootClass:
    9186           0 :     return cast<ObjCRootClassAttr>(this)->printPretty(OS, Policy);
    9187           0 :   case attr::ObjCRuntimeName:
    9188           0 :     return cast<ObjCRuntimeNameAttr>(this)->printPretty(OS, Policy);
    9189           0 :   case attr::ObjCRuntimeVisible:
    9190           0 :     return cast<ObjCRuntimeVisibleAttr>(this)->printPretty(OS, Policy);
    9191           0 :   case attr::ObjCSubclassingRestricted:
    9192           0 :     return cast<ObjCSubclassingRestrictedAttr>(this)->printPretty(OS, Policy);
    9193           0 :   case attr::OpenCLAccess:
    9194           0 :     return cast<OpenCLAccessAttr>(this)->printPretty(OS, Policy);
    9195           0 :   case attr::OpenCLIntelReqdSubGroupSize:
    9196           0 :     return cast<OpenCLIntelReqdSubGroupSizeAttr>(this)->printPretty(OS, Policy);
    9197           0 :   case attr::OpenCLKernel:
    9198           0 :     return cast<OpenCLKernelAttr>(this)->printPretty(OS, Policy);
    9199           0 :   case attr::OpenCLUnrollHint:
    9200           0 :     return cast<OpenCLUnrollHintAttr>(this)->printPretty(OS, Policy);
    9201           0 :   case attr::OptimizeNone:
    9202           0 :     return cast<OptimizeNoneAttr>(this)->printPretty(OS, Policy);
    9203           0 :   case attr::Overloadable:
    9204           0 :     return cast<OverloadableAttr>(this)->printPretty(OS, Policy);
    9205           0 :   case attr::Override:
    9206           0 :     return cast<OverrideAttr>(this)->printPretty(OS, Policy);
    9207           0 :   case attr::Ownership:
    9208           0 :     return cast<OwnershipAttr>(this)->printPretty(OS, Policy);
    9209           0 :   case attr::Packed:
    9210           0 :     return cast<PackedAttr>(this)->printPretty(OS, Policy);
    9211           0 :   case attr::ParamTypestate:
    9212           0 :     return cast<ParamTypestateAttr>(this)->printPretty(OS, Policy);
    9213           0 :   case attr::Pascal:
    9214           0 :     return cast<PascalAttr>(this)->printPretty(OS, Policy);
    9215           0 :   case attr::PassObjectSize:
    9216           0 :     return cast<PassObjectSizeAttr>(this)->printPretty(OS, Policy);
    9217           0 :   case attr::Pcs:
    9218           0 :     return cast<PcsAttr>(this)->printPretty(OS, Policy);
    9219           0 :   case attr::PragmaClangBSSSection:
    9220           0 :     return cast<PragmaClangBSSSectionAttr>(this)->printPretty(OS, Policy);
    9221           0 :   case attr::PragmaClangDataSection:
    9222           0 :     return cast<PragmaClangDataSectionAttr>(this)->printPretty(OS, Policy);
    9223           0 :   case attr::PragmaClangRodataSection:
    9224           0 :     return cast<PragmaClangRodataSectionAttr>(this)->printPretty(OS, Policy);
    9225           0 :   case attr::PragmaClangTextSection:
    9226           0 :     return cast<PragmaClangTextSectionAttr>(this)->printPretty(OS, Policy);
    9227           0 :   case attr::PreserveAll:
    9228           0 :     return cast<PreserveAllAttr>(this)->printPretty(OS, Policy);
    9229           0 :   case attr::PreserveMost:
    9230           0 :     return cast<PreserveMostAttr>(this)->printPretty(OS, Policy);
    9231           0 :   case attr::PtGuardedBy:
    9232           0 :     return cast<PtGuardedByAttr>(this)->printPretty(OS, Policy);
    9233           0 :   case attr::PtGuardedVar:
    9234           0 :     return cast<PtGuardedVarAttr>(this)->printPretty(OS, Policy);
    9235           5 :   case attr::Pure:
    9236           5 :     return cast<PureAttr>(this)->printPretty(OS, Policy);
    9237           0 :   case attr::RegCall:
    9238           0 :     return cast<RegCallAttr>(this)->printPretty(OS, Policy);
    9239           0 :   case attr::ReleaseCapability:
    9240           0 :     return cast<ReleaseCapabilityAttr>(this)->printPretty(OS, Policy);
    9241           0 :   case attr::RenderScriptKernel:
    9242           0 :     return cast<RenderScriptKernelAttr>(this)->printPretty(OS, Policy);
    9243           0 :   case attr::ReqdWorkGroupSize:
    9244           0 :     return cast<ReqdWorkGroupSizeAttr>(this)->printPretty(OS, Policy);
    9245           0 :   case attr::RequireConstantInit:
    9246           0 :     return cast<RequireConstantInitAttr>(this)->printPretty(OS, Policy);
    9247           0 :   case attr::RequiresCapability:
    9248           0 :     return cast<RequiresCapabilityAttr>(this)->printPretty(OS, Policy);
    9249           1 :   case attr::Restrict:
    9250           1 :     return cast<RestrictAttr>(this)->printPretty(OS, Policy);
    9251           0 :   case attr::ReturnTypestate:
    9252           0 :     return cast<ReturnTypestateAttr>(this)->printPretty(OS, Policy);
    9253           0 :   case attr::ReturnsNonNull:
    9254           0 :     return cast<ReturnsNonNullAttr>(this)->printPretty(OS, Policy);
    9255           0 :   case attr::ReturnsTwice:
    9256           0 :     return cast<ReturnsTwiceAttr>(this)->printPretty(OS, Policy);
    9257           0 :   case attr::ScopedLockable:
    9258           0 :     return cast<ScopedLockableAttr>(this)->printPretty(OS, Policy);
    9259           0 :   case attr::Section:
    9260           0 :     return cast<SectionAttr>(this)->printPretty(OS, Policy);
    9261           0 :   case attr::SelectAny:
    9262           0 :     return cast<SelectAnyAttr>(this)->printPretty(OS, Policy);
    9263           0 :   case attr::Sentinel:
    9264           0 :     return cast<SentinelAttr>(this)->printPretty(OS, Policy);
    9265           0 :   case attr::SetTypestate:
    9266           0 :     return cast<SetTypestateAttr>(this)->printPretty(OS, Policy);
    9267           0 :   case attr::SharedTrylockFunction:
    9268           0 :     return cast<SharedTrylockFunctionAttr>(this)->printPretty(OS, Policy);
    9269           0 :   case attr::StdCall:
    9270           0 :     return cast<StdCallAttr>(this)->printPretty(OS, Policy);
    9271           0 :   case attr::Suppress:
    9272           0 :     return cast<SuppressAttr>(this)->printPretty(OS, Policy);
    9273           0 :   case attr::SwiftCall:
    9274           0 :     return cast<SwiftCallAttr>(this)->printPretty(OS, Policy);
    9275           0 :   case attr::SwiftContext:
    9276           0 :     return cast<SwiftContextAttr>(this)->printPretty(OS, Policy);
    9277           0 :   case attr::SwiftErrorResult:
    9278           0 :     return cast<SwiftErrorResultAttr>(this)->printPretty(OS, Policy);
    9279           0 :   case attr::SwiftIndirectResult:
    9280           0 :     return cast<SwiftIndirectResultAttr>(this)->printPretty(OS, Policy);
    9281           0 :   case attr::SysVABI:
    9282           0 :     return cast<SysVABIAttr>(this)->printPretty(OS, Policy);
    9283           0 :   case attr::TLSModel:
    9284           0 :     return cast<TLSModelAttr>(this)->printPretty(OS, Policy);
    9285           0 :   case attr::Target:
    9286           0 :     return cast<TargetAttr>(this)->printPretty(OS, Policy);
    9287           0 :   case attr::TestTypestate:
    9288           0 :     return cast<TestTypestateAttr>(this)->printPretty(OS, Policy);
    9289           0 :   case attr::ThisCall:
    9290           0 :     return cast<ThisCallAttr>(this)->printPretty(OS, Policy);
    9291           1 :   case attr::Thread:
    9292           1 :     return cast<ThreadAttr>(this)->printPretty(OS, Policy);
    9293           0 :   case attr::TransparentUnion:
    9294           0 :     return cast<TransparentUnionAttr>(this)->printPretty(OS, Policy);
    9295           0 :   case attr::TryAcquireCapability:
    9296           0 :     return cast<TryAcquireCapabilityAttr>(this)->printPretty(OS, Policy);
    9297           0 :   case attr::TypeTagForDatatype:
    9298           0 :     return cast<TypeTagForDatatypeAttr>(this)->printPretty(OS, Policy);
    9299           0 :   case attr::TypeVisibility:
    9300           0 :     return cast<TypeVisibilityAttr>(this)->printPretty(OS, Policy);
    9301           2 :   case attr::Unavailable:
    9302           2 :     return cast<UnavailableAttr>(this)->printPretty(OS, Policy);
    9303           0 :   case attr::Unused:
    9304           0 :     return cast<UnusedAttr>(this)->printPretty(OS, Policy);
    9305           0 :   case attr::Used:
    9306           0 :     return cast<UsedAttr>(this)->printPretty(OS, Policy);
    9307           0 :   case attr::Uuid:
    9308           0 :     return cast<UuidAttr>(this)->printPretty(OS, Policy);
    9309           0 :   case attr::VecReturn:
    9310           0 :     return cast<VecReturnAttr>(this)->printPretty(OS, Policy);
    9311           0 :   case attr::VecTypeHint:
    9312           0 :     return cast<VecTypeHintAttr>(this)->printPretty(OS, Policy);
    9313           0 :   case attr::VectorCall:
    9314           0 :     return cast<VectorCallAttr>(this)->printPretty(OS, Policy);
    9315           4 :   case attr::Visibility:
    9316           4 :     return cast<VisibilityAttr>(this)->printPretty(OS, Policy);
    9317           0 :   case attr::WarnUnused:
    9318           0 :     return cast<WarnUnusedAttr>(this)->printPretty(OS, Policy);
    9319           3 :   case attr::WarnUnusedResult:
    9320           3 :     return cast<WarnUnusedResultAttr>(this)->printPretty(OS, Policy);
    9321           0 :   case attr::Weak:
    9322           0 :     return cast<WeakAttr>(this)->printPretty(OS, Policy);
    9323           0 :   case attr::WeakImport:
    9324           0 :     return cast<WeakImportAttr>(this)->printPretty(OS, Policy);
    9325           0 :   case attr::WeakRef:
    9326           0 :     return cast<WeakRefAttr>(this)->printPretty(OS, Policy);
    9327           0 :   case attr::WorkGroupSizeHint:
    9328           0 :     return cast<WorkGroupSizeHintAttr>(this)->printPretty(OS, Policy);
    9329           0 :   case attr::X86ForceAlignArgPointer:
    9330           0 :     return cast<X86ForceAlignArgPointerAttr>(this)->printPretty(OS, Policy);
    9331           0 :   case attr::XRayInstrument:
    9332           0 :     return cast<XRayInstrumentAttr>(this)->printPretty(OS, Policy);
    9333           0 :   case attr::XRayLogArgs:
    9334           0 :     return cast<XRayLogArgsAttr>(this)->printPretty(OS, Policy);
    9335             :   }
    9336           0 :   llvm_unreachable("Unexpected attribute kind!");
    9337             : }
    9338             : 

Generated by: LCOV version 1.13