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