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: 1236 6180 20.0 %
Date: 2018-07-13 00:08:38 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           1 : const char *AMDGPUFlatWorkGroupSizeAttr::getSpelling() const {
      34           1 :   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           1 : const char *AMDGPUNumSGPRAttr::getSpelling() const {
      70           1 :   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           1 : const char *AMDGPUNumVGPRAttr::getSpelling() const {
     106           1 :   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           2 : const char *AMDGPUWavesPerEUAttr::getSpelling() const {
     142           2 :   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        1150 : AbiTagAttr *AbiTagAttr::clone(ASTContext &C) const {
     262        1150 :   auto *A = new (C) AbiTagAttr(getLocation(), C, tags_, tags_Size, getSpellingListIndex());
     263        1150 :   A->Inherited = Inherited;
     264        1150 :   A->IsPackExpansion = IsPackExpansion;
     265        1150 :   A->Implicit = Implicit;
     266        1150 :   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        5721 : bool AlignedAttr::isAlignmentDependent() const {
     569        5721 :   if (isalignmentExpr)
     570       15690 :     return alignmentExpr && (alignmentExpr->isValueDependent() || alignmentExpr->isTypeDependent());
     571             :   else
     572           0 :     return alignmentType->getType()->isDependentType();
     573             : }
     574        7886 : unsigned AlignedAttr::getAlignment(ASTContext &Ctx) const {
     575             :   assert(!isAlignmentDependent());
     576        7886 :   if (isalignmentExpr)
     577       31508 :     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          47 : const char *AlignedAttr::getSpelling() const {
     698          47 :   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          26 :   case 3:
     709          26 :     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       27749 : AlwaysInlineAttr *AlwaysInlineAttr::clone(ASTContext &C) const {
     810             :   auto *A = new (C) AlwaysInlineAttr(getLocation(), C, getSpellingListIndex());
     811       27749 :   A->Inherited = Inherited;
     812       27749 :   A->IsPackExpansion = IsPackExpansion;
     813       27749 :   A->Implicit = Implicit;
     814       27749 :   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         713 : const char *AlwaysInlineAttr::getSpelling() const {
     838         713 :   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          12 : CUDAGlobalAttr *CUDAGlobalAttr::clone(ASTContext &C) const {
    1842             :   auto *A = new (C) CUDAGlobalAttr(getLocation(), C, getSpellingListIndex());
    1843          12 :   A->Inherited = Inherited;
    1844          12 :   A->IsPackExpansion = IsPackExpansion;
    1845          12 :   A->Implicit = Implicit;
    1846          12 :   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           2 : CUDASharedAttr *CUDASharedAttr::clone(ASTContext &C) const {
    1965             :   auto *A = new (C) CUDASharedAttr(getLocation(), C, getSpellingListIndex());
    1966           2 :   A->Inherited = Inherited;
    1967           2 :   A->IsPackExpansion = IsPackExpansion;
    1968           2 :   A->Implicit = Implicit;
    1969           2 :   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           1 : ColdAttr *ColdAttr::clone(ASTContext &C) const {
    2216             :   auto *A = new (C) ColdAttr(getLocation(), C, getSpellingListIndex());
    2217           1 :   A->Inherited = Inherited;
    2218           1 :   A->IsPackExpansion = IsPackExpansion;
    2219           1 :   A->Implicit = Implicit;
    2220           1 :   return A;
    2221             : }
    2222             : 
    2223          12 : void ColdAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    2224          12 :   switch (SpellingListIndex) {
    2225           0 :   default:
    2226           0 :     llvm_unreachable("Unknown attribute spelling!");
    2227             :     break;
    2228          12 :   case 0 : {
    2229          12 :     OS << " __attribute__((cold))";
    2230          12 :     break;
    2231             :   }
    2232           0 :   case 1 : {
    2233           0 :     OS << " [[gnu::cold]]";
    2234           0 :     break;
    2235             :   }
    2236             : }
    2237          12 : }
    2238             : 
    2239           1 : const char *ColdAttr::getSpelling() const {
    2240           1 :   switch (SpellingListIndex) {
    2241           0 :   default:
    2242           0 :     llvm_unreachable("Unknown attribute spelling!");
    2243             :     return "(No spelling)";
    2244             :   case 0:
    2245             :     return "cold";
    2246             :   case 1:
    2247             :     return "cold";
    2248             :   }
    2249             : }
    2250             : 
    2251           0 : CommonAttr *CommonAttr::clone(ASTContext &C) const {
    2252             :   auto *A = new (C) CommonAttr(getLocation(), C, getSpellingListIndex());
    2253           0 :   A->Inherited = Inherited;
    2254           0 :   A->IsPackExpansion = IsPackExpansion;
    2255           0 :   A->Implicit = Implicit;
    2256           0 :   return A;
    2257             : }
    2258             : 
    2259           0 : void CommonAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    2260           0 :   switch (SpellingListIndex) {
    2261           0 :   default:
    2262           0 :     llvm_unreachable("Unknown attribute spelling!");
    2263             :     break;
    2264           0 :   case 0 : {
    2265           0 :     OS << " __attribute__((common))";
    2266           0 :     break;
    2267             :   }
    2268           0 :   case 1 : {
    2269           0 :     OS << " [[gnu::common]]";
    2270           0 :     break;
    2271             :   }
    2272             : }
    2273           0 : }
    2274             : 
    2275           5 : const char *CommonAttr::getSpelling() const {
    2276           5 :   switch (SpellingListIndex) {
    2277           0 :   default:
    2278           0 :     llvm_unreachable("Unknown attribute spelling!");
    2279             :     return "(No spelling)";
    2280             :   case 0:
    2281             :     return "common";
    2282             :   case 1:
    2283             :     return "common";
    2284             :   }
    2285             : }
    2286             : 
    2287         461 : ConstAttr *ConstAttr::clone(ASTContext &C) const {
    2288             :   auto *A = new (C) ConstAttr(getLocation(), C, getSpellingListIndex());
    2289         461 :   A->Inherited = Inherited;
    2290         461 :   A->IsPackExpansion = IsPackExpansion;
    2291         461 :   A->Implicit = Implicit;
    2292         461 :   return A;
    2293             : }
    2294             : 
    2295           6 : void ConstAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    2296           6 :   switch (SpellingListIndex) {
    2297           0 :   default:
    2298           0 :     llvm_unreachable("Unknown attribute spelling!");
    2299             :     break;
    2300           3 :   case 0 : {
    2301           3 :     OS << " __attribute__((const))";
    2302           3 :     break;
    2303             :   }
    2304           0 :   case 1 : {
    2305           0 :     OS << " [[gnu::const]]";
    2306           0 :     break;
    2307             :   }
    2308           3 :   case 2 : {
    2309           3 :     OS << " __attribute__((__const))";
    2310           3 :     break;
    2311             :   }
    2312           0 :   case 3 : {
    2313           0 :     OS << " [[gnu::__const]]";
    2314           0 :     break;
    2315             :   }
    2316             : }
    2317           6 : }
    2318             : 
    2319           0 : const char *ConstAttr::getSpelling() const {
    2320           0 :   switch (SpellingListIndex) {
    2321           0 :   default:
    2322           0 :     llvm_unreachable("Unknown attribute spelling!");
    2323             :     return "(No spelling)";
    2324             :   case 0:
    2325             :     return "const";
    2326             :   case 1:
    2327             :     return "const";
    2328           0 :   case 2:
    2329           0 :     return "__const";
    2330           0 :   case 3:
    2331           0 :     return "__const";
    2332             :   }
    2333             : }
    2334             : 
    2335          19 : ConstructorAttr *ConstructorAttr::clone(ASTContext &C) const {
    2336          19 :   auto *A = new (C) ConstructorAttr(getLocation(), C, priority, getSpellingListIndex());
    2337          19 :   A->Inherited = Inherited;
    2338          19 :   A->IsPackExpansion = IsPackExpansion;
    2339          19 :   A->Implicit = Implicit;
    2340          19 :   return A;
    2341             : }
    2342             : 
    2343           0 : void ConstructorAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    2344           0 :   switch (SpellingListIndex) {
    2345           0 :   default:
    2346           0 :     llvm_unreachable("Unknown attribute spelling!");
    2347             :     break;
    2348           0 :   case 0 : {
    2349           0 :     OS << " __attribute__((constructor(" << getPriority() << ")))";
    2350           0 :     break;
    2351             :   }
    2352           0 :   case 1 : {
    2353           0 :     OS << " [[gnu::constructor(" << getPriority() << ")]]";
    2354           0 :     break;
    2355             :   }
    2356             : }
    2357           0 : }
    2358             : 
    2359           0 : const char *ConstructorAttr::getSpelling() const {
    2360           0 :   switch (SpellingListIndex) {
    2361           0 :   default:
    2362           0 :     llvm_unreachable("Unknown attribute spelling!");
    2363             :     return "(No spelling)";
    2364             :   case 0:
    2365             :     return "constructor";
    2366             :   case 1:
    2367             :     return "constructor";
    2368             :   }
    2369             : }
    2370             : 
    2371           2 : ConsumableAttr *ConsumableAttr::clone(ASTContext &C) const {
    2372           2 :   auto *A = new (C) ConsumableAttr(getLocation(), C, defaultState, getSpellingListIndex());
    2373           2 :   A->Inherited = Inherited;
    2374           2 :   A->IsPackExpansion = IsPackExpansion;
    2375           2 :   A->Implicit = Implicit;
    2376           2 :   return A;
    2377             : }
    2378             : 
    2379           1 : void ConsumableAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    2380           1 :   switch (SpellingListIndex) {
    2381           0 :   default:
    2382           0 :     llvm_unreachable("Unknown attribute spelling!");
    2383             :     break;
    2384           1 :   case 0 : {
    2385           2 :     OS << " __attribute__((consumable(\"" << ConsumableAttr::ConvertConsumedStateToStr(getDefaultState()) << "\")))";
    2386           1 :     break;
    2387             :   }
    2388           0 :   case 1 : {
    2389           0 :     OS << " [[clang::consumable(\"" << ConsumableAttr::ConvertConsumedStateToStr(getDefaultState()) << "\")]]";
    2390           0 :     break;
    2391             :   }
    2392             : }
    2393           1 : }
    2394             : 
    2395           0 : const char *ConsumableAttr::getSpelling() const {
    2396           0 :   switch (SpellingListIndex) {
    2397           0 :   default:
    2398           0 :     llvm_unreachable("Unknown attribute spelling!");
    2399             :     return "(No spelling)";
    2400             :   case 0:
    2401             :     return "consumable";
    2402             :   case 1:
    2403             :     return "consumable";
    2404             :   }
    2405             : }
    2406             : 
    2407           0 : ConsumableAutoCastAttr *ConsumableAutoCastAttr::clone(ASTContext &C) const {
    2408             :   auto *A = new (C) ConsumableAutoCastAttr(getLocation(), C, getSpellingListIndex());
    2409           0 :   A->Inherited = Inherited;
    2410           0 :   A->IsPackExpansion = IsPackExpansion;
    2411           0 :   A->Implicit = Implicit;
    2412           0 :   return A;
    2413             : }
    2414             : 
    2415           0 : void ConsumableAutoCastAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    2416           0 :   switch (SpellingListIndex) {
    2417           0 :   default:
    2418           0 :     llvm_unreachable("Unknown attribute spelling!");
    2419             :     break;
    2420           0 :   case 0 : {
    2421           0 :     OS << " __attribute__((consumable_auto_cast_state))";
    2422           0 :     break;
    2423             :   }
    2424           0 :   case 1 : {
    2425           0 :     OS << " [[clang::consumable_auto_cast_state]]";
    2426           0 :     break;
    2427             :   }
    2428             : }
    2429           0 : }
    2430             : 
    2431           0 : const char *ConsumableAutoCastAttr::getSpelling() const {
    2432           0 :   switch (SpellingListIndex) {
    2433           0 :   default:
    2434           0 :     llvm_unreachable("Unknown attribute spelling!");
    2435             :     return "(No spelling)";
    2436             :   case 0:
    2437             :     return "consumable_auto_cast_state";
    2438             :   case 1:
    2439             :     return "consumable_auto_cast_state";
    2440             :   }
    2441             : }
    2442             : 
    2443           0 : ConsumableSetOnReadAttr *ConsumableSetOnReadAttr::clone(ASTContext &C) const {
    2444             :   auto *A = new (C) ConsumableSetOnReadAttr(getLocation(), C, getSpellingListIndex());
    2445           0 :   A->Inherited = Inherited;
    2446           0 :   A->IsPackExpansion = IsPackExpansion;
    2447           0 :   A->Implicit = Implicit;
    2448           0 :   return A;
    2449             : }
    2450             : 
    2451           0 : void ConsumableSetOnReadAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    2452           0 :   switch (SpellingListIndex) {
    2453           0 :   default:
    2454           0 :     llvm_unreachable("Unknown attribute spelling!");
    2455             :     break;
    2456           0 :   case 0 : {
    2457           0 :     OS << " __attribute__((consumable_set_state_on_read))";
    2458           0 :     break;
    2459             :   }
    2460           0 :   case 1 : {
    2461           0 :     OS << " [[clang::consumable_set_state_on_read]]";
    2462           0 :     break;
    2463             :   }
    2464             : }
    2465           0 : }
    2466             : 
    2467           0 : const char *ConsumableSetOnReadAttr::getSpelling() const {
    2468           0 :   switch (SpellingListIndex) {
    2469           0 :   default:
    2470           0 :     llvm_unreachable("Unknown attribute spelling!");
    2471             :     return "(No spelling)";
    2472             :   case 0:
    2473             :     return "consumable_set_state_on_read";
    2474             :   case 1:
    2475             :     return "consumable_set_state_on_read";
    2476             :   }
    2477             : }
    2478             : 
    2479           0 : ConvergentAttr *ConvergentAttr::clone(ASTContext &C) const {
    2480             :   auto *A = new (C) ConvergentAttr(getLocation(), C, getSpellingListIndex());
    2481           0 :   A->Inherited = Inherited;
    2482           0 :   A->IsPackExpansion = IsPackExpansion;
    2483           0 :   A->Implicit = Implicit;
    2484           0 :   return A;
    2485             : }
    2486             : 
    2487           0 : void ConvergentAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    2488           0 :   switch (SpellingListIndex) {
    2489           0 :   default:
    2490           0 :     llvm_unreachable("Unknown attribute spelling!");
    2491             :     break;
    2492           0 :   case 0 : {
    2493           0 :     OS << " __attribute__((convergent))";
    2494           0 :     break;
    2495             :   }
    2496           0 :   case 1 : {
    2497           0 :     OS << " [[clang::convergent]]";
    2498           0 :     break;
    2499             :   }
    2500           0 :   case 2 : {
    2501           0 :     OS << " [[clang::convergent]]";
    2502           0 :     break;
    2503             :   }
    2504             : }
    2505           0 : }
    2506             : 
    2507           0 : const char *ConvergentAttr::getSpelling() const {
    2508           0 :   switch (SpellingListIndex) {
    2509           0 :   default:
    2510           0 :     llvm_unreachable("Unknown attribute spelling!");
    2511             :     return "(No spelling)";
    2512             :   case 0:
    2513             :     return "convergent";
    2514             :   case 1:
    2515             :     return "convergent";
    2516             :   case 2:
    2517             :     return "convergent";
    2518             :   }
    2519             : }
    2520             : 
    2521        2566 : DLLExportAttr *DLLExportAttr::clone(ASTContext &C) const {
    2522             :   auto *A = new (C) DLLExportAttr(getLocation(), C, getSpellingListIndex());
    2523        2566 :   A->Inherited = Inherited;
    2524        2566 :   A->IsPackExpansion = IsPackExpansion;
    2525        2566 :   A->Implicit = Implicit;
    2526        2566 :   return A;
    2527             : }
    2528             : 
    2529           0 : void DLLExportAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    2530           0 :   switch (SpellingListIndex) {
    2531           0 :   default:
    2532           0 :     llvm_unreachable("Unknown attribute spelling!");
    2533             :     break;
    2534           0 :   case 0 : {
    2535           0 :     OS << " __declspec(dllexport)";
    2536           0 :     break;
    2537             :   }
    2538           0 :   case 1 : {
    2539           0 :     OS << " __attribute__((dllexport))";
    2540           0 :     break;
    2541             :   }
    2542           0 :   case 2 : {
    2543           0 :     OS << " [[gnu::dllexport]]";
    2544           0 :     break;
    2545             :   }
    2546             : }
    2547           0 : }
    2548             : 
    2549         365 : const char *DLLExportAttr::getSpelling() const {
    2550         365 :   switch (SpellingListIndex) {
    2551           0 :   default:
    2552           0 :     llvm_unreachable("Unknown attribute spelling!");
    2553             :     return "(No spelling)";
    2554             :   case 0:
    2555             :     return "dllexport";
    2556             :   case 1:
    2557             :     return "dllexport";
    2558             :   case 2:
    2559             :     return "dllexport";
    2560             :   }
    2561             : }
    2562             : 
    2563        2267 : DLLImportAttr *DLLImportAttr::clone(ASTContext &C) const {
    2564             :   auto *A = new (C) DLLImportAttr(getLocation(), C, getSpellingListIndex());
    2565        2267 :   A->Inherited = Inherited;
    2566        2267 :   A->IsPackExpansion = IsPackExpansion;
    2567        2267 :   A->Implicit = Implicit;
    2568        2267 :   return A;
    2569             : }
    2570             : 
    2571           0 : void DLLImportAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    2572           0 :   switch (SpellingListIndex) {
    2573           0 :   default:
    2574           0 :     llvm_unreachable("Unknown attribute spelling!");
    2575             :     break;
    2576           0 :   case 0 : {
    2577           0 :     OS << " __declspec(dllimport)";
    2578           0 :     break;
    2579             :   }
    2580           0 :   case 1 : {
    2581           0 :     OS << " __attribute__((dllimport))";
    2582           0 :     break;
    2583             :   }
    2584           0 :   case 2 : {
    2585           0 :     OS << " [[gnu::dllimport]]";
    2586           0 :     break;
    2587             :   }
    2588             : }
    2589           0 : }
    2590             : 
    2591         830 : const char *DLLImportAttr::getSpelling() const {
    2592         830 :   switch (SpellingListIndex) {
    2593           0 :   default:
    2594           0 :     llvm_unreachable("Unknown attribute spelling!");
    2595             :     return "(No spelling)";
    2596             :   case 0:
    2597             :     return "dllimport";
    2598             :   case 1:
    2599             :     return "dllimport";
    2600             :   case 2:
    2601             :     return "dllimport";
    2602             :   }
    2603             : }
    2604             : 
    2605         550 : DeprecatedAttr *DeprecatedAttr::clone(ASTContext &C) const {
    2606        2200 :   auto *A = new (C) DeprecatedAttr(getLocation(), C, getMessage(), getReplacement(), getSpellingListIndex());
    2607         550 :   A->Inherited = Inherited;
    2608         550 :   A->IsPackExpansion = IsPackExpansion;
    2609         550 :   A->Implicit = Implicit;
    2610         550 :   return A;
    2611             : }
    2612             : 
    2613          55 : void DeprecatedAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    2614          55 :   switch (SpellingListIndex) {
    2615           0 :   default:
    2616           0 :     llvm_unreachable("Unknown attribute spelling!");
    2617             :     break;
    2618          52 :   case 0 : {
    2619         104 :     OS << " __attribute__((deprecated(\"" << getMessage() << "\"";
    2620         105 :     if (!getReplacement().empty()) OS << ", \"" << getReplacement() << "\"";
    2621          52 :     OS << ")))";
    2622          52 :     break;
    2623             :   }
    2624           1 :   case 1 : {
    2625           2 :     OS << " [[gnu::deprecated(\"" << getMessage() << "\"";
    2626           1 :     OS << ")]]";
    2627           1 :     break;
    2628             :   }
    2629           1 :   case 2 : {
    2630           2 :     OS << " __declspec(deprecated(\"" << getMessage() << "\"";
    2631           1 :     OS << "))";
    2632           1 :     break;
    2633             :   }
    2634           1 :   case 3 : {
    2635           2 :     OS << " [[deprecated(\"" << getMessage() << "\"";
    2636           1 :     OS << ")]]";
    2637           1 :     break;
    2638             :   }
    2639           0 :   case 4 : {
    2640           0 :     OS << " [[deprecated(\"" << getMessage() << "\"";
    2641           0 :     OS << ")]]";
    2642           0 :     break;
    2643             :   }
    2644             : }
    2645          55 : }
    2646             : 
    2647           0 : const char *DeprecatedAttr::getSpelling() const {
    2648           0 :   switch (SpellingListIndex) {
    2649           0 :   default:
    2650           0 :     llvm_unreachable("Unknown attribute spelling!");
    2651             :     return "(No spelling)";
    2652             :   case 0:
    2653             :     return "deprecated";
    2654             :   case 1:
    2655             :     return "deprecated";
    2656             :   case 2:
    2657             :     return "deprecated";
    2658             :   case 3:
    2659             :     return "deprecated";
    2660             :   case 4:
    2661             :     return "deprecated";
    2662             :   }
    2663             : }
    2664             : 
    2665          11 : DestructorAttr *DestructorAttr::clone(ASTContext &C) const {
    2666          11 :   auto *A = new (C) DestructorAttr(getLocation(), C, priority, getSpellingListIndex());
    2667          11 :   A->Inherited = Inherited;
    2668          11 :   A->IsPackExpansion = IsPackExpansion;
    2669          11 :   A->Implicit = Implicit;
    2670          11 :   return A;
    2671             : }
    2672             : 
    2673           0 : void DestructorAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    2674           0 :   switch (SpellingListIndex) {
    2675           0 :   default:
    2676           0 :     llvm_unreachable("Unknown attribute spelling!");
    2677             :     break;
    2678           0 :   case 0 : {
    2679           0 :     OS << " __attribute__((destructor(" << getPriority() << ")))";
    2680           0 :     break;
    2681             :   }
    2682           0 :   case 1 : {
    2683           0 :     OS << " [[gnu::destructor(" << getPriority() << ")]]";
    2684           0 :     break;
    2685             :   }
    2686             : }
    2687           0 : }
    2688             : 
    2689           0 : const char *DestructorAttr::getSpelling() const {
    2690           0 :   switch (SpellingListIndex) {
    2691           0 :   default:
    2692           0 :     llvm_unreachable("Unknown attribute spelling!");
    2693             :     return "(No spelling)";
    2694             :   case 0:
    2695             :     return "destructor";
    2696             :   case 1:
    2697             :     return "destructor";
    2698             :   }
    2699             : }
    2700             : 
    2701           4 : DiagnoseIfAttr *DiagnoseIfAttr::clone(ASTContext &C) const {
    2702          12 :   auto *A = new (C) DiagnoseIfAttr(getLocation(), C, cond, getMessage(), diagnosticType, argDependent, parent, getSpellingListIndex());
    2703           4 :   A->Inherited = Inherited;
    2704           4 :   A->IsPackExpansion = IsPackExpansion;
    2705           4 :   A->Implicit = Implicit;
    2706           4 :   return A;
    2707             : }
    2708             : 
    2709           0 : void DiagnoseIfAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    2710           0 :   switch (SpellingListIndex) {
    2711           0 :   default:
    2712           0 :     llvm_unreachable("Unknown attribute spelling!");
    2713             :     break;
    2714           0 :   case 0 : {
    2715           0 :     OS << " __attribute__((diagnose_if(" << getCond() << ", \"" << getMessage() << "\", \"" << DiagnoseIfAttr::ConvertDiagnosticTypeToStr(getDiagnosticType()) << "\")))";
    2716             :     break;
    2717             :   }
    2718             : }
    2719           0 : }
    2720             : 
    2721           0 : const char *DiagnoseIfAttr::getSpelling() const {
    2722           0 :   switch (SpellingListIndex) {
    2723           0 :   default:
    2724           0 :     llvm_unreachable("Unknown attribute spelling!");
    2725             :     return "(No spelling)";
    2726           0 :   case 0:
    2727             :     return "diagnose_if";
    2728             :   }
    2729             : }
    2730             : 
    2731           0 : DisableTailCallsAttr *DisableTailCallsAttr::clone(ASTContext &C) const {
    2732             :   auto *A = new (C) DisableTailCallsAttr(getLocation(), C, getSpellingListIndex());
    2733           0 :   A->Inherited = Inherited;
    2734           0 :   A->IsPackExpansion = IsPackExpansion;
    2735           0 :   A->Implicit = Implicit;
    2736           0 :   return A;
    2737             : }
    2738             : 
    2739           0 : void DisableTailCallsAttr::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__((disable_tail_calls))";
    2746           0 :     break;
    2747             :   }
    2748           0 :   case 1 : {
    2749           0 :     OS << " [[clang::disable_tail_calls]]";
    2750           0 :     break;
    2751             :   }
    2752           0 :   case 2 : {
    2753           0 :     OS << " [[clang::disable_tail_calls]]";
    2754           0 :     break;
    2755             :   }
    2756             : }
    2757           0 : }
    2758             : 
    2759           1 : const char *DisableTailCallsAttr::getSpelling() const {
    2760           1 :   switch (SpellingListIndex) {
    2761           0 :   default:
    2762           0 :     llvm_unreachable("Unknown attribute spelling!");
    2763             :     return "(No spelling)";
    2764             :   case 0:
    2765             :     return "disable_tail_calls";
    2766             :   case 1:
    2767             :     return "disable_tail_calls";
    2768             :   case 2:
    2769             :     return "disable_tail_calls";
    2770             :   }
    2771             : }
    2772             : 
    2773           0 : EmptyBasesAttr *EmptyBasesAttr::clone(ASTContext &C) const {
    2774             :   auto *A = new (C) EmptyBasesAttr(getLocation(), C, getSpellingListIndex());
    2775           0 :   A->Inherited = Inherited;
    2776           0 :   A->IsPackExpansion = IsPackExpansion;
    2777           0 :   A->Implicit = Implicit;
    2778           0 :   return A;
    2779             : }
    2780             : 
    2781           0 : void EmptyBasesAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    2782           0 :   switch (SpellingListIndex) {
    2783           0 :   default:
    2784           0 :     llvm_unreachable("Unknown attribute spelling!");
    2785             :     break;
    2786           0 :   case 0 : {
    2787           0 :     OS << " __declspec(empty_bases)";
    2788             :     break;
    2789             :   }
    2790             : }
    2791           0 : }
    2792             : 
    2793           0 : const char *EmptyBasesAttr::getSpelling() const {
    2794           0 :   switch (SpellingListIndex) {
    2795           0 :   default:
    2796           0 :     llvm_unreachable("Unknown attribute spelling!");
    2797             :     return "(No spelling)";
    2798           0 :   case 0:
    2799             :     return "empty_bases";
    2800             :   }
    2801             : }
    2802             : 
    2803           0 : EnableIfAttr *EnableIfAttr::clone(ASTContext &C) const {
    2804           0 :   auto *A = new (C) EnableIfAttr(getLocation(), C, cond, getMessage(), 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 EnableIfAttr::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 << " __attribute__((enable_if(" << getCond() << ", \"" << getMessage() << "\")))";
    2818             :     break;
    2819             :   }
    2820             : }
    2821           0 : }
    2822             : 
    2823           0 : const char *EnableIfAttr::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 "enable_if";
    2830             :   }
    2831             : }
    2832             : 
    2833           2 : EnumExtensibilityAttr *EnumExtensibilityAttr::clone(ASTContext &C) const {
    2834           2 :   auto *A = new (C) EnumExtensibilityAttr(getLocation(), C, extensibility, getSpellingListIndex());
    2835           2 :   A->Inherited = Inherited;
    2836           2 :   A->IsPackExpansion = IsPackExpansion;
    2837           2 :   A->Implicit = Implicit;
    2838           2 :   return A;
    2839             : }
    2840             : 
    2841           0 : void EnumExtensibilityAttr::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__((enum_extensibility(\"" << EnumExtensibilityAttr::ConvertKindToStr(getExtensibility()) << "\")))";
    2848           0 :     break;
    2849             :   }
    2850           0 :   case 1 : {
    2851           0 :     OS << " [[clang::enum_extensibility(\"" << EnumExtensibilityAttr::ConvertKindToStr(getExtensibility()) << "\")]]";
    2852           0 :     break;
    2853             :   }
    2854           0 :   case 2 : {
    2855           0 :     OS << " [[clang::enum_extensibility(\"" << EnumExtensibilityAttr::ConvertKindToStr(getExtensibility()) << "\")]]";
    2856           0 :     break;
    2857             :   }
    2858             : }
    2859           0 : }
    2860             : 
    2861           0 : const char *EnumExtensibilityAttr::getSpelling() const {
    2862           0 :   switch (SpellingListIndex) {
    2863           0 :   default:
    2864           0 :     llvm_unreachable("Unknown attribute spelling!");
    2865             :     return "(No spelling)";
    2866             :   case 0:
    2867             :     return "enum_extensibility";
    2868             :   case 1:
    2869             :     return "enum_extensibility";
    2870             :   case 2:
    2871             :     return "enum_extensibility";
    2872             :   }
    2873             : }
    2874             : 
    2875          12 : ExclusiveTrylockFunctionAttr *ExclusiveTrylockFunctionAttr::clone(ASTContext &C) const {
    2876          12 :   auto *A = new (C) ExclusiveTrylockFunctionAttr(getLocation(), C, successValue, args_, args_Size, getSpellingListIndex());
    2877          12 :   A->Inherited = Inherited;
    2878          12 :   A->IsPackExpansion = IsPackExpansion;
    2879          12 :   A->Implicit = Implicit;
    2880          12 :   return A;
    2881             : }
    2882             : 
    2883           0 : void ExclusiveTrylockFunctionAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    2884           0 :   switch (SpellingListIndex) {
    2885           0 :   default:
    2886           0 :     llvm_unreachable("Unknown attribute spelling!");
    2887             :     break;
    2888           0 :   case 0 : {
    2889           0 :     OS << " __attribute__((exclusive_trylock_function(" << getSuccessValue() << ", ";
    2890             :   bool isFirst = true;
    2891           0 :   for (const auto &Val : args()) {
    2892           0 :     if (isFirst) isFirst = false;
    2893           0 :     else OS << ", ";
    2894           0 :     OS << Val;
    2895             :   }
    2896           0 :   OS << ")))";
    2897             :     break;
    2898             :   }
    2899             : }
    2900           0 : }
    2901             : 
    2902           0 : const char *ExclusiveTrylockFunctionAttr::getSpelling() const {
    2903           0 :   switch (SpellingListIndex) {
    2904           0 :   default:
    2905           0 :     llvm_unreachable("Unknown attribute spelling!");
    2906             :     return "(No spelling)";
    2907           0 :   case 0:
    2908             :     return "exclusive_trylock_function";
    2909             :   }
    2910             : }
    2911             : 
    2912           0 : ExternalSourceSymbolAttr *ExternalSourceSymbolAttr::clone(ASTContext &C) const {
    2913           0 :   auto *A = new (C) ExternalSourceSymbolAttr(getLocation(), C, getLanguage(), getDefinedIn(), generatedDeclaration, getSpellingListIndex());
    2914           0 :   A->Inherited = Inherited;
    2915           0 :   A->IsPackExpansion = IsPackExpansion;
    2916           0 :   A->Implicit = Implicit;
    2917           0 :   return A;
    2918             : }
    2919             : 
    2920           0 : void ExternalSourceSymbolAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    2921           0 :   switch (SpellingListIndex) {
    2922           0 :   default:
    2923           0 :     llvm_unreachable("Unknown attribute spelling!");
    2924             :     break;
    2925           0 :   case 0 : {
    2926           0 :     OS << " __attribute__((external_source_symbol(\"" << getLanguage() << "\", \"" << getDefinedIn() << "\", " << getGeneratedDeclaration() << ")))";
    2927           0 :     break;
    2928             :   }
    2929           0 :   case 1 : {
    2930           0 :     OS << " [[clang::external_source_symbol(\"" << getLanguage() << "\", \"" << getDefinedIn() << "\", " << getGeneratedDeclaration() << ")]]";
    2931           0 :     break;
    2932             :   }
    2933           0 :   case 2 : {
    2934           0 :     OS << " [[clang::external_source_symbol(\"" << getLanguage() << "\", \"" << getDefinedIn() << "\", " << getGeneratedDeclaration() << ")]]";
    2935           0 :     break;
    2936             :   }
    2937             : }
    2938           0 : }
    2939             : 
    2940           0 : const char *ExternalSourceSymbolAttr::getSpelling() const {
    2941           0 :   switch (SpellingListIndex) {
    2942           0 :   default:
    2943           0 :     llvm_unreachable("Unknown attribute spelling!");
    2944             :     return "(No spelling)";
    2945             :   case 0:
    2946             :     return "external_source_symbol";
    2947             :   case 1:
    2948             :     return "external_source_symbol";
    2949             :   case 2:
    2950             :     return "external_source_symbol";
    2951             :   }
    2952             : }
    2953             : 
    2954           0 : FallThroughAttr *FallThroughAttr::clone(ASTContext &C) const {
    2955             :   auto *A = new (C) FallThroughAttr(getLocation(), C, getSpellingListIndex());
    2956           0 :   A->Inherited = Inherited;
    2957           0 :   A->IsPackExpansion = IsPackExpansion;
    2958           0 :   A->Implicit = Implicit;
    2959           0 :   return A;
    2960             : }
    2961             : 
    2962           3 : void FallThroughAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    2963           3 :   switch (SpellingListIndex) {
    2964           0 :   default:
    2965           0 :     llvm_unreachable("Unknown attribute spelling!");
    2966             :     break;
    2967           0 :   case 0 : {
    2968           0 :     OS << " [[fallthrough]]";
    2969           0 :     break;
    2970             :   }
    2971           0 :   case 1 : {
    2972           0 :     OS << " [[fallthrough]]";
    2973           0 :     break;
    2974             :   }
    2975           3 :   case 2 : {
    2976           3 :     OS << " [[clang::fallthrough]]";
    2977           3 :     break;
    2978             :   }
    2979             : }
    2980           3 : }
    2981             : 
    2982           6 : const char *FallThroughAttr::getSpelling() const {
    2983           6 :   switch (SpellingListIndex) {
    2984           0 :   default:
    2985           0 :     llvm_unreachable("Unknown attribute spelling!");
    2986             :     return "(No spelling)";
    2987             :   case 0:
    2988             :     return "fallthrough";
    2989             :   case 1:
    2990             :     return "fallthrough";
    2991             :   case 2:
    2992             :     return "fallthrough";
    2993             :   }
    2994             : }
    2995             : 
    2996           0 : FastCallAttr *FastCallAttr::clone(ASTContext &C) const {
    2997             :   auto *A = new (C) FastCallAttr(getLocation(), C, getSpellingListIndex());
    2998           0 :   A->Inherited = Inherited;
    2999           0 :   A->IsPackExpansion = IsPackExpansion;
    3000           0 :   A->Implicit = Implicit;
    3001           0 :   return A;
    3002             : }
    3003             : 
    3004           0 : void FastCallAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    3005           0 :   switch (SpellingListIndex) {
    3006           0 :   default:
    3007           0 :     llvm_unreachable("Unknown attribute spelling!");
    3008             :     break;
    3009           0 :   case 0 : {
    3010           0 :     OS << " __attribute__((fastcall))";
    3011           0 :     break;
    3012             :   }
    3013           0 :   case 1 : {
    3014           0 :     OS << " [[gnu::fastcall]]";
    3015           0 :     break;
    3016             :   }
    3017           0 :   case 2 : {
    3018           0 :     OS << " __fastcall";
    3019           0 :     break;
    3020             :   }
    3021           0 :   case 3 : {
    3022           0 :     OS << " _fastcall";
    3023           0 :     break;
    3024             :   }
    3025             : }
    3026           0 : }
    3027             : 
    3028           0 : const char *FastCallAttr::getSpelling() const {
    3029           0 :   switch (SpellingListIndex) {
    3030           0 :   default:
    3031           0 :     llvm_unreachable("Unknown attribute spelling!");
    3032             :     return "(No spelling)";
    3033             :   case 0:
    3034             :     return "fastcall";
    3035             :   case 1:
    3036             :     return "fastcall";
    3037           0 :   case 2:
    3038           0 :     return "__fastcall";
    3039           0 :   case 3:
    3040           0 :     return "_fastcall";
    3041             :   }
    3042             : }
    3043             : 
    3044         726 : FinalAttr *FinalAttr::clone(ASTContext &C) const {
    3045             :   auto *A = new (C) FinalAttr(getLocation(), C, getSpellingListIndex());
    3046         726 :   A->Inherited = Inherited;
    3047         726 :   A->IsPackExpansion = IsPackExpansion;
    3048         726 :   A->Implicit = Implicit;
    3049         726 :   return A;
    3050             : }
    3051             : 
    3052           0 : void FinalAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    3053           0 :   switch (SpellingListIndex) {
    3054           0 :   default:
    3055           0 :     llvm_unreachable("Unknown attribute spelling!");
    3056             :     break;
    3057           0 :   case 0 : {
    3058           0 :     OS << " final";
    3059           0 :     break;
    3060             :   }
    3061           0 :   case 1 : {
    3062           0 :     OS << " sealed";
    3063           0 :     break;
    3064             :   }
    3065             : }
    3066           0 : }
    3067             : 
    3068           0 : const char *FinalAttr::getSpelling() const {
    3069           0 :   switch (SpellingListIndex) {
    3070           0 :   default:
    3071           0 :     llvm_unreachable("Unknown attribute spelling!");
    3072             :     return "(No spelling)";
    3073             :   case 0:
    3074             :     return "final";
    3075           0 :   case 1:
    3076           0 :     return "sealed";
    3077             :   }
    3078             : }
    3079             : 
    3080           2 : FlagEnumAttr *FlagEnumAttr::clone(ASTContext &C) const {
    3081             :   auto *A = new (C) FlagEnumAttr(getLocation(), C, getSpellingListIndex());
    3082           2 :   A->Inherited = Inherited;
    3083           2 :   A->IsPackExpansion = IsPackExpansion;
    3084           2 :   A->Implicit = Implicit;
    3085           2 :   return A;
    3086             : }
    3087             : 
    3088           0 : void FlagEnumAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    3089           0 :   switch (SpellingListIndex) {
    3090           0 :   default:
    3091           0 :     llvm_unreachable("Unknown attribute spelling!");
    3092             :     break;
    3093           0 :   case 0 : {
    3094           0 :     OS << " __attribute__((flag_enum))";
    3095           0 :     break;
    3096             :   }
    3097           0 :   case 1 : {
    3098           0 :     OS << " [[clang::flag_enum]]";
    3099           0 :     break;
    3100             :   }
    3101           0 :   case 2 : {
    3102           0 :     OS << " [[clang::flag_enum]]";
    3103           0 :     break;
    3104             :   }
    3105             : }
    3106           0 : }
    3107             : 
    3108           0 : const char *FlagEnumAttr::getSpelling() const {
    3109           0 :   switch (SpellingListIndex) {
    3110           0 :   default:
    3111           0 :     llvm_unreachable("Unknown attribute spelling!");
    3112             :     return "(No spelling)";
    3113             :   case 0:
    3114             :     return "flag_enum";
    3115             :   case 1:
    3116             :     return "flag_enum";
    3117             :   case 2:
    3118             :     return "flag_enum";
    3119             :   }
    3120             : }
    3121             : 
    3122           0 : FlattenAttr *FlattenAttr::clone(ASTContext &C) const {
    3123             :   auto *A = new (C) FlattenAttr(getLocation(), C, getSpellingListIndex());
    3124           0 :   A->Inherited = Inherited;
    3125           0 :   A->IsPackExpansion = IsPackExpansion;
    3126           0 :   A->Implicit = Implicit;
    3127           0 :   return A;
    3128             : }
    3129             : 
    3130           0 : void FlattenAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    3131           0 :   switch (SpellingListIndex) {
    3132           0 :   default:
    3133           0 :     llvm_unreachable("Unknown attribute spelling!");
    3134             :     break;
    3135           0 :   case 0 : {
    3136           0 :     OS << " __attribute__((flatten))";
    3137           0 :     break;
    3138             :   }
    3139           0 :   case 1 : {
    3140           0 :     OS << " [[gnu::flatten]]";
    3141           0 :     break;
    3142             :   }
    3143             : }
    3144           0 : }
    3145             : 
    3146           0 : const char *FlattenAttr::getSpelling() const {
    3147           0 :   switch (SpellingListIndex) {
    3148           0 :   default:
    3149           0 :     llvm_unreachable("Unknown attribute spelling!");
    3150             :     return "(No spelling)";
    3151             :   case 0:
    3152             :     return "flatten";
    3153             :   case 1:
    3154             :     return "flatten";
    3155             :   }
    3156             : }
    3157             : 
    3158           3 : FormatAttr *FormatAttr::clone(ASTContext &C) const {
    3159           3 :   auto *A = new (C) FormatAttr(getLocation(), C, type, formatIdx, firstArg, getSpellingListIndex());
    3160           3 :   A->Inherited = Inherited;
    3161           3 :   A->IsPackExpansion = IsPackExpansion;
    3162           3 :   A->Implicit = Implicit;
    3163           3 :   return A;
    3164             : }
    3165             : 
    3166           5 : void FormatAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    3167           5 :   switch (SpellingListIndex) {
    3168           0 :   default:
    3169           0 :     llvm_unreachable("Unknown attribute spelling!");
    3170             :     break;
    3171           5 :   case 0 : {
    3172          15 :     OS << " __attribute__((format(" << (getType() ? getType()->getName() : "") << ", " << getFormatIdx() << ", " << getFirstArg() << ")))";
    3173           5 :     break;
    3174             :   }
    3175           0 :   case 1 : {
    3176           0 :     OS << " [[gnu::format(" << (getType() ? getType()->getName() : "") << ", " << getFormatIdx() << ", " << getFirstArg() << ")]]";
    3177           0 :     break;
    3178             :   }
    3179             : }
    3180           5 : }
    3181             : 
    3182           0 : const char *FormatAttr::getSpelling() const {
    3183           0 :   switch (SpellingListIndex) {
    3184           0 :   default:
    3185           0 :     llvm_unreachable("Unknown attribute spelling!");
    3186             :     return "(No spelling)";
    3187             :   case 0:
    3188             :     return "format";
    3189             :   case 1:
    3190             :     return "format";
    3191             :   }
    3192             : }
    3193             : 
    3194           0 : FormatArgAttr *FormatArgAttr::clone(ASTContext &C) const {
    3195           0 :   auto *A = new (C) FormatArgAttr(getLocation(), C, formatIdx, getSpellingListIndex());
    3196           0 :   A->Inherited = Inherited;
    3197           0 :   A->IsPackExpansion = IsPackExpansion;
    3198           0 :   A->Implicit = Implicit;
    3199           0 :   return A;
    3200             : }
    3201             : 
    3202           4 : void FormatArgAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    3203           4 :   switch (SpellingListIndex) {
    3204           0 :   default:
    3205           0 :     llvm_unreachable("Unknown attribute spelling!");
    3206             :     break;
    3207           4 :   case 0 : {
    3208          12 :     OS << " __attribute__((format_arg(" << getFormatIdx().getSourceIndex() << ")))";
    3209           4 :     break;
    3210             :   }
    3211           0 :   case 1 : {
    3212           0 :     OS << " [[gnu::format_arg(" << getFormatIdx().getSourceIndex() << ")]]";
    3213           0 :     break;
    3214             :   }
    3215             : }
    3216           4 : }
    3217             : 
    3218           0 : const char *FormatArgAttr::getSpelling() const {
    3219           0 :   switch (SpellingListIndex) {
    3220           0 :   default:
    3221           0 :     llvm_unreachable("Unknown attribute spelling!");
    3222             :     return "(No spelling)";
    3223             :   case 0:
    3224             :     return "format_arg";
    3225             :   case 1:
    3226             :     return "format_arg";
    3227             :   }
    3228             : }
    3229             : 
    3230           3 : GNUInlineAttr *GNUInlineAttr::clone(ASTContext &C) const {
    3231             :   auto *A = new (C) GNUInlineAttr(getLocation(), C, getSpellingListIndex());
    3232           3 :   A->Inherited = Inherited;
    3233           3 :   A->IsPackExpansion = IsPackExpansion;
    3234           3 :   A->Implicit = Implicit;
    3235           3 :   return A;
    3236             : }
    3237             : 
    3238           2 : void GNUInlineAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    3239           2 :   switch (SpellingListIndex) {
    3240           0 :   default:
    3241           0 :     llvm_unreachable("Unknown attribute spelling!");
    3242             :     break;
    3243           1 :   case 0 : {
    3244           1 :     OS << " __attribute__((gnu_inline))";
    3245           1 :     break;
    3246             :   }
    3247           1 :   case 1 : {
    3248           1 :     OS << " [[gnu::gnu_inline]]";
    3249           1 :     break;
    3250             :   }
    3251             : }
    3252           2 : }
    3253             : 
    3254           0 : const char *GNUInlineAttr::getSpelling() const {
    3255           0 :   switch (SpellingListIndex) {
    3256           0 :   default:
    3257           0 :     llvm_unreachable("Unknown attribute spelling!");
    3258             :     return "(No spelling)";
    3259             :   case 0:
    3260             :     return "gnu_inline";
    3261             :   case 1:
    3262             :     return "gnu_inline";
    3263             :   }
    3264             : }
    3265             : 
    3266           0 : GuardedByAttr *GuardedByAttr::clone(ASTContext &C) const {
    3267           0 :   auto *A = new (C) GuardedByAttr(getLocation(), C, arg, getSpellingListIndex());
    3268           0 :   A->Inherited = Inherited;
    3269           0 :   A->IsPackExpansion = IsPackExpansion;
    3270           0 :   A->Implicit = Implicit;
    3271           0 :   return A;
    3272             : }
    3273             : 
    3274           0 : void GuardedByAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    3275           0 :   switch (SpellingListIndex) {
    3276           0 :   default:
    3277           0 :     llvm_unreachable("Unknown attribute spelling!");
    3278             :     break;
    3279           0 :   case 0 : {
    3280           0 :     OS << " __attribute__((guarded_by(" << getArg() << ")))";
    3281             :     break;
    3282             :   }
    3283             : }
    3284           0 : }
    3285             : 
    3286           0 : const char *GuardedByAttr::getSpelling() const {
    3287           0 :   switch (SpellingListIndex) {
    3288           0 :   default:
    3289           0 :     llvm_unreachable("Unknown attribute spelling!");
    3290             :     return "(No spelling)";
    3291           0 :   case 0:
    3292             :     return "guarded_by";
    3293             :   }
    3294             : }
    3295             : 
    3296           0 : GuardedVarAttr *GuardedVarAttr::clone(ASTContext &C) const {
    3297             :   auto *A = new (C) GuardedVarAttr(getLocation(), C, 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 GuardedVarAttr::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_var))";
    3311           0 :     break;
    3312             :   }
    3313           0 :   case 1 : {
    3314           0 :     OS << " [[clang::guarded_var]]";
    3315           0 :     break;
    3316             :   }
    3317             : }
    3318           0 : }
    3319             : 
    3320           0 : const char *GuardedVarAttr::getSpelling() const {
    3321           0 :   switch (SpellingListIndex) {
    3322           0 :   default:
    3323           0 :     llvm_unreachable("Unknown attribute spelling!");
    3324             :     return "(No spelling)";
    3325             :   case 0:
    3326             :     return "guarded_var";
    3327             :   case 1:
    3328             :     return "guarded_var";
    3329             :   }
    3330             : }
    3331             : 
    3332           0 : HotAttr *HotAttr::clone(ASTContext &C) const {
    3333             :   auto *A = new (C) HotAttr(getLocation(), C, getSpellingListIndex());
    3334           0 :   A->Inherited = Inherited;
    3335           0 :   A->IsPackExpansion = IsPackExpansion;
    3336           0 :   A->Implicit = Implicit;
    3337           0 :   return A;
    3338             : }
    3339             : 
    3340           0 : void HotAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    3341           0 :   switch (SpellingListIndex) {
    3342           0 :   default:
    3343           0 :     llvm_unreachable("Unknown attribute spelling!");
    3344             :     break;
    3345           0 :   case 0 : {
    3346           0 :     OS << " __attribute__((hot))";
    3347           0 :     break;
    3348             :   }
    3349           0 :   case 1 : {
    3350           0 :     OS << " [[gnu::hot]]";
    3351           0 :     break;
    3352             :   }
    3353             : }
    3354           0 : }
    3355             : 
    3356           1 : const char *HotAttr::getSpelling() const {
    3357           1 :   switch (SpellingListIndex) {
    3358           0 :   default:
    3359           0 :     llvm_unreachable("Unknown attribute spelling!");
    3360             :     return "(No spelling)";
    3361             :   case 0:
    3362             :     return "hot";
    3363             :   case 1:
    3364             :     return "hot";
    3365             :   }
    3366             : }
    3367             : 
    3368           0 : IBActionAttr *IBActionAttr::clone(ASTContext &C) const {
    3369             :   auto *A = new (C) IBActionAttr(getLocation(), C, getSpellingListIndex());
    3370           0 :   A->Inherited = Inherited;
    3371           0 :   A->IsPackExpansion = IsPackExpansion;
    3372           0 :   A->Implicit = Implicit;
    3373           0 :   return A;
    3374             : }
    3375             : 
    3376           0 : void IBActionAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    3377           0 :   switch (SpellingListIndex) {
    3378           0 :   default:
    3379           0 :     llvm_unreachable("Unknown attribute spelling!");
    3380             :     break;
    3381           0 :   case 0 : {
    3382           0 :     OS << " __attribute__((ibaction))";
    3383           0 :     break;
    3384             :   }
    3385           0 :   case 1 : {
    3386           0 :     OS << " [[clang::ibaction]]";
    3387           0 :     break;
    3388             :   }
    3389           0 :   case 2 : {
    3390           0 :     OS << " [[clang::ibaction]]";
    3391           0 :     break;
    3392             :   }
    3393             : }
    3394           0 : }
    3395             : 
    3396           0 : const char *IBActionAttr::getSpelling() const {
    3397           0 :   switch (SpellingListIndex) {
    3398           0 :   default:
    3399           0 :     llvm_unreachable("Unknown attribute spelling!");
    3400             :     return "(No spelling)";
    3401             :   case 0:
    3402             :     return "ibaction";
    3403             :   case 1:
    3404             :     return "ibaction";
    3405             :   case 2:
    3406             :     return "ibaction";
    3407             :   }
    3408             : }
    3409             : 
    3410           0 : IBOutletAttr *IBOutletAttr::clone(ASTContext &C) const {
    3411             :   auto *A = new (C) IBOutletAttr(getLocation(), C, getSpellingListIndex());
    3412           0 :   A->Inherited = Inherited;
    3413           0 :   A->IsPackExpansion = IsPackExpansion;
    3414           0 :   A->Implicit = Implicit;
    3415           0 :   return A;
    3416             : }
    3417             : 
    3418           0 : void IBOutletAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    3419           0 :   switch (SpellingListIndex) {
    3420           0 :   default:
    3421           0 :     llvm_unreachable("Unknown attribute spelling!");
    3422             :     break;
    3423           0 :   case 0 : {
    3424           0 :     OS << " __attribute__((iboutlet))";
    3425           0 :     break;
    3426             :   }
    3427           0 :   case 1 : {
    3428           0 :     OS << " [[clang::iboutlet]]";
    3429           0 :     break;
    3430             :   }
    3431           0 :   case 2 : {
    3432           0 :     OS << " [[clang::iboutlet]]";
    3433           0 :     break;
    3434             :   }
    3435             : }
    3436           0 : }
    3437             : 
    3438           0 : const char *IBOutletAttr::getSpelling() const {
    3439           0 :   switch (SpellingListIndex) {
    3440           0 :   default:
    3441           0 :     llvm_unreachable("Unknown attribute spelling!");
    3442             :     return "(No spelling)";
    3443             :   case 0:
    3444             :     return "iboutlet";
    3445             :   case 1:
    3446             :     return "iboutlet";
    3447             :   case 2:
    3448             :     return "iboutlet";
    3449             :   }
    3450             : }
    3451             : 
    3452           0 : IBOutletCollectionAttr *IBOutletCollectionAttr::clone(ASTContext &C) const {
    3453           0 :   auto *A = new (C) IBOutletCollectionAttr(getLocation(), C, interface_, getSpellingListIndex());
    3454           0 :   A->Inherited = Inherited;
    3455           0 :   A->IsPackExpansion = IsPackExpansion;
    3456           0 :   A->Implicit = Implicit;
    3457           0 :   return A;
    3458             : }
    3459             : 
    3460           0 : void IBOutletCollectionAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    3461           0 :   switch (SpellingListIndex) {
    3462           0 :   default:
    3463           0 :     llvm_unreachable("Unknown attribute spelling!");
    3464             :     break;
    3465           0 :   case 0 : {
    3466           0 :     OS << " __attribute__((iboutletcollection(" << getInterface().getAsString() << ")))";
    3467           0 :     break;
    3468             :   }
    3469           0 :   case 1 : {
    3470           0 :     OS << " [[clang::iboutletcollection(" << getInterface().getAsString() << ")]]";
    3471           0 :     break;
    3472             :   }
    3473           0 :   case 2 : {
    3474           0 :     OS << " [[clang::iboutletcollection(" << getInterface().getAsString() << ")]]";
    3475           0 :     break;
    3476             :   }
    3477             : }
    3478           0 : }
    3479             : 
    3480           0 : const char *IBOutletCollectionAttr::getSpelling() const {
    3481           0 :   switch (SpellingListIndex) {
    3482           0 :   default:
    3483           0 :     llvm_unreachable("Unknown attribute spelling!");
    3484             :     return "(No spelling)";
    3485             :   case 0:
    3486             :     return "iboutletcollection";
    3487             :   case 1:
    3488             :     return "iboutletcollection";
    3489             :   case 2:
    3490             :     return "iboutletcollection";
    3491             :   }
    3492             : }
    3493             : 
    3494           0 : IFuncAttr *IFuncAttr::clone(ASTContext &C) const {
    3495           0 :   auto *A = new (C) IFuncAttr(getLocation(), C, getResolver(), getSpellingListIndex());
    3496           0 :   A->Inherited = Inherited;
    3497           0 :   A->IsPackExpansion = IsPackExpansion;
    3498           0 :   A->Implicit = Implicit;
    3499           0 :   return A;
    3500             : }
    3501             : 
    3502           0 : void IFuncAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    3503           0 :   switch (SpellingListIndex) {
    3504           0 :   default:
    3505           0 :     llvm_unreachable("Unknown attribute spelling!");
    3506             :     break;
    3507           0 :   case 0 : {
    3508           0 :     OS << " __attribute__((ifunc(\"" << getResolver() << "\")))";
    3509           0 :     break;
    3510             :   }
    3511           0 :   case 1 : {
    3512           0 :     OS << " [[gnu::ifunc(\"" << getResolver() << "\")]]";
    3513           0 :     break;
    3514             :   }
    3515             : }
    3516           0 : }
    3517             : 
    3518           0 : const char *IFuncAttr::getSpelling() const {
    3519           0 :   switch (SpellingListIndex) {
    3520           0 :   default:
    3521           0 :     llvm_unreachable("Unknown attribute spelling!");
    3522             :     return "(No spelling)";
    3523             :   case 0:
    3524             :     return "ifunc";
    3525             :   case 1:
    3526             :     return "ifunc";
    3527             :   }
    3528             : }
    3529             : 
    3530           0 : InitPriorityAttr *InitPriorityAttr::clone(ASTContext &C) const {
    3531           0 :   auto *A = new (C) InitPriorityAttr(getLocation(), C, priority, getSpellingListIndex());
    3532           0 :   A->Inherited = Inherited;
    3533           0 :   A->IsPackExpansion = IsPackExpansion;
    3534           0 :   A->Implicit = Implicit;
    3535           0 :   return A;
    3536             : }
    3537             : 
    3538           0 : void InitPriorityAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    3539           0 :   switch (SpellingListIndex) {
    3540           0 :   default:
    3541           0 :     llvm_unreachable("Unknown attribute spelling!");
    3542             :     break;
    3543           0 :   case 0 : {
    3544           0 :     OS << " __attribute__((init_priority(" << getPriority() << ")))";
    3545           0 :     break;
    3546             :   }
    3547           0 :   case 1 : {
    3548           0 :     OS << " [[gnu::init_priority(" << getPriority() << ")]]";
    3549           0 :     break;
    3550             :   }
    3551             : }
    3552           0 : }
    3553             : 
    3554           0 : const char *InitPriorityAttr::getSpelling() const {
    3555           0 :   switch (SpellingListIndex) {
    3556           0 :   default:
    3557           0 :     llvm_unreachable("Unknown attribute spelling!");
    3558             :     return "(No spelling)";
    3559             :   case 0:
    3560             :     return "init_priority";
    3561             :   case 1:
    3562             :     return "init_priority";
    3563             :   }
    3564             : }
    3565             : 
    3566           2 : InitSegAttr *InitSegAttr::clone(ASTContext &C) const {
    3567           6 :   auto *A = new (C) InitSegAttr(getLocation(), C, getSection(), getSpellingListIndex());
    3568           2 :   A->Inherited = Inherited;
    3569           2 :   A->IsPackExpansion = IsPackExpansion;
    3570           2 :   A->Implicit = Implicit;
    3571           2 :   return A;
    3572             : }
    3573             : 
    3574           1 : void InitSegAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    3575           1 :   switch (SpellingListIndex) {
    3576           0 :   default:
    3577           0 :     llvm_unreachable("Unknown attribute spelling!");
    3578             :     break;
    3579           1 :   case 0 : {
    3580           1 :     OS << "#pragma init_seg";
    3581           1 :     printPrettyPragma(OS, Policy);
    3582           1 :     OS << "\n";    break;
    3583             :   }
    3584             : }
    3585           1 : }
    3586             : 
    3587           0 : const char *InitSegAttr::getSpelling() const {
    3588           0 :   switch (SpellingListIndex) {
    3589           0 :   default:
    3590           0 :     llvm_unreachable("Unknown attribute spelling!");
    3591             :     return "(No spelling)";
    3592           0 :   case 0:
    3593             :     return "init_seg";
    3594             :   }
    3595             : }
    3596             : 
    3597           0 : IntelOclBiccAttr *IntelOclBiccAttr::clone(ASTContext &C) const {
    3598             :   auto *A = new (C) IntelOclBiccAttr(getLocation(), C, getSpellingListIndex());
    3599           0 :   A->Inherited = Inherited;
    3600           0 :   A->IsPackExpansion = IsPackExpansion;
    3601           0 :   A->Implicit = Implicit;
    3602           0 :   return A;
    3603             : }
    3604             : 
    3605           0 : void IntelOclBiccAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    3606           0 :   switch (SpellingListIndex) {
    3607           0 :   default:
    3608           0 :     llvm_unreachable("Unknown attribute spelling!");
    3609             :     break;
    3610           0 :   case 0 : {
    3611           0 :     OS << " __attribute__((intel_ocl_bicc))";
    3612           0 :     break;
    3613             :   }
    3614           0 :   case 1 : {
    3615           0 :     OS << " [[clang::intel_ocl_bicc]]";
    3616           0 :     break;
    3617             :   }
    3618             : }
    3619           0 : }
    3620             : 
    3621           0 : const char *IntelOclBiccAttr::getSpelling() const {
    3622           0 :   switch (SpellingListIndex) {
    3623           0 :   default:
    3624           0 :     llvm_unreachable("Unknown attribute spelling!");
    3625             :     return "(No spelling)";
    3626             :   case 0:
    3627             :     return "intel_ocl_bicc";
    3628             :   case 1:
    3629             :     return "intel_ocl_bicc";
    3630             :   }
    3631             : }
    3632             : 
    3633           0 : InternalLinkageAttr *InternalLinkageAttr::clone(ASTContext &C) const {
    3634             :   auto *A = new (C) InternalLinkageAttr(getLocation(), C, getSpellingListIndex());
    3635           0 :   A->Inherited = Inherited;
    3636           0 :   A->IsPackExpansion = IsPackExpansion;
    3637           0 :   A->Implicit = Implicit;
    3638           0 :   return A;
    3639             : }
    3640             : 
    3641           0 : void InternalLinkageAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    3642           0 :   switch (SpellingListIndex) {
    3643           0 :   default:
    3644           0 :     llvm_unreachable("Unknown attribute spelling!");
    3645             :     break;
    3646           0 :   case 0 : {
    3647           0 :     OS << " __attribute__((internal_linkage))";
    3648           0 :     break;
    3649             :   }
    3650           0 :   case 1 : {
    3651           0 :     OS << " [[clang::internal_linkage]]";
    3652           0 :     break;
    3653             :   }
    3654           0 :   case 2 : {
    3655           0 :     OS << " [[clang::internal_linkage]]";
    3656           0 :     break;
    3657             :   }
    3658             : }
    3659           0 : }
    3660             : 
    3661          10 : const char *InternalLinkageAttr::getSpelling() const {
    3662          10 :   switch (SpellingListIndex) {
    3663           0 :   default:
    3664           0 :     llvm_unreachable("Unknown attribute spelling!");
    3665             :     return "(No spelling)";
    3666             :   case 0:
    3667             :     return "internal_linkage";
    3668             :   case 1:
    3669             :     return "internal_linkage";
    3670             :   case 2:
    3671             :     return "internal_linkage";
    3672             :   }
    3673             : }
    3674             : 
    3675           0 : LTOVisibilityPublicAttr *LTOVisibilityPublicAttr::clone(ASTContext &C) const {
    3676             :   auto *A = new (C) LTOVisibilityPublicAttr(getLocation(), C, getSpellingListIndex());
    3677           0 :   A->Inherited = Inherited;
    3678           0 :   A->IsPackExpansion = IsPackExpansion;
    3679           0 :   A->Implicit = Implicit;
    3680           0 :   return A;
    3681             : }
    3682             : 
    3683           0 : void LTOVisibilityPublicAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    3684           0 :   switch (SpellingListIndex) {
    3685           0 :   default:
    3686           0 :     llvm_unreachable("Unknown attribute spelling!");
    3687             :     break;
    3688           0 :   case 0 : {
    3689           0 :     OS << " __attribute__((lto_visibility_public))";
    3690           0 :     break;
    3691             :   }
    3692           0 :   case 1 : {
    3693           0 :     OS << " [[clang::lto_visibility_public]]";
    3694           0 :     break;
    3695             :   }
    3696           0 :   case 2 : {
    3697           0 :     OS << " [[clang::lto_visibility_public]]";
    3698           0 :     break;
    3699             :   }
    3700             : }
    3701           0 : }
    3702             : 
    3703           0 : const char *LTOVisibilityPublicAttr::getSpelling() const {
    3704           0 :   switch (SpellingListIndex) {
    3705           0 :   default:
    3706           0 :     llvm_unreachable("Unknown attribute spelling!");
    3707             :     return "(No spelling)";
    3708             :   case 0:
    3709             :     return "lto_visibility_public";
    3710             :   case 1:
    3711             :     return "lto_visibility_public";
    3712             :   case 2:
    3713             :     return "lto_visibility_public";
    3714             :   }
    3715             : }
    3716             : 
    3717           0 : LayoutVersionAttr *LayoutVersionAttr::clone(ASTContext &C) const {
    3718           0 :   auto *A = new (C) LayoutVersionAttr(getLocation(), C, version, getSpellingListIndex());
    3719           0 :   A->Inherited = Inherited;
    3720           0 :   A->IsPackExpansion = IsPackExpansion;
    3721           0 :   A->Implicit = Implicit;
    3722           0 :   return A;
    3723             : }
    3724             : 
    3725           0 : void LayoutVersionAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    3726           0 :   switch (SpellingListIndex) {
    3727           0 :   default:
    3728           0 :     llvm_unreachable("Unknown attribute spelling!");
    3729             :     break;
    3730           0 :   case 0 : {
    3731           0 :     OS << " __declspec(layout_version(" << getVersion() << "))";
    3732             :     break;
    3733             :   }
    3734             : }
    3735           0 : }
    3736             : 
    3737           0 : const char *LayoutVersionAttr::getSpelling() const {
    3738           0 :   switch (SpellingListIndex) {
    3739           0 :   default:
    3740           0 :     llvm_unreachable("Unknown attribute spelling!");
    3741             :     return "(No spelling)";
    3742           0 :   case 0:
    3743             :     return "layout_version";
    3744             :   }
    3745             : }
    3746             : 
    3747           3 : LockReturnedAttr *LockReturnedAttr::clone(ASTContext &C) const {
    3748           3 :   auto *A = new (C) LockReturnedAttr(getLocation(), C, arg, getSpellingListIndex());
    3749           3 :   A->Inherited = Inherited;
    3750           3 :   A->IsPackExpansion = IsPackExpansion;
    3751           3 :   A->Implicit = Implicit;
    3752           3 :   return A;
    3753             : }
    3754             : 
    3755           0 : void LockReturnedAttr::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 << " __attribute__((lock_returned(" << getArg() << ")))";
    3762             :     break;
    3763             :   }
    3764             : }
    3765           0 : }
    3766             : 
    3767           0 : const char *LockReturnedAttr::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 "lock_returned";
    3774             :   }
    3775             : }
    3776             : 
    3777          19 : LocksExcludedAttr *LocksExcludedAttr::clone(ASTContext &C) const {
    3778          19 :   auto *A = new (C) LocksExcludedAttr(getLocation(), C, args_, args_Size, getSpellingListIndex());
    3779          19 :   A->Inherited = Inherited;
    3780          19 :   A->IsPackExpansion = IsPackExpansion;
    3781          19 :   A->Implicit = Implicit;
    3782          19 :   return A;
    3783             : }
    3784             : 
    3785           0 : void LocksExcludedAttr::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__((locks_excluded(";
    3792             :   bool isFirst = true;
    3793           0 :   for (const auto &Val : args()) {
    3794           0 :     if (isFirst) isFirst = false;
    3795           0 :     else OS << ", ";
    3796           0 :     OS << Val;
    3797             :   }
    3798           0 :   OS << ")))";
    3799             :     break;
    3800             :   }
    3801             : }
    3802           0 : }
    3803             : 
    3804           0 : const char *LocksExcludedAttr::getSpelling() const {
    3805           0 :   switch (SpellingListIndex) {
    3806           0 :   default:
    3807           0 :     llvm_unreachable("Unknown attribute spelling!");
    3808             :     return "(No spelling)";
    3809           0 :   case 0:
    3810             :     return "locks_excluded";
    3811             :   }
    3812             : }
    3813             : 
    3814           2 : LoopHintAttr *LoopHintAttr::clone(ASTContext &C) const {
    3815           2 :   auto *A = new (C) LoopHintAttr(getLocation(), C, option, state, value, getSpellingListIndex());
    3816           2 :   A->Inherited = Inherited;
    3817           2 :   A->IsPackExpansion = IsPackExpansion;
    3818           2 :   A->Implicit = Implicit;
    3819           2 :   return A;
    3820             : }
    3821             : 
    3822          42 : void LoopHintAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    3823          42 :   switch (SpellingListIndex) {
    3824           0 :   default:
    3825           0 :     llvm_unreachable("Unknown attribute spelling!");
    3826             :     break;
    3827          39 :   case 0 : {
    3828          39 :     OS << "#pragma clang loop";
    3829          39 :     printPrettyPragma(OS, Policy);
    3830          39 :     OS << "\n";    break;
    3831             :   }
    3832           2 :   case 1 : {
    3833           2 :     OS << "#pragma unroll";
    3834           2 :     printPrettyPragma(OS, Policy);
    3835           2 :     OS << "\n";    break;
    3836             :   }
    3837           1 :   case 2 : {
    3838           1 :     OS << "#pragma nounroll";
    3839           1 :     printPrettyPragma(OS, Policy);
    3840           1 :     OS << "\n";    break;
    3841             :   }
    3842             : }
    3843          42 : }
    3844             : 
    3845           1 : const char *LoopHintAttr::getSpelling() const {
    3846           1 :   switch (SpellingListIndex) {
    3847           0 :   default:
    3848           0 :     llvm_unreachable("Unknown attribute spelling!");
    3849             :     return "(No spelling)";
    3850             :   case 0:
    3851             :     return "loop";
    3852           1 :   case 1:
    3853           1 :     return "unroll";
    3854           0 :   case 2:
    3855           0 :     return "nounroll";
    3856             :   }
    3857             : }
    3858             : 
    3859           0 : MSABIAttr *MSABIAttr::clone(ASTContext &C) const {
    3860             :   auto *A = new (C) MSABIAttr(getLocation(), C, getSpellingListIndex());
    3861           0 :   A->Inherited = Inherited;
    3862           0 :   A->IsPackExpansion = IsPackExpansion;
    3863           0 :   A->Implicit = Implicit;
    3864           0 :   return A;
    3865             : }
    3866             : 
    3867           0 : void MSABIAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    3868           0 :   switch (SpellingListIndex) {
    3869           0 :   default:
    3870           0 :     llvm_unreachable("Unknown attribute spelling!");
    3871             :     break;
    3872           0 :   case 0 : {
    3873           0 :     OS << " __attribute__((ms_abi))";
    3874           0 :     break;
    3875             :   }
    3876           0 :   case 1 : {
    3877           0 :     OS << " [[gnu::ms_abi]]";
    3878           0 :     break;
    3879             :   }
    3880             : }
    3881           0 : }
    3882             : 
    3883           0 : const char *MSABIAttr::getSpelling() const {
    3884           0 :   switch (SpellingListIndex) {
    3885           0 :   default:
    3886           0 :     llvm_unreachable("Unknown attribute spelling!");
    3887             :     return "(No spelling)";
    3888             :   case 0:
    3889             :     return "ms_abi";
    3890             :   case 1:
    3891             :     return "ms_abi";
    3892             :   }
    3893             : }
    3894             : 
    3895           0 : MSInheritanceAttr *MSInheritanceAttr::clone(ASTContext &C) const {
    3896           0 :   auto *A = new (C) MSInheritanceAttr(getLocation(), C, bestCase, getSpellingListIndex());
    3897           0 :   A->Inherited = Inherited;
    3898           0 :   A->IsPackExpansion = IsPackExpansion;
    3899           0 :   A->Implicit = Implicit;
    3900           0 :   return A;
    3901             : }
    3902             : 
    3903           3 : void MSInheritanceAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    3904           3 :   switch (SpellingListIndex) {
    3905           0 :   default:
    3906           0 :     llvm_unreachable("Unknown attribute spelling!");
    3907             :     break;
    3908           1 :   case 0 : {
    3909           1 :     OS << " __single_inheritance";
    3910           1 :     break;
    3911             :   }
    3912           1 :   case 1 : {
    3913           1 :     OS << " __multiple_inheritance";
    3914           1 :     break;
    3915             :   }
    3916           1 :   case 2 : {
    3917           1 :     OS << " __virtual_inheritance";
    3918           1 :     break;
    3919             :   }
    3920           0 :   case 3 : {
    3921           0 :     OS << " __unspecified_inheritance";
    3922           0 :     break;
    3923             :   }
    3924             : }
    3925           3 : }
    3926             : 
    3927           0 : const char *MSInheritanceAttr::getSpelling() const {
    3928           0 :   switch (SpellingListIndex) {
    3929           0 :   default:
    3930           0 :     llvm_unreachable("Unknown attribute spelling!");
    3931             :     return "(No spelling)";
    3932             :   case 0:
    3933             :     return "__single_inheritance";
    3934           0 :   case 1:
    3935           0 :     return "__multiple_inheritance";
    3936           0 :   case 2:
    3937           0 :     return "__virtual_inheritance";
    3938           0 :   case 3:
    3939           0 :     return "__unspecified_inheritance";
    3940             :   }
    3941             : }
    3942             : 
    3943           0 : MSNoVTableAttr *MSNoVTableAttr::clone(ASTContext &C) const {
    3944             :   auto *A = new (C) MSNoVTableAttr(getLocation(), C, getSpellingListIndex());
    3945           0 :   A->Inherited = Inherited;
    3946           0 :   A->IsPackExpansion = IsPackExpansion;
    3947           0 :   A->Implicit = Implicit;
    3948           0 :   return A;
    3949             : }
    3950             : 
    3951           0 : void MSNoVTableAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    3952           0 :   switch (SpellingListIndex) {
    3953           0 :   default:
    3954           0 :     llvm_unreachable("Unknown attribute spelling!");
    3955             :     break;
    3956           0 :   case 0 : {
    3957           0 :     OS << " __declspec(novtable)";
    3958             :     break;
    3959             :   }
    3960             : }
    3961           0 : }
    3962             : 
    3963           0 : const char *MSNoVTableAttr::getSpelling() const {
    3964           0 :   switch (SpellingListIndex) {
    3965           0 :   default:
    3966           0 :     llvm_unreachable("Unknown attribute spelling!");
    3967             :     return "(No spelling)";
    3968           0 :   case 0:
    3969             :     return "novtable";
    3970             :   }
    3971             : }
    3972             : 
    3973           0 : MSP430InterruptAttr *MSP430InterruptAttr::clone(ASTContext &C) const {
    3974           0 :   auto *A = new (C) MSP430InterruptAttr(getLocation(), C, number, 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 MSP430InterruptAttr::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 << " __attribute__((interrupt(" << getNumber() << ")))";
    3988           0 :     break;
    3989             :   }
    3990           0 :   case 1 : {
    3991           0 :     OS << " [[gnu::interrupt(" << getNumber() << ")]]";
    3992           0 :     break;
    3993             :   }
    3994             : }
    3995           0 : }
    3996             : 
    3997           0 : const char *MSP430InterruptAttr::getSpelling() const {
    3998           0 :   switch (SpellingListIndex) {
    3999           0 :   default:
    4000           0 :     llvm_unreachable("Unknown attribute spelling!");
    4001             :     return "(No spelling)";
    4002             :   case 0:
    4003             :     return "interrupt";
    4004             :   case 1:
    4005             :     return "interrupt";
    4006             :   }
    4007             : }
    4008             : 
    4009           1 : MSStructAttr *MSStructAttr::clone(ASTContext &C) const {
    4010             :   auto *A = new (C) MSStructAttr(getLocation(), C, getSpellingListIndex());
    4011           1 :   A->Inherited = Inherited;
    4012           1 :   A->IsPackExpansion = IsPackExpansion;
    4013           1 :   A->Implicit = Implicit;
    4014           1 :   return A;
    4015             : }
    4016             : 
    4017           0 : void MSStructAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    4018           0 :   switch (SpellingListIndex) {
    4019           0 :   default:
    4020           0 :     llvm_unreachable("Unknown attribute spelling!");
    4021             :     break;
    4022           0 :   case 0 : {
    4023           0 :     OS << " __attribute__((ms_struct))";
    4024           0 :     break;
    4025             :   }
    4026           0 :   case 1 : {
    4027           0 :     OS << " [[gnu::ms_struct]]";
    4028           0 :     break;
    4029             :   }
    4030             : }
    4031           0 : }
    4032             : 
    4033           0 : const char *MSStructAttr::getSpelling() const {
    4034           0 :   switch (SpellingListIndex) {
    4035           0 :   default:
    4036           0 :     llvm_unreachable("Unknown attribute spelling!");
    4037             :     return "(No spelling)";
    4038             :   case 0:
    4039             :     return "ms_struct";
    4040             :   case 1:
    4041             :     return "ms_struct";
    4042             :   }
    4043             : }
    4044             : 
    4045           2 : MSVtorDispAttr *MSVtorDispAttr::clone(ASTContext &C) const {
    4046           2 :   auto *A = new (C) MSVtorDispAttr(getLocation(), C, vdm, getSpellingListIndex());
    4047           2 :   A->Inherited = Inherited;
    4048           2 :   A->IsPackExpansion = IsPackExpansion;
    4049           2 :   A->Implicit = Implicit;
    4050           2 :   return A;
    4051             : }
    4052             : 
    4053           0 : void MSVtorDispAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    4054           0 : }
    4055             : 
    4056           0 : const char *MSVtorDispAttr::getSpelling() const {
    4057           0 :   return "(No spelling)";
    4058             : }
    4059             : 
    4060           1 : MaxFieldAlignmentAttr *MaxFieldAlignmentAttr::clone(ASTContext &C) const {
    4061           1 :   auto *A = new (C) MaxFieldAlignmentAttr(getLocation(), C, alignment, getSpellingListIndex());
    4062           1 :   A->Inherited = Inherited;
    4063           1 :   A->IsPackExpansion = IsPackExpansion;
    4064           1 :   A->Implicit = Implicit;
    4065           1 :   return A;
    4066             : }
    4067             : 
    4068           0 : void MaxFieldAlignmentAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    4069           0 : }
    4070             : 
    4071           0 : const char *MaxFieldAlignmentAttr::getSpelling() const {
    4072           0 :   return "(No spelling)";
    4073             : }
    4074             : 
    4075          14 : MayAliasAttr *MayAliasAttr::clone(ASTContext &C) const {
    4076             :   auto *A = new (C) MayAliasAttr(getLocation(), C, getSpellingListIndex());
    4077          14 :   A->Inherited = Inherited;
    4078          14 :   A->IsPackExpansion = IsPackExpansion;
    4079          14 :   A->Implicit = Implicit;
    4080          14 :   return A;
    4081             : }
    4082             : 
    4083          16 : void MayAliasAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    4084          16 :   switch (SpellingListIndex) {
    4085           0 :   default:
    4086           0 :     llvm_unreachable("Unknown attribute spelling!");
    4087             :     break;
    4088          16 :   case 0 : {
    4089          16 :     OS << " __attribute__((may_alias))";
    4090          16 :     break;
    4091             :   }
    4092           0 :   case 1 : {
    4093           0 :     OS << " [[gnu::may_alias]]";
    4094           0 :     break;
    4095             :   }
    4096             : }
    4097          16 : }
    4098             : 
    4099           0 : const char *MayAliasAttr::getSpelling() const {
    4100           0 :   switch (SpellingListIndex) {
    4101           0 :   default:
    4102           0 :     llvm_unreachable("Unknown attribute spelling!");
    4103             :     return "(No spelling)";
    4104             :   case 0:
    4105             :     return "may_alias";
    4106             :   case 1:
    4107             :     return "may_alias";
    4108             :   }
    4109             : }
    4110             : 
    4111           0 : MicroMipsAttr *MicroMipsAttr::clone(ASTContext &C) const {
    4112             :   auto *A = new (C) MicroMipsAttr(getLocation(), C, getSpellingListIndex());
    4113           0 :   A->Inherited = Inherited;
    4114           0 :   A->IsPackExpansion = IsPackExpansion;
    4115           0 :   A->Implicit = Implicit;
    4116           0 :   return A;
    4117             : }
    4118             : 
    4119           0 : void MicroMipsAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    4120           0 :   switch (SpellingListIndex) {
    4121           0 :   default:
    4122           0 :     llvm_unreachable("Unknown attribute spelling!");
    4123             :     break;
    4124           0 :   case 0 : {
    4125           0 :     OS << " __attribute__((micromips))";
    4126           0 :     break;
    4127             :   }
    4128           0 :   case 1 : {
    4129           0 :     OS << " [[gnu::micromips]]";
    4130           0 :     break;
    4131             :   }
    4132             : }
    4133           0 : }
    4134             : 
    4135           1 : const char *MicroMipsAttr::getSpelling() const {
    4136           1 :   switch (SpellingListIndex) {
    4137           0 :   default:
    4138           0 :     llvm_unreachable("Unknown attribute spelling!");
    4139             :     return "(No spelling)";
    4140             :   case 0:
    4141             :     return "micromips";
    4142             :   case 1:
    4143             :     return "micromips";
    4144             :   }
    4145             : }
    4146             : 
    4147          12 : MinSizeAttr *MinSizeAttr::clone(ASTContext &C) const {
    4148             :   auto *A = new (C) MinSizeAttr(getLocation(), C, getSpellingListIndex());
    4149          12 :   A->Inherited = Inherited;
    4150          12 :   A->IsPackExpansion = IsPackExpansion;
    4151          12 :   A->Implicit = Implicit;
    4152          12 :   return A;
    4153             : }
    4154             : 
    4155           0 : void MinSizeAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    4156           0 :   switch (SpellingListIndex) {
    4157           0 :   default:
    4158           0 :     llvm_unreachable("Unknown attribute spelling!");
    4159             :     break;
    4160           0 :   case 0 : {
    4161           0 :     OS << " __attribute__((minsize))";
    4162           0 :     break;
    4163             :   }
    4164           0 :   case 1 : {
    4165           0 :     OS << " [[clang::minsize]]";
    4166           0 :     break;
    4167             :   }
    4168           0 :   case 2 : {
    4169           0 :     OS << " [[clang::minsize]]";
    4170           0 :     break;
    4171             :   }
    4172             : }
    4173           0 : }
    4174             : 
    4175           3 : const char *MinSizeAttr::getSpelling() const {
    4176           3 :   switch (SpellingListIndex) {
    4177           0 :   default:
    4178           0 :     llvm_unreachable("Unknown attribute spelling!");
    4179             :     return "(No spelling)";
    4180             :   case 0:
    4181             :     return "minsize";
    4182             :   case 1:
    4183             :     return "minsize";
    4184             :   case 2:
    4185             :     return "minsize";
    4186             :   }
    4187             : }
    4188             : 
    4189           0 : MinVectorWidthAttr *MinVectorWidthAttr::clone(ASTContext &C) const {
    4190           0 :   auto *A = new (C) MinVectorWidthAttr(getLocation(), C, vectorWidth, getSpellingListIndex());
    4191           0 :   A->Inherited = Inherited;
    4192           0 :   A->IsPackExpansion = IsPackExpansion;
    4193           0 :   A->Implicit = Implicit;
    4194           0 :   return A;
    4195             : }
    4196             : 
    4197           0 : void MinVectorWidthAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    4198           0 :   switch (SpellingListIndex) {
    4199           0 :   default:
    4200           0 :     llvm_unreachable("Unknown attribute spelling!");
    4201             :     break;
    4202           0 :   case 0 : {
    4203           0 :     OS << " __attribute__((min_vector_width(" << getVectorWidth() << ")))";
    4204           0 :     break;
    4205             :   }
    4206           0 :   case 1 : {
    4207           0 :     OS << " [[clang::min_vector_width(" << getVectorWidth() << ")]]";
    4208           0 :     break;
    4209             :   }
    4210           0 :   case 2 : {
    4211           0 :     OS << " [[clang::min_vector_width(" << getVectorWidth() << ")]]";
    4212           0 :     break;
    4213             :   }
    4214             : }
    4215           0 : }
    4216             : 
    4217           0 : const char *MinVectorWidthAttr::getSpelling() const {
    4218           0 :   switch (SpellingListIndex) {
    4219           0 :   default:
    4220           0 :     llvm_unreachable("Unknown attribute spelling!");
    4221             :     return "(No spelling)";
    4222             :   case 0:
    4223             :     return "min_vector_width";
    4224             :   case 1:
    4225             :     return "min_vector_width";
    4226             :   case 2:
    4227             :     return "min_vector_width";
    4228             :   }
    4229             : }
    4230             : 
    4231           1 : Mips16Attr *Mips16Attr::clone(ASTContext &C) const {
    4232             :   auto *A = new (C) Mips16Attr(getLocation(), C, getSpellingListIndex());
    4233           1 :   A->Inherited = Inherited;
    4234           1 :   A->IsPackExpansion = IsPackExpansion;
    4235           1 :   A->Implicit = Implicit;
    4236           1 :   return A;
    4237             : }
    4238             : 
    4239           0 : void Mips16Attr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    4240           0 :   switch (SpellingListIndex) {
    4241           0 :   default:
    4242           0 :     llvm_unreachable("Unknown attribute spelling!");
    4243             :     break;
    4244           0 :   case 0 : {
    4245           0 :     OS << " __attribute__((mips16))";
    4246           0 :     break;
    4247             :   }
    4248           0 :   case 1 : {
    4249           0 :     OS << " [[gnu::mips16]]";
    4250           0 :     break;
    4251             :   }
    4252             : }
    4253           0 : }
    4254             : 
    4255           4 : const char *Mips16Attr::getSpelling() const {
    4256           4 :   switch (SpellingListIndex) {
    4257           0 :   default:
    4258           0 :     llvm_unreachable("Unknown attribute spelling!");
    4259             :     return "(No spelling)";
    4260             :   case 0:
    4261             :     return "mips16";
    4262             :   case 1:
    4263             :     return "mips16";
    4264             :   }
    4265             : }
    4266             : 
    4267           0 : MipsInterruptAttr *MipsInterruptAttr::clone(ASTContext &C) const {
    4268           0 :   auto *A = new (C) MipsInterruptAttr(getLocation(), C, interrupt, getSpellingListIndex());
    4269           0 :   A->Inherited = Inherited;
    4270           0 :   A->IsPackExpansion = IsPackExpansion;
    4271           0 :   A->Implicit = Implicit;
    4272           0 :   return A;
    4273             : }
    4274             : 
    4275           0 : void MipsInterruptAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    4276           0 :   switch (SpellingListIndex) {
    4277           0 :   default:
    4278           0 :     llvm_unreachable("Unknown attribute spelling!");
    4279             :     break;
    4280           0 :   case 0 : {
    4281           0 :     OS << " __attribute__((interrupt(\"" << MipsInterruptAttr::ConvertInterruptTypeToStr(getInterrupt()) << "\")))";
    4282           0 :     break;
    4283             :   }
    4284           0 :   case 1 : {
    4285           0 :     OS << " [[gnu::interrupt(\"" << MipsInterruptAttr::ConvertInterruptTypeToStr(getInterrupt()) << "\")]]";
    4286           0 :     break;
    4287             :   }
    4288             : }
    4289           0 : }
    4290             : 
    4291           2 : const char *MipsInterruptAttr::getSpelling() const {
    4292           2 :   switch (SpellingListIndex) {
    4293           0 :   default:
    4294           0 :     llvm_unreachable("Unknown attribute spelling!");
    4295             :     return "(No spelling)";
    4296             :   case 0:
    4297             :     return "interrupt";
    4298             :   case 1:
    4299             :     return "interrupt";
    4300             :   }
    4301             : }
    4302             : 
    4303           0 : MipsLongCallAttr *MipsLongCallAttr::clone(ASTContext &C) const {
    4304             :   auto *A = new (C) MipsLongCallAttr(getLocation(), C, getSpellingListIndex());
    4305           0 :   A->Inherited = Inherited;
    4306           0 :   A->IsPackExpansion = IsPackExpansion;
    4307           0 :   A->Implicit = Implicit;
    4308           0 :   return A;
    4309             : }
    4310             : 
    4311           0 : void MipsLongCallAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    4312           0 :   switch (SpellingListIndex) {
    4313           0 :   default:
    4314           0 :     llvm_unreachable("Unknown attribute spelling!");
    4315             :     break;
    4316           0 :   case 0 : {
    4317           0 :     OS << " __attribute__((long_call))";
    4318           0 :     break;
    4319             :   }
    4320           0 :   case 1 : {
    4321           0 :     OS << " [[gnu::long_call]]";
    4322           0 :     break;
    4323             :   }
    4324           0 :   case 2 : {
    4325           0 :     OS << " __attribute__((far))";
    4326           0 :     break;
    4327             :   }
    4328           0 :   case 3 : {
    4329           0 :     OS << " [[gnu::far]]";
    4330           0 :     break;
    4331             :   }
    4332             : }
    4333           0 : }
    4334             : 
    4335           2 : const char *MipsLongCallAttr::getSpelling() const {
    4336           2 :   switch (SpellingListIndex) {
    4337           0 :   default:
    4338           0 :     llvm_unreachable("Unknown attribute spelling!");
    4339             :     return "(No spelling)";
    4340             :   case 0:
    4341             :     return "long_call";
    4342             :   case 1:
    4343             :     return "long_call";
    4344           0 :   case 2:
    4345           0 :     return "far";
    4346           0 :   case 3:
    4347           0 :     return "far";
    4348             :   }
    4349             : }
    4350             : 
    4351           0 : MipsShortCallAttr *MipsShortCallAttr::clone(ASTContext &C) const {
    4352             :   auto *A = new (C) MipsShortCallAttr(getLocation(), C, getSpellingListIndex());
    4353           0 :   A->Inherited = Inherited;
    4354           0 :   A->IsPackExpansion = IsPackExpansion;
    4355           0 :   A->Implicit = Implicit;
    4356           0 :   return A;
    4357             : }
    4358             : 
    4359           0 : void MipsShortCallAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    4360           0 :   switch (SpellingListIndex) {
    4361           0 :   default:
    4362           0 :     llvm_unreachable("Unknown attribute spelling!");
    4363             :     break;
    4364           0 :   case 0 : {
    4365           0 :     OS << " __attribute__((short_call))";
    4366           0 :     break;
    4367             :   }
    4368           0 :   case 1 : {
    4369           0 :     OS << " [[gnu::short_call]]";
    4370           0 :     break;
    4371             :   }
    4372           0 :   case 2 : {
    4373           0 :     OS << " __attribute__((near))";
    4374           0 :     break;
    4375             :   }
    4376           0 :   case 3 : {
    4377           0 :     OS << " [[gnu::near]]";
    4378           0 :     break;
    4379             :   }
    4380             : }
    4381           0 : }
    4382             : 
    4383           2 : const char *MipsShortCallAttr::getSpelling() const {
    4384           2 :   switch (SpellingListIndex) {
    4385           0 :   default:
    4386           0 :     llvm_unreachable("Unknown attribute spelling!");
    4387             :     return "(No spelling)";
    4388             :   case 0:
    4389             :     return "short_call";
    4390             :   case 1:
    4391             :     return "short_call";
    4392           2 :   case 2:
    4393           2 :     return "near";
    4394           0 :   case 3:
    4395           0 :     return "near";
    4396             :   }
    4397             : }
    4398             : 
    4399           0 : ModeAttr *ModeAttr::clone(ASTContext &C) const {
    4400           0 :   auto *A = new (C) ModeAttr(getLocation(), C, mode, getSpellingListIndex());
    4401           0 :   A->Inherited = Inherited;
    4402           0 :   A->IsPackExpansion = IsPackExpansion;
    4403           0 :   A->Implicit = Implicit;
    4404           0 :   return A;
    4405             : }
    4406             : 
    4407           3 : void ModeAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    4408           3 :   switch (SpellingListIndex) {
    4409           0 :   default:
    4410           0 :     llvm_unreachable("Unknown attribute spelling!");
    4411             :     break;
    4412           2 :   case 0 : {
    4413           2 :     OS << " __attribute__((mode(" << (getMode() ? getMode()->getName() : "") << ")))";
    4414           2 :     break;
    4415             :   }
    4416           1 :   case 1 : {
    4417           1 :     OS << " [[gnu::mode(" << (getMode() ? getMode()->getName() : "") << ")]]";
    4418           1 :     break;
    4419             :   }
    4420             : }
    4421           3 : }
    4422             : 
    4423           0 : const char *ModeAttr::getSpelling() const {
    4424           0 :   switch (SpellingListIndex) {
    4425           0 :   default:
    4426           0 :     llvm_unreachable("Unknown attribute spelling!");
    4427             :     return "(No spelling)";
    4428             :   case 0:
    4429             :     return "mode";
    4430             :   case 1:
    4431             :     return "mode";
    4432             :   }
    4433             : }
    4434             : 
    4435           6 : NSConsumedAttr *NSConsumedAttr::clone(ASTContext &C) const {
    4436             :   auto *A = new (C) NSConsumedAttr(getLocation(), C, getSpellingListIndex());
    4437           6 :   A->Inherited = Inherited;
    4438           6 :   A->IsPackExpansion = IsPackExpansion;
    4439           6 :   A->Implicit = Implicit;
    4440           6 :   return A;
    4441             : }
    4442             : 
    4443           0 : void NSConsumedAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    4444           0 :   switch (SpellingListIndex) {
    4445           0 :   default:
    4446           0 :     llvm_unreachable("Unknown attribute spelling!");
    4447             :     break;
    4448           0 :   case 0 : {
    4449           0 :     OS << " __attribute__((ns_consumed))";
    4450           0 :     break;
    4451             :   }
    4452           0 :   case 1 : {
    4453           0 :     OS << " [[clang::ns_consumed]]";
    4454           0 :     break;
    4455             :   }
    4456           0 :   case 2 : {
    4457           0 :     OS << " [[clang::ns_consumed]]";
    4458           0 :     break;
    4459             :   }
    4460             : }
    4461           0 : }
    4462             : 
    4463           0 : const char *NSConsumedAttr::getSpelling() const {
    4464           0 :   switch (SpellingListIndex) {
    4465           0 :   default:
    4466           0 :     llvm_unreachable("Unknown attribute spelling!");
    4467             :     return "(No spelling)";
    4468             :   case 0:
    4469             :     return "ns_consumed";
    4470             :   case 1:
    4471             :     return "ns_consumed";
    4472             :   case 2:
    4473             :     return "ns_consumed";
    4474             :   }
    4475             : }
    4476             : 
    4477         137 : NSConsumesSelfAttr *NSConsumesSelfAttr::clone(ASTContext &C) const {
    4478             :   auto *A = new (C) NSConsumesSelfAttr(getLocation(), C, getSpellingListIndex());
    4479         137 :   A->Inherited = Inherited;
    4480         137 :   A->IsPackExpansion = IsPackExpansion;
    4481         137 :   A->Implicit = Implicit;
    4482         137 :   return A;
    4483             : }
    4484             : 
    4485           0 : void NSConsumesSelfAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    4486           0 :   switch (SpellingListIndex) {
    4487           0 :   default:
    4488           0 :     llvm_unreachable("Unknown attribute spelling!");
    4489             :     break;
    4490           0 :   case 0 : {
    4491           0 :     OS << " __attribute__((ns_consumes_self))";
    4492           0 :     break;
    4493             :   }
    4494           0 :   case 1 : {
    4495           0 :     OS << " [[clang::ns_consumes_self]]";
    4496           0 :     break;
    4497             :   }
    4498           0 :   case 2 : {
    4499           0 :     OS << " [[clang::ns_consumes_self]]";
    4500           0 :     break;
    4501             :   }
    4502             : }
    4503           0 : }
    4504             : 
    4505           0 : const char *NSConsumesSelfAttr::getSpelling() const {
    4506           0 :   switch (SpellingListIndex) {
    4507           0 :   default:
    4508           0 :     llvm_unreachable("Unknown attribute spelling!");
    4509             :     return "(No spelling)";
    4510             :   case 0:
    4511             :     return "ns_consumes_self";
    4512             :   case 1:
    4513             :     return "ns_consumes_self";
    4514             :   case 2:
    4515             :     return "ns_consumes_self";
    4516             :   }
    4517             : }
    4518             : 
    4519           0 : NSReturnsAutoreleasedAttr *NSReturnsAutoreleasedAttr::clone(ASTContext &C) const {
    4520             :   auto *A = new (C) NSReturnsAutoreleasedAttr(getLocation(), C, getSpellingListIndex());
    4521           0 :   A->Inherited = Inherited;
    4522           0 :   A->IsPackExpansion = IsPackExpansion;
    4523           0 :   A->Implicit = Implicit;
    4524           0 :   return A;
    4525             : }
    4526             : 
    4527           0 : void NSReturnsAutoreleasedAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    4528           0 :   switch (SpellingListIndex) {
    4529           0 :   default:
    4530           0 :     llvm_unreachable("Unknown attribute spelling!");
    4531             :     break;
    4532           0 :   case 0 : {
    4533           0 :     OS << " __attribute__((ns_returns_autoreleased))";
    4534           0 :     break;
    4535             :   }
    4536           0 :   case 1 : {
    4537           0 :     OS << " [[clang::ns_returns_autoreleased]]";
    4538           0 :     break;
    4539             :   }
    4540           0 :   case 2 : {
    4541           0 :     OS << " [[clang::ns_returns_autoreleased]]";
    4542           0 :     break;
    4543             :   }
    4544             : }
    4545           0 : }
    4546             : 
    4547           0 : const char *NSReturnsAutoreleasedAttr::getSpelling() const {
    4548           0 :   switch (SpellingListIndex) {
    4549           0 :   default:
    4550           0 :     llvm_unreachable("Unknown attribute spelling!");
    4551             :     return "(No spelling)";
    4552             :   case 0:
    4553             :     return "ns_returns_autoreleased";
    4554             :   case 1:
    4555             :     return "ns_returns_autoreleased";
    4556             :   case 2:
    4557             :     return "ns_returns_autoreleased";
    4558             :   }
    4559             : }
    4560             : 
    4561           8 : NSReturnsNotRetainedAttr *NSReturnsNotRetainedAttr::clone(ASTContext &C) const {
    4562             :   auto *A = new (C) NSReturnsNotRetainedAttr(getLocation(), C, getSpellingListIndex());
    4563           8 :   A->Inherited = Inherited;
    4564           8 :   A->IsPackExpansion = IsPackExpansion;
    4565           8 :   A->Implicit = Implicit;
    4566           8 :   return A;
    4567             : }
    4568             : 
    4569           0 : void NSReturnsNotRetainedAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    4570           0 :   switch (SpellingListIndex) {
    4571           0 :   default:
    4572           0 :     llvm_unreachable("Unknown attribute spelling!");
    4573             :     break;
    4574           0 :   case 0 : {
    4575           0 :     OS << " __attribute__((ns_returns_not_retained))";
    4576           0 :     break;
    4577             :   }
    4578           0 :   case 1 : {
    4579           0 :     OS << " [[clang::ns_returns_not_retained]]";
    4580           0 :     break;
    4581             :   }
    4582           0 :   case 2 : {
    4583           0 :     OS << " [[clang::ns_returns_not_retained]]";
    4584           0 :     break;
    4585             :   }
    4586             : }
    4587           0 : }
    4588             : 
    4589           0 : const char *NSReturnsNotRetainedAttr::getSpelling() const {
    4590           0 :   switch (SpellingListIndex) {
    4591           0 :   default:
    4592           0 :     llvm_unreachable("Unknown attribute spelling!");
    4593             :     return "(No spelling)";
    4594             :   case 0:
    4595             :     return "ns_returns_not_retained";
    4596             :   case 1:
    4597             :     return "ns_returns_not_retained";
    4598             :   case 2:
    4599             :     return "ns_returns_not_retained";
    4600             :   }
    4601             : }
    4602             : 
    4603         175 : NSReturnsRetainedAttr *NSReturnsRetainedAttr::clone(ASTContext &C) const {
    4604             :   auto *A = new (C) NSReturnsRetainedAttr(getLocation(), C, getSpellingListIndex());
    4605         175 :   A->Inherited = Inherited;
    4606         175 :   A->IsPackExpansion = IsPackExpansion;
    4607         175 :   A->Implicit = Implicit;
    4608         175 :   return A;
    4609             : }
    4610             : 
    4611           0 : void NSReturnsRetainedAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    4612           0 :   switch (SpellingListIndex) {
    4613           0 :   default:
    4614           0 :     llvm_unreachable("Unknown attribute spelling!");
    4615             :     break;
    4616           0 :   case 0 : {
    4617           0 :     OS << " __attribute__((ns_returns_retained))";
    4618           0 :     break;
    4619             :   }
    4620           0 :   case 1 : {
    4621           0 :     OS << " [[clang::ns_returns_retained]]";
    4622           0 :     break;
    4623             :   }
    4624           0 :   case 2 : {
    4625           0 :     OS << " [[clang::ns_returns_retained]]";
    4626           0 :     break;
    4627             :   }
    4628             : }
    4629           0 : }
    4630             : 
    4631           0 : const char *NSReturnsRetainedAttr::getSpelling() const {
    4632           0 :   switch (SpellingListIndex) {
    4633           0 :   default:
    4634           0 :     llvm_unreachable("Unknown attribute spelling!");
    4635             :     return "(No spelling)";
    4636             :   case 0:
    4637             :     return "ns_returns_retained";
    4638             :   case 1:
    4639             :     return "ns_returns_retained";
    4640             :   case 2:
    4641             :     return "ns_returns_retained";
    4642             :   }
    4643             : }
    4644             : 
    4645           1 : NakedAttr *NakedAttr::clone(ASTContext &C) const {
    4646             :   auto *A = new (C) NakedAttr(getLocation(), C, getSpellingListIndex());
    4647           1 :   A->Inherited = Inherited;
    4648           1 :   A->IsPackExpansion = IsPackExpansion;
    4649           1 :   A->Implicit = Implicit;
    4650           1 :   return A;
    4651             : }
    4652             : 
    4653           0 : void NakedAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    4654           0 :   switch (SpellingListIndex) {
    4655           0 :   default:
    4656           0 :     llvm_unreachable("Unknown attribute spelling!");
    4657             :     break;
    4658           0 :   case 0 : {
    4659           0 :     OS << " __attribute__((naked))";
    4660           0 :     break;
    4661             :   }
    4662           0 :   case 1 : {
    4663           0 :     OS << " [[gnu::naked]]";
    4664           0 :     break;
    4665             :   }
    4666           0 :   case 2 : {
    4667           0 :     OS << " __declspec(naked)";
    4668           0 :     break;
    4669             :   }
    4670             : }
    4671           0 : }
    4672             : 
    4673           1 : const char *NakedAttr::getSpelling() const {
    4674           1 :   switch (SpellingListIndex) {
    4675           0 :   default:
    4676           0 :     llvm_unreachable("Unknown attribute spelling!");
    4677             :     return "(No spelling)";
    4678             :   case 0:
    4679             :     return "naked";
    4680             :   case 1:
    4681             :     return "naked";
    4682             :   case 2:
    4683             :     return "naked";
    4684             :   }
    4685             : }
    4686             : 
    4687           0 : NoAliasAttr *NoAliasAttr::clone(ASTContext &C) const {
    4688             :   auto *A = new (C) NoAliasAttr(getLocation(), C, getSpellingListIndex());
    4689           0 :   A->Inherited = Inherited;
    4690           0 :   A->IsPackExpansion = IsPackExpansion;
    4691           0 :   A->Implicit = Implicit;
    4692           0 :   return A;
    4693             : }
    4694             : 
    4695           0 : void NoAliasAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    4696           0 :   switch (SpellingListIndex) {
    4697           0 :   default:
    4698           0 :     llvm_unreachable("Unknown attribute spelling!");
    4699             :     break;
    4700           0 :   case 0 : {
    4701           0 :     OS << " __declspec(noalias)";
    4702             :     break;
    4703             :   }
    4704             : }
    4705           0 : }
    4706             : 
    4707           0 : const char *NoAliasAttr::getSpelling() const {
    4708           0 :   switch (SpellingListIndex) {
    4709           0 :   default:
    4710           0 :     llvm_unreachable("Unknown attribute spelling!");
    4711             :     return "(No spelling)";
    4712           0 :   case 0:
    4713             :     return "noalias";
    4714             :   }
    4715             : }
    4716             : 
    4717           0 : NoCommonAttr *NoCommonAttr::clone(ASTContext &C) const {
    4718             :   auto *A = new (C) NoCommonAttr(getLocation(), C, getSpellingListIndex());
    4719           0 :   A->Inherited = Inherited;
    4720           0 :   A->IsPackExpansion = IsPackExpansion;
    4721           0 :   A->Implicit = Implicit;
    4722           0 :   return A;
    4723             : }
    4724             : 
    4725           0 : void NoCommonAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    4726           0 :   switch (SpellingListIndex) {
    4727           0 :   default:
    4728           0 :     llvm_unreachable("Unknown attribute spelling!");
    4729             :     break;
    4730           0 :   case 0 : {
    4731           0 :     OS << " __attribute__((nocommon))";
    4732           0 :     break;
    4733             :   }
    4734           0 :   case 1 : {
    4735           0 :     OS << " [[gnu::nocommon]]";
    4736           0 :     break;
    4737             :   }
    4738             : }
    4739           0 : }
    4740             : 
    4741           0 : const char *NoCommonAttr::getSpelling() const {
    4742           0 :   switch (SpellingListIndex) {
    4743           0 :   default:
    4744           0 :     llvm_unreachable("Unknown attribute spelling!");
    4745             :     return "(No spelling)";
    4746             :   case 0:
    4747             :     return "nocommon";
    4748             :   case 1:
    4749             :     return "nocommon";
    4750             :   }
    4751             : }
    4752             : 
    4753           4 : NoDebugAttr *NoDebugAttr::clone(ASTContext &C) const {
    4754             :   auto *A = new (C) NoDebugAttr(getLocation(), C, getSpellingListIndex());
    4755           4 :   A->Inherited = Inherited;
    4756           4 :   A->IsPackExpansion = IsPackExpansion;
    4757           4 :   A->Implicit = Implicit;
    4758           4 :   return A;
    4759             : }
    4760             : 
    4761           0 : void NoDebugAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    4762           0 :   switch (SpellingListIndex) {
    4763           0 :   default:
    4764           0 :     llvm_unreachable("Unknown attribute spelling!");
    4765             :     break;
    4766           0 :   case 0 : {
    4767           0 :     OS << " __attribute__((nodebug))";
    4768           0 :     break;
    4769             :   }
    4770           0 :   case 1 : {
    4771           0 :     OS << " [[gnu::nodebug]]";
    4772           0 :     break;
    4773             :   }
    4774             : }
    4775           0 : }
    4776             : 
    4777           0 : const char *NoDebugAttr::getSpelling() const {
    4778           0 :   switch (SpellingListIndex) {
    4779           0 :   default:
    4780           0 :     llvm_unreachable("Unknown attribute spelling!");
    4781             :     return "(No spelling)";
    4782             :   case 0:
    4783             :     return "nodebug";
    4784             :   case 1:
    4785             :     return "nodebug";
    4786             :   }
    4787             : }
    4788             : 
    4789           0 : NoDuplicateAttr *NoDuplicateAttr::clone(ASTContext &C) const {
    4790             :   auto *A = new (C) NoDuplicateAttr(getLocation(), C, getSpellingListIndex());
    4791           0 :   A->Inherited = Inherited;
    4792           0 :   A->IsPackExpansion = IsPackExpansion;
    4793           0 :   A->Implicit = Implicit;
    4794           0 :   return A;
    4795             : }
    4796             : 
    4797           0 : void NoDuplicateAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    4798           0 :   switch (SpellingListIndex) {
    4799           0 :   default:
    4800           0 :     llvm_unreachable("Unknown attribute spelling!");
    4801             :     break;
    4802           0 :   case 0 : {
    4803           0 :     OS << " __attribute__((noduplicate))";
    4804           0 :     break;
    4805             :   }
    4806           0 :   case 1 : {
    4807           0 :     OS << " [[clang::noduplicate]]";
    4808           0 :     break;
    4809             :   }
    4810           0 :   case 2 : {
    4811           0 :     OS << " [[clang::noduplicate]]";
    4812           0 :     break;
    4813             :   }
    4814             : }
    4815           0 : }
    4816             : 
    4817           0 : const char *NoDuplicateAttr::getSpelling() const {
    4818           0 :   switch (SpellingListIndex) {
    4819           0 :   default:
    4820           0 :     llvm_unreachable("Unknown attribute spelling!");
    4821             :     return "(No spelling)";
    4822             :   case 0:
    4823             :     return "noduplicate";
    4824             :   case 1:
    4825             :     return "noduplicate";
    4826             :   case 2:
    4827             :     return "noduplicate";
    4828             :   }
    4829             : }
    4830             : 
    4831           0 : NoEscapeAttr *NoEscapeAttr::clone(ASTContext &C) const {
    4832             :   auto *A = new (C) NoEscapeAttr(getLocation(), C, getSpellingListIndex());
    4833           0 :   A->Inherited = Inherited;
    4834           0 :   A->IsPackExpansion = IsPackExpansion;
    4835           0 :   A->Implicit = Implicit;
    4836           0 :   return A;
    4837             : }
    4838             : 
    4839           0 : void NoEscapeAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    4840           0 :   switch (SpellingListIndex) {
    4841           0 :   default:
    4842           0 :     llvm_unreachable("Unknown attribute spelling!");
    4843             :     break;
    4844           0 :   case 0 : {
    4845           0 :     OS << " __attribute__((noescape))";
    4846           0 :     break;
    4847             :   }
    4848           0 :   case 1 : {
    4849           0 :     OS << " [[clang::noescape]]";
    4850           0 :     break;
    4851             :   }
    4852           0 :   case 2 : {
    4853           0 :     OS << " [[clang::noescape]]";
    4854           0 :     break;
    4855             :   }
    4856             : }
    4857           0 : }
    4858             : 
    4859           0 : const char *NoEscapeAttr::getSpelling() const {
    4860           0 :   switch (SpellingListIndex) {
    4861           0 :   default:
    4862           0 :     llvm_unreachable("Unknown attribute spelling!");
    4863             :     return "(No spelling)";
    4864             :   case 0:
    4865             :     return "noescape";
    4866             :   case 1:
    4867             :     return "noescape";
    4868             :   case 2:
    4869             :     return "noescape";
    4870             :   }
    4871             : }
    4872             : 
    4873         103 : NoInlineAttr *NoInlineAttr::clone(ASTContext &C) const {
    4874             :   auto *A = new (C) NoInlineAttr(getLocation(), C, getSpellingListIndex());
    4875         103 :   A->Inherited = Inherited;
    4876         103 :   A->IsPackExpansion = IsPackExpansion;
    4877         103 :   A->Implicit = Implicit;
    4878         103 :   return A;
    4879             : }
    4880             : 
    4881           1 : void NoInlineAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    4882           1 :   switch (SpellingListIndex) {
    4883           0 :   default:
    4884           0 :     llvm_unreachable("Unknown attribute spelling!");
    4885             :     break;
    4886           1 :   case 0 : {
    4887           1 :     OS << " __attribute__((noinline))";
    4888           1 :     break;
    4889             :   }
    4890           0 :   case 1 : {
    4891           0 :     OS << " [[gnu::noinline]]";
    4892           0 :     break;
    4893             :   }
    4894           0 :   case 2 : {
    4895           0 :     OS << " __declspec(noinline)";
    4896           0 :     break;
    4897             :   }
    4898             : }
    4899           1 : }
    4900             : 
    4901           0 : const char *NoInlineAttr::getSpelling() const {
    4902           0 :   switch (SpellingListIndex) {
    4903           0 :   default:
    4904           0 :     llvm_unreachable("Unknown attribute spelling!");
    4905             :     return "(No spelling)";
    4906             :   case 0:
    4907             :     return "noinline";
    4908             :   case 1:
    4909             :     return "noinline";
    4910             :   case 2:
    4911             :     return "noinline";
    4912             :   }
    4913             : }
    4914             : 
    4915           3 : NoInstrumentFunctionAttr *NoInstrumentFunctionAttr::clone(ASTContext &C) const {
    4916             :   auto *A = new (C) NoInstrumentFunctionAttr(getLocation(), C, getSpellingListIndex());
    4917           3 :   A->Inherited = Inherited;
    4918           3 :   A->IsPackExpansion = IsPackExpansion;
    4919           3 :   A->Implicit = Implicit;
    4920           3 :   return A;
    4921             : }
    4922             : 
    4923           0 : void NoInstrumentFunctionAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    4924           0 :   switch (SpellingListIndex) {
    4925           0 :   default:
    4926           0 :     llvm_unreachable("Unknown attribute spelling!");
    4927             :     break;
    4928           0 :   case 0 : {
    4929           0 :     OS << " __attribute__((no_instrument_function))";
    4930           0 :     break;
    4931             :   }
    4932           0 :   case 1 : {
    4933           0 :     OS << " [[gnu::no_instrument_function]]";
    4934           0 :     break;
    4935             :   }
    4936             : }
    4937           0 : }
    4938             : 
    4939           0 : const char *NoInstrumentFunctionAttr::getSpelling() const {
    4940           0 :   switch (SpellingListIndex) {
    4941           0 :   default:
    4942           0 :     llvm_unreachable("Unknown attribute spelling!");
    4943             :     return "(No spelling)";
    4944             :   case 0:
    4945             :     return "no_instrument_function";
    4946             :   case 1:
    4947             :     return "no_instrument_function";
    4948             :   }
    4949             : }
    4950             : 
    4951           0 : NoMicroMipsAttr *NoMicroMipsAttr::clone(ASTContext &C) const {
    4952             :   auto *A = new (C) NoMicroMipsAttr(getLocation(), C, getSpellingListIndex());
    4953           0 :   A->Inherited = Inherited;
    4954           0 :   A->IsPackExpansion = IsPackExpansion;
    4955           0 :   A->Implicit = Implicit;
    4956           0 :   return A;
    4957             : }
    4958             : 
    4959           0 : void NoMicroMipsAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    4960           0 :   switch (SpellingListIndex) {
    4961           0 :   default:
    4962           0 :     llvm_unreachable("Unknown attribute spelling!");
    4963             :     break;
    4964           0 :   case 0 : {
    4965           0 :     OS << " __attribute__((nomicromips))";
    4966           0 :     break;
    4967             :   }
    4968           0 :   case 1 : {
    4969           0 :     OS << " [[gnu::nomicromips]]";
    4970           0 :     break;
    4971             :   }
    4972             : }
    4973           0 : }
    4974             : 
    4975           0 : const char *NoMicroMipsAttr::getSpelling() const {
    4976           0 :   switch (SpellingListIndex) {
    4977           0 :   default:
    4978           0 :     llvm_unreachable("Unknown attribute spelling!");
    4979             :     return "(No spelling)";
    4980             :   case 0:
    4981             :     return "nomicromips";
    4982             :   case 1:
    4983             :     return "nomicromips";
    4984             :   }
    4985             : }
    4986             : 
    4987           2 : NoMips16Attr *NoMips16Attr::clone(ASTContext &C) const {
    4988             :   auto *A = new (C) NoMips16Attr(getLocation(), C, getSpellingListIndex());
    4989           2 :   A->Inherited = Inherited;
    4990           2 :   A->IsPackExpansion = IsPackExpansion;
    4991           2 :   A->Implicit = Implicit;
    4992           2 :   return A;
    4993             : }
    4994             : 
    4995           0 : void NoMips16Attr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    4996           0 :   switch (SpellingListIndex) {
    4997           0 :   default:
    4998           0 :     llvm_unreachable("Unknown attribute spelling!");
    4999             :     break;
    5000           0 :   case 0 : {
    5001           0 :     OS << " __attribute__((nomips16))";
    5002           0 :     break;
    5003             :   }
    5004           0 :   case 1 : {
    5005           0 :     OS << " [[gnu::nomips16]]";
    5006           0 :     break;
    5007             :   }
    5008             : }
    5009           0 : }
    5010             : 
    5011           0 : const char *NoMips16Attr::getSpelling() const {
    5012           0 :   switch (SpellingListIndex) {
    5013           0 :   default:
    5014           0 :     llvm_unreachable("Unknown attribute spelling!");
    5015             :     return "(No spelling)";
    5016             :   case 0:
    5017             :     return "nomips16";
    5018             :   case 1:
    5019             :     return "nomips16";
    5020             :   }
    5021             : }
    5022             : 
    5023           0 : NoReturnAttr *NoReturnAttr::clone(ASTContext &C) const {
    5024             :   auto *A = new (C) NoReturnAttr(getLocation(), C, getSpellingListIndex());
    5025           0 :   A->Inherited = Inherited;
    5026           0 :   A->IsPackExpansion = IsPackExpansion;
    5027           0 :   A->Implicit = Implicit;
    5028           0 :   return A;
    5029             : }
    5030             : 
    5031           0 : void NoReturnAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    5032           0 :   switch (SpellingListIndex) {
    5033           0 :   default:
    5034           0 :     llvm_unreachable("Unknown attribute spelling!");
    5035             :     break;
    5036           0 :   case 0 : {
    5037           0 :     OS << " __attribute__((noreturn))";
    5038           0 :     break;
    5039             :   }
    5040           0 :   case 1 : {
    5041           0 :     OS << " [[gnu::noreturn]]";
    5042           0 :     break;
    5043             :   }
    5044           0 :   case 2 : {
    5045           0 :     OS << " __declspec(noreturn)";
    5046           0 :     break;
    5047             :   }
    5048             : }
    5049           0 : }
    5050             : 
    5051           0 : const char *NoReturnAttr::getSpelling() const {
    5052           0 :   switch (SpellingListIndex) {
    5053           0 :   default:
    5054           0 :     llvm_unreachable("Unknown attribute spelling!");
    5055             :     return "(No spelling)";
    5056             :   case 0:
    5057             :     return "noreturn";
    5058             :   case 1:
    5059             :     return "noreturn";
    5060             :   case 2:
    5061             :     return "noreturn";
    5062             :   }
    5063             : }
    5064             : 
    5065          33 : NoSanitizeAttr *NoSanitizeAttr::clone(ASTContext &C) const {
    5066          33 :   auto *A = new (C) NoSanitizeAttr(getLocation(), C, sanitizers_, sanitizers_Size, getSpellingListIndex());
    5067          33 :   A->Inherited = Inherited;
    5068          33 :   A->IsPackExpansion = IsPackExpansion;
    5069          33 :   A->Implicit = Implicit;
    5070          33 :   return A;
    5071             : }
    5072             : 
    5073           5 : void NoSanitizeAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    5074           5 :   switch (SpellingListIndex) {
    5075           0 :   default:
    5076           0 :     llvm_unreachable("Unknown attribute spelling!");
    5077             :     break;
    5078           3 :   case 0 : {
    5079           3 :     OS << " __attribute__((no_sanitize(";
    5080             :   bool isFirst = true;
    5081          13 :   for (const auto &Val : sanitizers()) {
    5082           5 :     if (isFirst) isFirst = false;
    5083           2 :     else OS << ", ";
    5084           5 :     OS << "\"" << Val << "\"";
    5085             :   }
    5086           3 :   OS << ")))";
    5087           3 :     break;
    5088             :   }
    5089           2 :   case 1 : {
    5090           2 :     OS << " [[clang::no_sanitize(";
    5091             :   bool isFirst = true;
    5092           6 :   for (const auto &Val : sanitizers()) {
    5093           2 :     if (isFirst) isFirst = false;
    5094           0 :     else OS << ", ";
    5095           2 :     OS << "\"" << Val << "\"";
    5096             :   }
    5097           2 :   OS << ")]]";
    5098           2 :     break;
    5099             :   }
    5100           0 :   case 2 : {
    5101           0 :     OS << " [[clang::no_sanitize(";
    5102             :   bool isFirst = true;
    5103           0 :   for (const auto &Val : sanitizers()) {
    5104           0 :     if (isFirst) isFirst = false;
    5105           0 :     else OS << ", ";
    5106           0 :     OS << "\"" << Val << "\"";
    5107             :   }
    5108           0 :   OS << ")]]";
    5109           0 :     break;
    5110             :   }
    5111             : }
    5112           5 : }
    5113             : 
    5114           0 : const char *NoSanitizeAttr::getSpelling() const {
    5115           0 :   switch (SpellingListIndex) {
    5116           0 :   default:
    5117           0 :     llvm_unreachable("Unknown attribute spelling!");
    5118             :     return "(No spelling)";
    5119             :   case 0:
    5120             :     return "no_sanitize";
    5121             :   case 1:
    5122             :     return "no_sanitize";
    5123             :   case 2:
    5124             :     return "no_sanitize";
    5125             :   }
    5126             : }
    5127             : 
    5128           2 : NoSplitStackAttr *NoSplitStackAttr::clone(ASTContext &C) const {
    5129             :   auto *A = new (C) NoSplitStackAttr(getLocation(), C, getSpellingListIndex());
    5130           2 :   A->Inherited = Inherited;
    5131           2 :   A->IsPackExpansion = IsPackExpansion;
    5132           2 :   A->Implicit = Implicit;
    5133           2 :   return A;
    5134             : }
    5135             : 
    5136           0 : void NoSplitStackAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    5137           0 :   switch (SpellingListIndex) {
    5138           0 :   default:
    5139           0 :     llvm_unreachable("Unknown attribute spelling!");
    5140             :     break;
    5141           0 :   case 0 : {
    5142           0 :     OS << " __attribute__((no_split_stack))";
    5143           0 :     break;
    5144             :   }
    5145           0 :   case 1 : {
    5146           0 :     OS << " [[gnu::no_split_stack]]";
    5147           0 :     break;
    5148             :   }
    5149             : }
    5150           0 : }
    5151             : 
    5152           0 : const char *NoSplitStackAttr::getSpelling() const {
    5153           0 :   switch (SpellingListIndex) {
    5154           0 :   default:
    5155           0 :     llvm_unreachable("Unknown attribute spelling!");
    5156             :     return "(No spelling)";
    5157             :   case 0:
    5158             :     return "no_split_stack";
    5159             :   case 1:
    5160             :     return "no_split_stack";
    5161             :   }
    5162             : }
    5163             : 
    5164           0 : NoStackProtectorAttr *NoStackProtectorAttr::clone(ASTContext &C) const {
    5165             :   auto *A = new (C) NoStackProtectorAttr(getLocation(), C, getSpellingListIndex());
    5166           0 :   A->Inherited = Inherited;
    5167           0 :   A->IsPackExpansion = IsPackExpansion;
    5168           0 :   A->Implicit = Implicit;
    5169           0 :   return A;
    5170             : }
    5171             : 
    5172           0 : void NoStackProtectorAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    5173           0 :   switch (SpellingListIndex) {
    5174           0 :   default:
    5175           0 :     llvm_unreachable("Unknown attribute spelling!");
    5176             :     break;
    5177           0 :   case 0 : {
    5178           0 :     OS << " __attribute__((no_stack_protector))";
    5179           0 :     break;
    5180             :   }
    5181           0 :   case 1 : {
    5182           0 :     OS << " [[clang::no_stack_protector]]";
    5183           0 :     break;
    5184             :   }
    5185           0 :   case 2 : {
    5186           0 :     OS << " [[clang::no_stack_protector]]";
    5187           0 :     break;
    5188             :   }
    5189             : }
    5190           0 : }
    5191             : 
    5192           0 : const char *NoStackProtectorAttr::getSpelling() const {
    5193           0 :   switch (SpellingListIndex) {
    5194           0 :   default:
    5195           0 :     llvm_unreachable("Unknown attribute spelling!");
    5196             :     return "(No spelling)";
    5197             :   case 0:
    5198             :     return "no_stack_protector";
    5199             :   case 1:
    5200             :     return "no_stack_protector";
    5201             :   case 2:
    5202             :     return "no_stack_protector";
    5203             :   }
    5204             : }
    5205             : 
    5206          27 : NoThreadSafetyAnalysisAttr *NoThreadSafetyAnalysisAttr::clone(ASTContext &C) const {
    5207             :   auto *A = new (C) NoThreadSafetyAnalysisAttr(getLocation(), C, getSpellingListIndex());
    5208          27 :   A->Inherited = Inherited;
    5209          27 :   A->IsPackExpansion = IsPackExpansion;
    5210          27 :   A->Implicit = Implicit;
    5211          27 :   return A;
    5212             : }
    5213             : 
    5214           0 : void NoThreadSafetyAnalysisAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    5215           0 :   switch (SpellingListIndex) {
    5216           0 :   default:
    5217           0 :     llvm_unreachable("Unknown attribute spelling!");
    5218             :     break;
    5219           0 :   case 0 : {
    5220           0 :     OS << " __attribute__((no_thread_safety_analysis))";
    5221           0 :     break;
    5222             :   }
    5223           0 :   case 1 : {
    5224           0 :     OS << " [[clang::no_thread_safety_analysis]]";
    5225           0 :     break;
    5226             :   }
    5227           0 :   case 2 : {
    5228           0 :     OS << " [[clang::no_thread_safety_analysis]]";
    5229           0 :     break;
    5230             :   }
    5231             : }
    5232           0 : }
    5233             : 
    5234           0 : const char *NoThreadSafetyAnalysisAttr::getSpelling() const {
    5235           0 :   switch (SpellingListIndex) {
    5236           0 :   default:
    5237           0 :     llvm_unreachable("Unknown attribute spelling!");
    5238             :     return "(No spelling)";
    5239             :   case 0:
    5240             :     return "no_thread_safety_analysis";
    5241             :   case 1:
    5242             :     return "no_thread_safety_analysis";
    5243             :   case 2:
    5244             :     return "no_thread_safety_analysis";
    5245             :   }
    5246             : }
    5247             : 
    5248        2059 : NoThrowAttr *NoThrowAttr::clone(ASTContext &C) const {
    5249             :   auto *A = new (C) NoThrowAttr(getLocation(), C, getSpellingListIndex());
    5250        2059 :   A->Inherited = Inherited;
    5251        2059 :   A->IsPackExpansion = IsPackExpansion;
    5252        2059 :   A->Implicit = Implicit;
    5253        2059 :   return A;
    5254             : }
    5255             : 
    5256           0 : void NoThrowAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    5257           0 :   switch (SpellingListIndex) {
    5258           0 :   default:
    5259           0 :     llvm_unreachable("Unknown attribute spelling!");
    5260             :     break;
    5261           0 :   case 0 : {
    5262           0 :     OS << " __attribute__((nothrow))";
    5263           0 :     break;
    5264             :   }
    5265           0 :   case 1 : {
    5266           0 :     OS << " [[gnu::nothrow]]";
    5267           0 :     break;
    5268             :   }
    5269           0 :   case 2 : {
    5270           0 :     OS << " __declspec(nothrow)";
    5271           0 :     break;
    5272             :   }
    5273             : }
    5274           0 : }
    5275             : 
    5276           0 : const char *NoThrowAttr::getSpelling() const {
    5277           0 :   switch (SpellingListIndex) {
    5278           0 :   default:
    5279           0 :     llvm_unreachable("Unknown attribute spelling!");
    5280             :     return "(No spelling)";
    5281             :   case 0:
    5282             :     return "nothrow";
    5283             :   case 1:
    5284             :     return "nothrow";
    5285             :   case 2:
    5286             :     return "nothrow";
    5287             :   }
    5288             : }
    5289             : 
    5290        1483 : NonNullAttr *NonNullAttr::clone(ASTContext &C) const {
    5291        1483 :   auto *A = new (C) NonNullAttr(getLocation(), C, args_, args_Size, getSpellingListIndex());
    5292        1483 :   A->Inherited = Inherited;
    5293        1483 :   A->IsPackExpansion = IsPackExpansion;
    5294        1483 :   A->Implicit = Implicit;
    5295        1483 :   return A;
    5296             : }
    5297             : 
    5298           4 : void NonNullAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    5299           4 :   switch (SpellingListIndex) {
    5300           0 :   default:
    5301           0 :     llvm_unreachable("Unknown attribute spelling!");
    5302             :     break;
    5303           4 :   case 0 : {
    5304           4 :     OS << " __attribute__((nonnull(";
    5305             :   bool isFirst = true;
    5306          20 :   for (const auto &Val : args()) {
    5307           8 :     if (isFirst) isFirst = false;
    5308           4 :     else OS << ", ";
    5309             :     OS << Val.getSourceIndex();
    5310             :   }
    5311           4 :   OS << ")))";
    5312           4 :     break;
    5313             :   }
    5314           0 :   case 1 : {
    5315           0 :     OS << " [[gnu::nonnull(";
    5316             :   bool isFirst = true;
    5317           0 :   for (const auto &Val : args()) {
    5318           0 :     if (isFirst) isFirst = false;
    5319           0 :     else OS << ", ";
    5320             :     OS << Val.getSourceIndex();
    5321             :   }
    5322           0 :   OS << ")]]";
    5323           0 :     break;
    5324             :   }
    5325             : }
    5326           4 : }
    5327             : 
    5328           0 : const char *NonNullAttr::getSpelling() const {
    5329           0 :   switch (SpellingListIndex) {
    5330           0 :   default:
    5331           0 :     llvm_unreachable("Unknown attribute spelling!");
    5332             :     return "(No spelling)";
    5333             :   case 0:
    5334             :     return "nonnull";
    5335             :   case 1:
    5336             :     return "nonnull";
    5337             :   }
    5338             : }
    5339             : 
    5340           0 : NotTailCalledAttr *NotTailCalledAttr::clone(ASTContext &C) const {
    5341             :   auto *A = new (C) NotTailCalledAttr(getLocation(), C, getSpellingListIndex());
    5342           0 :   A->Inherited = Inherited;
    5343           0 :   A->IsPackExpansion = IsPackExpansion;
    5344           0 :   A->Implicit = Implicit;
    5345           0 :   return A;
    5346             : }
    5347             : 
    5348           0 : void NotTailCalledAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    5349           0 :   switch (SpellingListIndex) {
    5350           0 :   default:
    5351           0 :     llvm_unreachable("Unknown attribute spelling!");
    5352             :     break;
    5353           0 :   case 0 : {
    5354           0 :     OS << " __attribute__((not_tail_called))";
    5355           0 :     break;
    5356             :   }
    5357           0 :   case 1 : {
    5358           0 :     OS << " [[clang::not_tail_called]]";
    5359           0 :     break;
    5360             :   }
    5361           0 :   case 2 : {
    5362           0 :     OS << " [[clang::not_tail_called]]";
    5363           0 :     break;
    5364             :   }
    5365             : }
    5366           0 : }
    5367             : 
    5368           3 : const char *NotTailCalledAttr::getSpelling() const {
    5369           3 :   switch (SpellingListIndex) {
    5370           0 :   default:
    5371           0 :     llvm_unreachable("Unknown attribute spelling!");
    5372             :     return "(No spelling)";
    5373             :   case 0:
    5374             :     return "not_tail_called";
    5375             :   case 1:
    5376             :     return "not_tail_called";
    5377             :   case 2:
    5378             :     return "not_tail_called";
    5379             :   }
    5380             : }
    5381             : 
    5382           0 : OMPCaptureKindAttr *OMPCaptureKindAttr::clone(ASTContext &C) const {
    5383           0 :   auto *A = new (C) OMPCaptureKindAttr(getLocation(), C, captureKind, getSpellingListIndex());
    5384           0 :   A->Inherited = Inherited;
    5385           0 :   A->IsPackExpansion = IsPackExpansion;
    5386           0 :   A->Implicit = Implicit;
    5387           0 :   return A;
    5388             : }
    5389             : 
    5390           0 : void OMPCaptureKindAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    5391           0 : }
    5392             : 
    5393           0 : const char *OMPCaptureKindAttr::getSpelling() const {
    5394           0 :   return "(No spelling)";
    5395             : }
    5396             : 
    5397           0 : OMPCaptureNoInitAttr *OMPCaptureNoInitAttr::clone(ASTContext &C) const {
    5398             :   auto *A = new (C) OMPCaptureNoInitAttr(getLocation(), C, getSpellingListIndex());
    5399           0 :   A->Inherited = Inherited;
    5400           0 :   A->IsPackExpansion = IsPackExpansion;
    5401           0 :   A->Implicit = Implicit;
    5402           0 :   return A;
    5403             : }
    5404             : 
    5405           0 : void OMPCaptureNoInitAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    5406           0 : }
    5407             : 
    5408           0 : const char *OMPCaptureNoInitAttr::getSpelling() const {
    5409           0 :   return "(No spelling)";
    5410             : }
    5411             : 
    5412           0 : OMPDeclareSimdDeclAttr *OMPDeclareSimdDeclAttr::clone(ASTContext &C) const {
    5413           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());
    5414           0 :   A->Inherited = Inherited;
    5415           0 :   A->IsPackExpansion = IsPackExpansion;
    5416           0 :   A->Implicit = Implicit;
    5417           0 :   return A;
    5418             : }
    5419             : 
    5420          92 : void OMPDeclareSimdDeclAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    5421          92 :   switch (SpellingListIndex) {
    5422           0 :   default:
    5423           0 :     llvm_unreachable("Unknown attribute spelling!");
    5424             :     break;
    5425          92 :   case 0 : {
    5426          92 :     OS << "#pragma omp declare simd";
    5427          92 :     printPrettyPragma(OS, Policy);
    5428          92 :     OS << "\n";    break;
    5429             :   }
    5430             : }
    5431          92 : }
    5432             : 
    5433           0 : const char *OMPDeclareSimdDeclAttr::getSpelling() const {
    5434           0 :   switch (SpellingListIndex) {
    5435           0 :   default:
    5436           0 :     llvm_unreachable("Unknown attribute spelling!");
    5437             :     return "(No spelling)";
    5438           0 :   case 0:
    5439             :     return "declare simd";
    5440             :   }
    5441             : }
    5442             : 
    5443          16 : OMPDeclareTargetDeclAttr *OMPDeclareTargetDeclAttr::clone(ASTContext &C) const {
    5444          16 :   auto *A = new (C) OMPDeclareTargetDeclAttr(getLocation(), C, mapType, getSpellingListIndex());
    5445          16 :   A->Inherited = Inherited;
    5446          16 :   A->IsPackExpansion = IsPackExpansion;
    5447          16 :   A->Implicit = Implicit;
    5448          16 :   return A;
    5449             : }
    5450             : 
    5451          92 : void OMPDeclareTargetDeclAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    5452          92 :   switch (SpellingListIndex) {
    5453           0 :   default:
    5454           0 :     llvm_unreachable("Unknown attribute spelling!");
    5455             :     break;
    5456          92 :   case 0 : {
    5457          92 :     OS << "#pragma omp declare target";
    5458          92 :     printPrettyPragma(OS, Policy);
    5459          92 :     OS << "\n";    break;
    5460             :   }
    5461             : }
    5462          92 : }
    5463             : 
    5464           0 : const char *OMPDeclareTargetDeclAttr::getSpelling() const {
    5465           0 :   switch (SpellingListIndex) {
    5466           0 :   default:
    5467           0 :     llvm_unreachable("Unknown attribute spelling!");
    5468             :     return "(No spelling)";
    5469           0 :   case 0:
    5470             :     return "declare target";
    5471             :   }
    5472             : }
    5473             : 
    5474           0 : OMPReferencedVarAttr *OMPReferencedVarAttr::clone(ASTContext &C) const {
    5475           0 :   auto *A = new (C) OMPReferencedVarAttr(getLocation(), C, ref, getSpellingListIndex());
    5476           0 :   A->Inherited = Inherited;
    5477           0 :   A->IsPackExpansion = IsPackExpansion;
    5478           0 :   A->Implicit = Implicit;
    5479           0 :   return A;
    5480             : }
    5481             : 
    5482           0 : void OMPReferencedVarAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    5483           0 : }
    5484             : 
    5485           0 : const char *OMPReferencedVarAttr::getSpelling() const {
    5486           0 :   return "(No spelling)";
    5487             : }
    5488             : 
    5489          44 : OMPThreadPrivateDeclAttr *OMPThreadPrivateDeclAttr::clone(ASTContext &C) const {
    5490             :   auto *A = new (C) OMPThreadPrivateDeclAttr(getLocation(), C, getSpellingListIndex());
    5491          44 :   A->Inherited = Inherited;
    5492          44 :   A->IsPackExpansion = IsPackExpansion;
    5493          44 :   A->Implicit = Implicit;
    5494          44 :   return A;
    5495             : }
    5496             : 
    5497           0 : void OMPThreadPrivateDeclAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    5498           0 : }
    5499             : 
    5500           0 : const char *OMPThreadPrivateDeclAttr::getSpelling() const {
    5501           0 :   return "(No spelling)";
    5502             : }
    5503             : 
    5504           0 : ObjCBoxableAttr *ObjCBoxableAttr::clone(ASTContext &C) const {
    5505             :   auto *A = new (C) ObjCBoxableAttr(getLocation(), C, getSpellingListIndex());
    5506           0 :   A->Inherited = Inherited;
    5507           0 :   A->IsPackExpansion = IsPackExpansion;
    5508           0 :   A->Implicit = Implicit;
    5509           0 :   return A;
    5510             : }
    5511             : 
    5512           0 : void ObjCBoxableAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    5513           0 :   switch (SpellingListIndex) {
    5514           0 :   default:
    5515           0 :     llvm_unreachable("Unknown attribute spelling!");
    5516             :     break;
    5517           0 :   case 0 : {
    5518           0 :     OS << " __attribute__((objc_boxable))";
    5519           0 :     break;
    5520             :   }
    5521           0 :   case 1 : {
    5522           0 :     OS << " [[clang::objc_boxable]]";
    5523           0 :     break;
    5524             :   }
    5525           0 :   case 2 : {
    5526           0 :     OS << " [[clang::objc_boxable]]";
    5527           0 :     break;
    5528             :   }
    5529             : }
    5530           0 : }
    5531             : 
    5532           0 : const char *ObjCBoxableAttr::getSpelling() const {
    5533           0 :   switch (SpellingListIndex) {
    5534           0 :   default:
    5535           0 :     llvm_unreachable("Unknown attribute spelling!");
    5536             :     return "(No spelling)";
    5537             :   case 0:
    5538             :     return "objc_boxable";
    5539             :   case 1:
    5540             :     return "objc_boxable";
    5541             :   case 2:
    5542             :     return "objc_boxable";
    5543             :   }
    5544             : }
    5545             : 
    5546           4 : ObjCBridgeAttr *ObjCBridgeAttr::clone(ASTContext &C) const {
    5547           4 :   auto *A = new (C) ObjCBridgeAttr(getLocation(), C, bridgedType, getSpellingListIndex());
    5548           4 :   A->Inherited = Inherited;
    5549           4 :   A->IsPackExpansion = IsPackExpansion;
    5550           4 :   A->Implicit = Implicit;
    5551           4 :   return A;
    5552             : }
    5553             : 
    5554           0 : void ObjCBridgeAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    5555           0 :   switch (SpellingListIndex) {
    5556           0 :   default:
    5557           0 :     llvm_unreachable("Unknown attribute spelling!");
    5558             :     break;
    5559           0 :   case 0 : {
    5560           0 :     OS << " __attribute__((objc_bridge(" << (getBridgedType() ? getBridgedType()->getName() : "") << ")))";
    5561           0 :     break;
    5562             :   }
    5563           0 :   case 1 : {
    5564           0 :     OS << " [[clang::objc_bridge(" << (getBridgedType() ? getBridgedType()->getName() : "") << ")]]";
    5565           0 :     break;
    5566             :   }
    5567           0 :   case 2 : {
    5568           0 :     OS << " [[clang::objc_bridge(" << (getBridgedType() ? getBridgedType()->getName() : "") << ")]]";
    5569           0 :     break;
    5570             :   }
    5571             : }
    5572           0 : }
    5573             : 
    5574           0 : const char *ObjCBridgeAttr::getSpelling() const {
    5575           0 :   switch (SpellingListIndex) {
    5576           0 :   default:
    5577           0 :     llvm_unreachable("Unknown attribute spelling!");
    5578             :     return "(No spelling)";
    5579             :   case 0:
    5580             :     return "objc_bridge";
    5581             :   case 1:
    5582             :     return "objc_bridge";
    5583             :   case 2:
    5584             :     return "objc_bridge";
    5585             :   }
    5586             : }
    5587             : 
    5588           1 : ObjCBridgeMutableAttr *ObjCBridgeMutableAttr::clone(ASTContext &C) const {
    5589           1 :   auto *A = new (C) ObjCBridgeMutableAttr(getLocation(), C, bridgedType, getSpellingListIndex());
    5590           1 :   A->Inherited = Inherited;
    5591           1 :   A->IsPackExpansion = IsPackExpansion;
    5592           1 :   A->Implicit = Implicit;
    5593           1 :   return A;
    5594             : }
    5595             : 
    5596           0 : void ObjCBridgeMutableAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    5597           0 :   switch (SpellingListIndex) {
    5598           0 :   default:
    5599           0 :     llvm_unreachable("Unknown attribute spelling!");
    5600             :     break;
    5601           0 :   case 0 : {
    5602           0 :     OS << " __attribute__((objc_bridge_mutable(" << (getBridgedType() ? getBridgedType()->getName() : "") << ")))";
    5603           0 :     break;
    5604             :   }
    5605           0 :   case 1 : {
    5606           0 :     OS << " [[clang::objc_bridge_mutable(" << (getBridgedType() ? getBridgedType()->getName() : "") << ")]]";
    5607           0 :     break;
    5608             :   }
    5609           0 :   case 2 : {
    5610           0 :     OS << " [[clang::objc_bridge_mutable(" << (getBridgedType() ? getBridgedType()->getName() : "") << ")]]";
    5611           0 :     break;
    5612             :   }
    5613             : }
    5614           0 : }
    5615             : 
    5616           0 : const char *ObjCBridgeMutableAttr::getSpelling() const {
    5617           0 :   switch (SpellingListIndex) {
    5618           0 :   default:
    5619           0 :     llvm_unreachable("Unknown attribute spelling!");
    5620             :     return "(No spelling)";
    5621             :   case 0:
    5622             :     return "objc_bridge_mutable";
    5623             :   case 1:
    5624             :     return "objc_bridge_mutable";
    5625             :   case 2:
    5626             :     return "objc_bridge_mutable";
    5627             :   }
    5628             : }
    5629             : 
    5630           0 : ObjCBridgeRelatedAttr *ObjCBridgeRelatedAttr::clone(ASTContext &C) const {
    5631           0 :   auto *A = new (C) ObjCBridgeRelatedAttr(getLocation(), C, relatedClass, classMethod, instanceMethod, getSpellingListIndex());
    5632           0 :   A->Inherited = Inherited;
    5633           0 :   A->IsPackExpansion = IsPackExpansion;
    5634           0 :   A->Implicit = Implicit;
    5635           0 :   return A;
    5636             : }
    5637             : 
    5638           1 : void ObjCBridgeRelatedAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    5639           1 :   switch (SpellingListIndex) {
    5640           0 :   default:
    5641           0 :     llvm_unreachable("Unknown attribute spelling!");
    5642             :     break;
    5643           1 :   case 0 : {
    5644           3 :     OS << " __attribute__((objc_bridge_related(" << (getRelatedClass() ? getRelatedClass()->getName() : "") << ", " << (getClassMethod() ? getClassMethod()->getName() : "") << ", " << (getInstanceMethod() ? getInstanceMethod()->getName() : "") << ")))";
    5645           1 :     break;
    5646             :   }
    5647           0 :   case 1 : {
    5648           0 :     OS << " [[clang::objc_bridge_related(" << (getRelatedClass() ? getRelatedClass()->getName() : "") << ", " << (getClassMethod() ? getClassMethod()->getName() : "") << ", " << (getInstanceMethod() ? getInstanceMethod()->getName() : "") << ")]]";
    5649           0 :     break;
    5650             :   }
    5651           0 :   case 2 : {
    5652           0 :     OS << " [[clang::objc_bridge_related(" << (getRelatedClass() ? getRelatedClass()->getName() : "") << ", " << (getClassMethod() ? getClassMethod()->getName() : "") << ", " << (getInstanceMethod() ? getInstanceMethod()->getName() : "") << ")]]";
    5653           0 :     break;
    5654             :   }
    5655             : }
    5656           1 : }
    5657             : 
    5658           0 : const char *ObjCBridgeRelatedAttr::getSpelling() const {
    5659           0 :   switch (SpellingListIndex) {
    5660           0 :   default:
    5661           0 :     llvm_unreachable("Unknown attribute spelling!");
    5662             :     return "(No spelling)";
    5663             :   case 0:
    5664             :     return "objc_bridge_related";
    5665             :   case 1:
    5666             :     return "objc_bridge_related";
    5667             :   case 2:
    5668             :     return "objc_bridge_related";
    5669             :   }
    5670             : }
    5671             : 
    5672           0 : ObjCDesignatedInitializerAttr *ObjCDesignatedInitializerAttr::clone(ASTContext &C) const {
    5673             :   auto *A = new (C) ObjCDesignatedInitializerAttr(getLocation(), C, getSpellingListIndex());
    5674           0 :   A->Inherited = Inherited;
    5675           0 :   A->IsPackExpansion = IsPackExpansion;
    5676           0 :   A->Implicit = Implicit;
    5677           0 :   return A;
    5678             : }
    5679             : 
    5680           0 : void ObjCDesignatedInitializerAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    5681           0 :   switch (SpellingListIndex) {
    5682           0 :   default:
    5683           0 :     llvm_unreachable("Unknown attribute spelling!");
    5684             :     break;
    5685           0 :   case 0 : {
    5686           0 :     OS << " __attribute__((objc_designated_initializer))";
    5687           0 :     break;
    5688             :   }
    5689           0 :   case 1 : {
    5690           0 :     OS << " [[clang::objc_designated_initializer]]";
    5691           0 :     break;
    5692             :   }
    5693           0 :   case 2 : {
    5694           0 :     OS << " [[clang::objc_designated_initializer]]";
    5695           0 :     break;
    5696             :   }
    5697             : }
    5698           0 : }
    5699             : 
    5700           0 : const char *ObjCDesignatedInitializerAttr::getSpelling() const {
    5701           0 :   switch (SpellingListIndex) {
    5702           0 :   default:
    5703           0 :     llvm_unreachable("Unknown attribute spelling!");
    5704             :     return "(No spelling)";
    5705             :   case 0:
    5706             :     return "objc_designated_initializer";
    5707             :   case 1:
    5708             :     return "objc_designated_initializer";
    5709             :   case 2:
    5710             :     return "objc_designated_initializer";
    5711             :   }
    5712             : }
    5713             : 
    5714           0 : ObjCExceptionAttr *ObjCExceptionAttr::clone(ASTContext &C) const {
    5715             :   auto *A = new (C) ObjCExceptionAttr(getLocation(), C, getSpellingListIndex());
    5716           0 :   A->Inherited = Inherited;
    5717           0 :   A->IsPackExpansion = IsPackExpansion;
    5718           0 :   A->Implicit = Implicit;
    5719           0 :   return A;
    5720             : }
    5721             : 
    5722           0 : void ObjCExceptionAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    5723           0 :   switch (SpellingListIndex) {
    5724           0 :   default:
    5725           0 :     llvm_unreachable("Unknown attribute spelling!");
    5726             :     break;
    5727           0 :   case 0 : {
    5728           0 :     OS << " __attribute__((objc_exception))";
    5729           0 :     break;
    5730             :   }
    5731           0 :   case 1 : {
    5732           0 :     OS << " [[clang::objc_exception]]";
    5733           0 :     break;
    5734             :   }
    5735           0 :   case 2 : {
    5736           0 :     OS << " [[clang::objc_exception]]";
    5737           0 :     break;
    5738             :   }
    5739             : }
    5740           0 : }
    5741             : 
    5742           0 : const char *ObjCExceptionAttr::getSpelling() const {
    5743           0 :   switch (SpellingListIndex) {
    5744           0 :   default:
    5745           0 :     llvm_unreachable("Unknown attribute spelling!");
    5746             :     return "(No spelling)";
    5747             :   case 0:
    5748             :     return "objc_exception";
    5749             :   case 1:
    5750             :     return "objc_exception";
    5751             :   case 2:
    5752             :     return "objc_exception";
    5753             :   }
    5754             : }
    5755             : 
    5756           0 : ObjCExplicitProtocolImplAttr *ObjCExplicitProtocolImplAttr::clone(ASTContext &C) const {
    5757             :   auto *A = new (C) ObjCExplicitProtocolImplAttr(getLocation(), C, getSpellingListIndex());
    5758           0 :   A->Inherited = Inherited;
    5759           0 :   A->IsPackExpansion = IsPackExpansion;
    5760           0 :   A->Implicit = Implicit;
    5761           0 :   return A;
    5762             : }
    5763             : 
    5764           0 : void ObjCExplicitProtocolImplAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    5765           0 :   switch (SpellingListIndex) {
    5766           0 :   default:
    5767           0 :     llvm_unreachable("Unknown attribute spelling!");
    5768             :     break;
    5769           0 :   case 0 : {
    5770           0 :     OS << " __attribute__((objc_protocol_requires_explicit_implementation))";
    5771           0 :     break;
    5772             :   }
    5773           0 :   case 1 : {
    5774           0 :     OS << " [[clang::objc_protocol_requires_explicit_implementation]]";
    5775           0 :     break;
    5776             :   }
    5777           0 :   case 2 : {
    5778           0 :     OS << " [[clang::objc_protocol_requires_explicit_implementation]]";
    5779           0 :     break;
    5780             :   }
    5781             : }
    5782           0 : }
    5783             : 
    5784           0 : const char *ObjCExplicitProtocolImplAttr::getSpelling() const {
    5785           0 :   switch (SpellingListIndex) {
    5786           0 :   default:
    5787           0 :     llvm_unreachable("Unknown attribute spelling!");
    5788             :     return "(No spelling)";
    5789             :   case 0:
    5790             :     return "objc_protocol_requires_explicit_implementation";
    5791             :   case 1:
    5792             :     return "objc_protocol_requires_explicit_implementation";
    5793             :   case 2:
    5794             :     return "objc_protocol_requires_explicit_implementation";
    5795             :   }
    5796             : }
    5797             : 
    5798           0 : ObjCIndependentClassAttr *ObjCIndependentClassAttr::clone(ASTContext &C) const {
    5799             :   auto *A = new (C) ObjCIndependentClassAttr(getLocation(), C, getSpellingListIndex());
    5800           0 :   A->Inherited = Inherited;
    5801           0 :   A->IsPackExpansion = IsPackExpansion;
    5802           0 :   A->Implicit = Implicit;
    5803           0 :   return A;
    5804             : }
    5805             : 
    5806           0 : void ObjCIndependentClassAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    5807           0 :   switch (SpellingListIndex) {
    5808           0 :   default:
    5809           0 :     llvm_unreachable("Unknown attribute spelling!");
    5810             :     break;
    5811           0 :   case 0 : {
    5812           0 :     OS << " __attribute__((objc_independent_class))";
    5813           0 :     break;
    5814             :   }
    5815           0 :   case 1 : {
    5816           0 :     OS << " [[clang::objc_independent_class]]";
    5817           0 :     break;
    5818             :   }
    5819           0 :   case 2 : {
    5820           0 :     OS << " [[clang::objc_independent_class]]";
    5821           0 :     break;
    5822             :   }
    5823             : }
    5824           0 : }
    5825             : 
    5826           0 : const char *ObjCIndependentClassAttr::getSpelling() const {
    5827           0 :   switch (SpellingListIndex) {
    5828           0 :   default:
    5829           0 :     llvm_unreachable("Unknown attribute spelling!");
    5830             :     return "(No spelling)";
    5831             :   case 0:
    5832             :     return "objc_independent_class";
    5833             :   case 1:
    5834             :     return "objc_independent_class";
    5835             :   case 2:
    5836             :     return "objc_independent_class";
    5837             :   }
    5838             : }
    5839             : 
    5840           9 : ObjCMethodFamilyAttr *ObjCMethodFamilyAttr::clone(ASTContext &C) const {
    5841           9 :   auto *A = new (C) ObjCMethodFamilyAttr(getLocation(), C, family, getSpellingListIndex());
    5842           9 :   A->Inherited = Inherited;
    5843           9 :   A->IsPackExpansion = IsPackExpansion;
    5844           9 :   A->Implicit = Implicit;
    5845           9 :   return A;
    5846             : }
    5847             : 
    5848           0 : void ObjCMethodFamilyAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    5849           0 :   switch (SpellingListIndex) {
    5850           0 :   default:
    5851           0 :     llvm_unreachable("Unknown attribute spelling!");
    5852             :     break;
    5853           0 :   case 0 : {
    5854           0 :     OS << " __attribute__((objc_method_family(\"" << ObjCMethodFamilyAttr::ConvertFamilyKindToStr(getFamily()) << "\")))";
    5855           0 :     break;
    5856             :   }
    5857           0 :   case 1 : {
    5858           0 :     OS << " [[clang::objc_method_family(\"" << ObjCMethodFamilyAttr::ConvertFamilyKindToStr(getFamily()) << "\")]]";
    5859           0 :     break;
    5860             :   }
    5861           0 :   case 2 : {
    5862           0 :     OS << " [[clang::objc_method_family(\"" << ObjCMethodFamilyAttr::ConvertFamilyKindToStr(getFamily()) << "\")]]";
    5863           0 :     break;
    5864             :   }
    5865             : }
    5866           0 : }
    5867             : 
    5868           0 : const char *ObjCMethodFamilyAttr::getSpelling() const {
    5869           0 :   switch (SpellingListIndex) {
    5870           0 :   default:
    5871           0 :     llvm_unreachable("Unknown attribute spelling!");
    5872             :     return "(No spelling)";
    5873             :   case 0:
    5874             :     return "objc_method_family";
    5875             :   case 1:
    5876             :     return "objc_method_family";
    5877             :   case 2:
    5878             :     return "objc_method_family";
    5879             :   }
    5880             : }
    5881             : 
    5882           0 : ObjCNSObjectAttr *ObjCNSObjectAttr::clone(ASTContext &C) const {
    5883             :   auto *A = new (C) ObjCNSObjectAttr(getLocation(), C, getSpellingListIndex());
    5884           0 :   A->Inherited = Inherited;
    5885           0 :   A->IsPackExpansion = IsPackExpansion;
    5886           0 :   A->Implicit = Implicit;
    5887           0 :   return A;
    5888             : }
    5889             : 
    5890           0 : void ObjCNSObjectAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    5891           0 :   switch (SpellingListIndex) {
    5892           0 :   default:
    5893           0 :     llvm_unreachable("Unknown attribute spelling!");
    5894             :     break;
    5895           0 :   case 0 : {
    5896           0 :     OS << " __attribute__((NSObject))";
    5897           0 :     break;
    5898             :   }
    5899           0 :   case 1 : {
    5900           0 :     OS << " [[clang::NSObject]]";
    5901           0 :     break;
    5902             :   }
    5903           0 :   case 2 : {
    5904           0 :     OS << " [[clang::NSObject]]";
    5905           0 :     break;
    5906             :   }
    5907             : }
    5908           0 : }
    5909             : 
    5910           0 : const char *ObjCNSObjectAttr::getSpelling() const {
    5911           0 :   switch (SpellingListIndex) {
    5912           0 :   default:
    5913           0 :     llvm_unreachable("Unknown attribute spelling!");
    5914             :     return "(No spelling)";
    5915             :   case 0:
    5916             :     return "NSObject";
    5917             :   case 1:
    5918             :     return "NSObject";
    5919             :   case 2:
    5920             :     return "NSObject";
    5921             :   }
    5922             : }
    5923             : 
    5924           0 : ObjCPreciseLifetimeAttr *ObjCPreciseLifetimeAttr::clone(ASTContext &C) const {
    5925             :   auto *A = new (C) ObjCPreciseLifetimeAttr(getLocation(), C, getSpellingListIndex());
    5926           0 :   A->Inherited = Inherited;
    5927           0 :   A->IsPackExpansion = IsPackExpansion;
    5928           0 :   A->Implicit = Implicit;
    5929           0 :   return A;
    5930             : }
    5931             : 
    5932           0 : void ObjCPreciseLifetimeAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    5933           0 :   switch (SpellingListIndex) {
    5934           0 :   default:
    5935           0 :     llvm_unreachable("Unknown attribute spelling!");
    5936             :     break;
    5937           0 :   case 0 : {
    5938           0 :     OS << " __attribute__((objc_precise_lifetime))";
    5939           0 :     break;
    5940             :   }
    5941           0 :   case 1 : {
    5942           0 :     OS << " [[clang::objc_precise_lifetime]]";
    5943           0 :     break;
    5944             :   }
    5945           0 :   case 2 : {
    5946           0 :     OS << " [[clang::objc_precise_lifetime]]";
    5947           0 :     break;
    5948             :   }
    5949             : }
    5950           0 : }
    5951             : 
    5952           0 : const char *ObjCPreciseLifetimeAttr::getSpelling() const {
    5953           0 :   switch (SpellingListIndex) {
    5954           0 :   default:
    5955           0 :     llvm_unreachable("Unknown attribute spelling!");
    5956             :     return "(No spelling)";
    5957             :   case 0:
    5958             :     return "objc_precise_lifetime";
    5959             :   case 1:
    5960             :     return "objc_precise_lifetime";
    5961             :   case 2:
    5962             :     return "objc_precise_lifetime";
    5963             :   }
    5964             : }
    5965             : 
    5966           0 : ObjCRequiresPropertyDefsAttr *ObjCRequiresPropertyDefsAttr::clone(ASTContext &C) const {
    5967             :   auto *A = new (C) ObjCRequiresPropertyDefsAttr(getLocation(), C, getSpellingListIndex());
    5968           0 :   A->Inherited = Inherited;
    5969           0 :   A->IsPackExpansion = IsPackExpansion;
    5970           0 :   A->Implicit = Implicit;
    5971           0 :   return A;
    5972             : }
    5973             : 
    5974           0 : void ObjCRequiresPropertyDefsAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    5975           0 :   switch (SpellingListIndex) {
    5976           0 :   default:
    5977           0 :     llvm_unreachable("Unknown attribute spelling!");
    5978             :     break;
    5979           0 :   case 0 : {
    5980           0 :     OS << " __attribute__((objc_requires_property_definitions))";
    5981           0 :     break;
    5982             :   }
    5983           0 :   case 1 : {
    5984           0 :     OS << " [[clang::objc_requires_property_definitions]]";
    5985           0 :     break;
    5986             :   }
    5987           0 :   case 2 : {
    5988           0 :     OS << " [[clang::objc_requires_property_definitions]]";
    5989           0 :     break;
    5990             :   }
    5991             : }
    5992           0 : }
    5993             : 
    5994           0 : const char *ObjCRequiresPropertyDefsAttr::getSpelling() const {
    5995           0 :   switch (SpellingListIndex) {
    5996           0 :   default:
    5997           0 :     llvm_unreachable("Unknown attribute spelling!");
    5998             :     return "(No spelling)";
    5999             :   case 0:
    6000             :     return "objc_requires_property_definitions";
    6001             :   case 1:
    6002             :     return "objc_requires_property_definitions";
    6003             :   case 2:
    6004             :     return "objc_requires_property_definitions";
    6005             :   }
    6006             : }
    6007             : 
    6008          12 : ObjCRequiresSuperAttr *ObjCRequiresSuperAttr::clone(ASTContext &C) const {
    6009             :   auto *A = new (C) ObjCRequiresSuperAttr(getLocation(), C, getSpellingListIndex());
    6010          12 :   A->Inherited = Inherited;
    6011          12 :   A->IsPackExpansion = IsPackExpansion;
    6012          12 :   A->Implicit = Implicit;
    6013          12 :   return A;
    6014             : }
    6015             : 
    6016           0 : void ObjCRequiresSuperAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    6017           0 :   switch (SpellingListIndex) {
    6018           0 :   default:
    6019           0 :     llvm_unreachable("Unknown attribute spelling!");
    6020             :     break;
    6021           0 :   case 0 : {
    6022           0 :     OS << " __attribute__((objc_requires_super))";
    6023           0 :     break;
    6024             :   }
    6025           0 :   case 1 : {
    6026           0 :     OS << " [[clang::objc_requires_super]]";
    6027           0 :     break;
    6028             :   }
    6029           0 :   case 2 : {
    6030           0 :     OS << " [[clang::objc_requires_super]]";
    6031           0 :     break;
    6032             :   }
    6033             : }
    6034           0 : }
    6035             : 
    6036           0 : const char *ObjCRequiresSuperAttr::getSpelling() const {
    6037           0 :   switch (SpellingListIndex) {
    6038           0 :   default:
    6039           0 :     llvm_unreachable("Unknown attribute spelling!");
    6040             :     return "(No spelling)";
    6041             :   case 0:
    6042             :     return "objc_requires_super";
    6043             :   case 1:
    6044             :     return "objc_requires_super";
    6045             :   case 2:
    6046             :     return "objc_requires_super";
    6047             :   }
    6048             : }
    6049             : 
    6050           0 : ObjCReturnsInnerPointerAttr *ObjCReturnsInnerPointerAttr::clone(ASTContext &C) const {
    6051             :   auto *A = new (C) ObjCReturnsInnerPointerAttr(getLocation(), C, getSpellingListIndex());
    6052           0 :   A->Inherited = Inherited;
    6053           0 :   A->IsPackExpansion = IsPackExpansion;
    6054           0 :   A->Implicit = Implicit;
    6055           0 :   return A;
    6056             : }
    6057             : 
    6058           0 : void ObjCReturnsInnerPointerAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    6059           0 :   switch (SpellingListIndex) {
    6060           0 :   default:
    6061           0 :     llvm_unreachable("Unknown attribute spelling!");
    6062             :     break;
    6063           0 :   case 0 : {
    6064           0 :     OS << " __attribute__((objc_returns_inner_pointer))";
    6065           0 :     break;
    6066             :   }
    6067           0 :   case 1 : {
    6068           0 :     OS << " [[clang::objc_returns_inner_pointer]]";
    6069           0 :     break;
    6070             :   }
    6071           0 :   case 2 : {
    6072           0 :     OS << " [[clang::objc_returns_inner_pointer]]";
    6073           0 :     break;
    6074             :   }
    6075             : }
    6076           0 : }
    6077             : 
    6078           0 : const char *ObjCReturnsInnerPointerAttr::getSpelling() const {
    6079           0 :   switch (SpellingListIndex) {
    6080           0 :   default:
    6081           0 :     llvm_unreachable("Unknown attribute spelling!");
    6082             :     return "(No spelling)";
    6083             :   case 0:
    6084             :     return "objc_returns_inner_pointer";
    6085             :   case 1:
    6086             :     return "objc_returns_inner_pointer";
    6087             :   case 2:
    6088             :     return "objc_returns_inner_pointer";
    6089             :   }
    6090             : }
    6091             : 
    6092           0 : ObjCRootClassAttr *ObjCRootClassAttr::clone(ASTContext &C) const {
    6093             :   auto *A = new (C) ObjCRootClassAttr(getLocation(), C, getSpellingListIndex());
    6094           0 :   A->Inherited = Inherited;
    6095           0 :   A->IsPackExpansion = IsPackExpansion;
    6096           0 :   A->Implicit = Implicit;
    6097           0 :   return A;
    6098             : }
    6099             : 
    6100           0 : void ObjCRootClassAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    6101           0 :   switch (SpellingListIndex) {
    6102           0 :   default:
    6103           0 :     llvm_unreachable("Unknown attribute spelling!");
    6104             :     break;
    6105           0 :   case 0 : {
    6106           0 :     OS << " __attribute__((objc_root_class))";
    6107           0 :     break;
    6108             :   }
    6109           0 :   case 1 : {
    6110           0 :     OS << " [[clang::objc_root_class]]";
    6111           0 :     break;
    6112             :   }
    6113           0 :   case 2 : {
    6114           0 :     OS << " [[clang::objc_root_class]]";
    6115           0 :     break;
    6116             :   }
    6117             : }
    6118           0 : }
    6119             : 
    6120           0 : const char *ObjCRootClassAttr::getSpelling() const {
    6121           0 :   switch (SpellingListIndex) {
    6122           0 :   default:
    6123           0 :     llvm_unreachable("Unknown attribute spelling!");
    6124             :     return "(No spelling)";
    6125             :   case 0:
    6126             :     return "objc_root_class";
    6127             :   case 1:
    6128             :     return "objc_root_class";
    6129             :   case 2:
    6130             :     return "objc_root_class";
    6131             :   }
    6132             : }
    6133             : 
    6134           0 : ObjCRuntimeNameAttr *ObjCRuntimeNameAttr::clone(ASTContext &C) const {
    6135           0 :   auto *A = new (C) ObjCRuntimeNameAttr(getLocation(), C, getMetadataName(), getSpellingListIndex());
    6136           0 :   A->Inherited = Inherited;
    6137           0 :   A->IsPackExpansion = IsPackExpansion;
    6138           0 :   A->Implicit = Implicit;
    6139           0 :   return A;
    6140             : }
    6141             : 
    6142           0 : void ObjCRuntimeNameAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    6143           0 :   switch (SpellingListIndex) {
    6144           0 :   default:
    6145           0 :     llvm_unreachable("Unknown attribute spelling!");
    6146             :     break;
    6147           0 :   case 0 : {
    6148           0 :     OS << " __attribute__((objc_runtime_name(\"" << getMetadataName() << "\")))";
    6149           0 :     break;
    6150             :   }
    6151           0 :   case 1 : {
    6152           0 :     OS << " [[clang::objc_runtime_name(\"" << getMetadataName() << "\")]]";
    6153           0 :     break;
    6154             :   }
    6155           0 :   case 2 : {
    6156           0 :     OS << " [[clang::objc_runtime_name(\"" << getMetadataName() << "\")]]";
    6157           0 :     break;
    6158             :   }
    6159             : }
    6160           0 : }
    6161             : 
    6162           0 : const char *ObjCRuntimeNameAttr::getSpelling() const {
    6163           0 :   switch (SpellingListIndex) {
    6164           0 :   default:
    6165           0 :     llvm_unreachable("Unknown attribute spelling!");
    6166             :     return "(No spelling)";
    6167             :   case 0:
    6168             :     return "objc_runtime_name";
    6169             :   case 1:
    6170             :     return "objc_runtime_name";
    6171             :   case 2:
    6172             :     return "objc_runtime_name";
    6173             :   }
    6174             : }
    6175             : 
    6176           0 : ObjCRuntimeVisibleAttr *ObjCRuntimeVisibleAttr::clone(ASTContext &C) const {
    6177             :   auto *A = new (C) ObjCRuntimeVisibleAttr(getLocation(), C, getSpellingListIndex());
    6178           0 :   A->Inherited = Inherited;
    6179           0 :   A->IsPackExpansion = IsPackExpansion;
    6180           0 :   A->Implicit = Implicit;
    6181           0 :   return A;
    6182             : }
    6183             : 
    6184           0 : void ObjCRuntimeVisibleAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    6185           0 :   switch (SpellingListIndex) {
    6186           0 :   default:
    6187           0 :     llvm_unreachable("Unknown attribute spelling!");
    6188             :     break;
    6189           0 :   case 0 : {
    6190           0 :     OS << " __attribute__((objc_runtime_visible))";
    6191           0 :     break;
    6192             :   }
    6193           0 :   case 1 : {
    6194           0 :     OS << " [[clang::objc_runtime_visible]]";
    6195           0 :     break;
    6196             :   }
    6197           0 :   case 2 : {
    6198           0 :     OS << " [[clang::objc_runtime_visible]]";
    6199           0 :     break;
    6200             :   }
    6201             : }
    6202           0 : }
    6203             : 
    6204           0 : const char *ObjCRuntimeVisibleAttr::getSpelling() const {
    6205           0 :   switch (SpellingListIndex) {
    6206           0 :   default:
    6207           0 :     llvm_unreachable("Unknown attribute spelling!");
    6208             :     return "(No spelling)";
    6209             :   case 0:
    6210             :     return "objc_runtime_visible";
    6211             :   case 1:
    6212             :     return "objc_runtime_visible";
    6213             :   case 2:
    6214             :     return "objc_runtime_visible";
    6215             :   }
    6216             : }
    6217             : 
    6218           0 : ObjCSubclassingRestrictedAttr *ObjCSubclassingRestrictedAttr::clone(ASTContext &C) const {
    6219             :   auto *A = new (C) ObjCSubclassingRestrictedAttr(getLocation(), C, getSpellingListIndex());
    6220           0 :   A->Inherited = Inherited;
    6221           0 :   A->IsPackExpansion = IsPackExpansion;
    6222           0 :   A->Implicit = Implicit;
    6223           0 :   return A;
    6224             : }
    6225             : 
    6226           0 : void ObjCSubclassingRestrictedAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    6227           0 :   switch (SpellingListIndex) {
    6228           0 :   default:
    6229           0 :     llvm_unreachable("Unknown attribute spelling!");
    6230             :     break;
    6231           0 :   case 0 : {
    6232           0 :     OS << " __attribute__((objc_subclassing_restricted))";
    6233           0 :     break;
    6234             :   }
    6235           0 :   case 1 : {
    6236           0 :     OS << " [[clang::objc_subclassing_restricted]]";
    6237           0 :     break;
    6238             :   }
    6239           0 :   case 2 : {
    6240           0 :     OS << " [[clang::objc_subclassing_restricted]]";
    6241           0 :     break;
    6242             :   }
    6243             : }
    6244           0 : }
    6245             : 
    6246           0 : const char *ObjCSubclassingRestrictedAttr::getSpelling() const {
    6247           0 :   switch (SpellingListIndex) {
    6248           0 :   default:
    6249           0 :     llvm_unreachable("Unknown attribute spelling!");
    6250             :     return "(No spelling)";
    6251             :   case 0:
    6252             :     return "objc_subclassing_restricted";
    6253             :   case 1:
    6254             :     return "objc_subclassing_restricted";
    6255             :   case 2:
    6256             :     return "objc_subclassing_restricted";
    6257             :   }
    6258             : }
    6259             : 
    6260           0 : OpenCLAccessAttr *OpenCLAccessAttr::clone(ASTContext &C) const {
    6261             :   auto *A = new (C) OpenCLAccessAttr(getLocation(), C, getSpellingListIndex());
    6262           0 :   A->Inherited = Inherited;
    6263           0 :   A->IsPackExpansion = IsPackExpansion;
    6264           0 :   A->Implicit = Implicit;
    6265           0 :   return A;
    6266             : }
    6267             : 
    6268           0 : void OpenCLAccessAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    6269           0 :   switch (SpellingListIndex) {
    6270           0 :   default:
    6271           0 :     llvm_unreachable("Unknown attribute spelling!");
    6272             :     break;
    6273           0 :   case 0 : {
    6274           0 :     OS << " __read_only";
    6275           0 :     break;
    6276             :   }
    6277           0 :   case 1 : {
    6278           0 :     OS << " read_only";
    6279           0 :     break;
    6280             :   }
    6281           0 :   case 2 : {
    6282           0 :     OS << " __write_only";
    6283           0 :     break;
    6284             :   }
    6285           0 :   case 3 : {
    6286           0 :     OS << " write_only";
    6287           0 :     break;
    6288             :   }
    6289           0 :   case 4 : {
    6290           0 :     OS << " __read_write";
    6291           0 :     break;
    6292             :   }
    6293           0 :   case 5 : {
    6294           0 :     OS << " read_write";
    6295           0 :     break;
    6296             :   }
    6297             : }
    6298           0 : }
    6299             : 
    6300           2 : const char *OpenCLAccessAttr::getSpelling() const {
    6301           2 :   switch (SpellingListIndex) {
    6302           0 :   default:
    6303           0 :     llvm_unreachable("Unknown attribute spelling!");
    6304             :     return "(No spelling)";
    6305             :   case 0:
    6306             :     return "__read_only";
    6307           1 :   case 1:
    6308           1 :     return "read_only";
    6309           0 :   case 2:
    6310           0 :     return "__write_only";
    6311           1 :   case 3:
    6312           1 :     return "write_only";
    6313           0 :   case 4:
    6314           0 :     return "__read_write";
    6315           0 :   case 5:
    6316           0 :     return "read_write";
    6317             :   }
    6318             : }
    6319             : 
    6320           0 : OpenCLIntelReqdSubGroupSizeAttr *OpenCLIntelReqdSubGroupSizeAttr::clone(ASTContext &C) const {
    6321           0 :   auto *A = new (C) OpenCLIntelReqdSubGroupSizeAttr(getLocation(), C, subGroupSize, getSpellingListIndex());
    6322           0 :   A->Inherited = Inherited;
    6323           0 :   A->IsPackExpansion = IsPackExpansion;
    6324           0 :   A->Implicit = Implicit;
    6325           0 :   return A;
    6326             : }
    6327             : 
    6328           0 : void OpenCLIntelReqdSubGroupSizeAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    6329           0 :   switch (SpellingListIndex) {
    6330           0 :   default:
    6331           0 :     llvm_unreachable("Unknown attribute spelling!");
    6332             :     break;
    6333           0 :   case 0 : {
    6334           0 :     OS << " __attribute__((intel_reqd_sub_group_size(" << getSubGroupSize() << ")))";
    6335             :     break;
    6336             :   }
    6337             : }
    6338           0 : }
    6339             : 
    6340           2 : const char *OpenCLIntelReqdSubGroupSizeAttr::getSpelling() const {
    6341           2 :   switch (SpellingListIndex) {
    6342           0 :   default:
    6343           0 :     llvm_unreachable("Unknown attribute spelling!");
    6344             :     return "(No spelling)";
    6345           2 :   case 0:
    6346             :     return "intel_reqd_sub_group_size";
    6347             :   }
    6348             : }
    6349             : 
    6350           0 : OpenCLKernelAttr *OpenCLKernelAttr::clone(ASTContext &C) const {
    6351             :   auto *A = new (C) OpenCLKernelAttr(getLocation(), C, getSpellingListIndex());
    6352           0 :   A->Inherited = Inherited;
    6353           0 :   A->IsPackExpansion = IsPackExpansion;
    6354           0 :   A->Implicit = Implicit;
    6355           0 :   return A;
    6356             : }
    6357             : 
    6358           0 : void OpenCLKernelAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    6359           0 :   switch (SpellingListIndex) {
    6360           0 :   default:
    6361           0 :     llvm_unreachable("Unknown attribute spelling!");
    6362             :     break;
    6363           0 :   case 0 : {
    6364           0 :     OS << " __kernel";
    6365           0 :     break;
    6366             :   }
    6367           0 :   case 1 : {
    6368           0 :     OS << " kernel";
    6369           0 :     break;
    6370             :   }
    6371             : }
    6372           0 : }
    6373             : 
    6374           0 : const char *OpenCLKernelAttr::getSpelling() const {
    6375           0 :   switch (SpellingListIndex) {
    6376           0 :   default:
    6377           0 :     llvm_unreachable("Unknown attribute spelling!");
    6378             :     return "(No spelling)";
    6379             :   case 0:
    6380             :     return "__kernel";
    6381           0 :   case 1:
    6382           0 :     return "kernel";
    6383             :   }
    6384             : }
    6385             : 
    6386           0 : OpenCLUnrollHintAttr *OpenCLUnrollHintAttr::clone(ASTContext &C) const {
    6387           0 :   auto *A = new (C) OpenCLUnrollHintAttr(getLocation(), C, unrollHint, getSpellingListIndex());
    6388           0 :   A->Inherited = Inherited;
    6389           0 :   A->IsPackExpansion = IsPackExpansion;
    6390           0 :   A->Implicit = Implicit;
    6391           0 :   return A;
    6392             : }
    6393             : 
    6394           0 : void OpenCLUnrollHintAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    6395           0 :   switch (SpellingListIndex) {
    6396           0 :   default:
    6397           0 :     llvm_unreachable("Unknown attribute spelling!");
    6398             :     break;
    6399           0 :   case 0 : {
    6400           0 :     OS << " __attribute__((opencl_unroll_hint(" << getUnrollHint() << ")))";
    6401             :     break;
    6402             :   }
    6403             : }
    6404           0 : }
    6405             : 
    6406           0 : const char *OpenCLUnrollHintAttr::getSpelling() const {
    6407           0 :   switch (SpellingListIndex) {
    6408           0 :   default:
    6409           0 :     llvm_unreachable("Unknown attribute spelling!");
    6410             :     return "(No spelling)";
    6411           0 :   case 0:
    6412             :     return "opencl_unroll_hint";
    6413             :   }
    6414             : }
    6415             : 
    6416           9 : OptimizeNoneAttr *OptimizeNoneAttr::clone(ASTContext &C) const {
    6417             :   auto *A = new (C) OptimizeNoneAttr(getLocation(), C, getSpellingListIndex());
    6418           9 :   A->Inherited = Inherited;
    6419           9 :   A->IsPackExpansion = IsPackExpansion;
    6420           9 :   A->Implicit = Implicit;
    6421           9 :   return A;
    6422             : }
    6423             : 
    6424           0 : void OptimizeNoneAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    6425           0 :   switch (SpellingListIndex) {
    6426           0 :   default:
    6427           0 :     llvm_unreachable("Unknown attribute spelling!");
    6428             :     break;
    6429           0 :   case 0 : {
    6430           0 :     OS << " __attribute__((optnone))";
    6431           0 :     break;
    6432             :   }
    6433           0 :   case 1 : {
    6434           0 :     OS << " [[clang::optnone]]";
    6435           0 :     break;
    6436             :   }
    6437           0 :   case 2 : {
    6438           0 :     OS << " [[clang::optnone]]";
    6439           0 :     break;
    6440             :   }
    6441             : }
    6442           0 : }
    6443             : 
    6444           0 : const char *OptimizeNoneAttr::getSpelling() const {
    6445           0 :   switch (SpellingListIndex) {
    6446           0 :   default:
    6447           0 :     llvm_unreachable("Unknown attribute spelling!");
    6448             :     return "(No spelling)";
    6449             :   case 0:
    6450             :     return "optnone";
    6451             :   case 1:
    6452             :     return "optnone";
    6453             :   case 2:
    6454             :     return "optnone";
    6455             :   }
    6456             : }
    6457             : 
    6458           0 : OverloadableAttr *OverloadableAttr::clone(ASTContext &C) const {
    6459             :   auto *A = new (C) OverloadableAttr(getLocation(), C, getSpellingListIndex());
    6460           0 :   A->Inherited = Inherited;
    6461           0 :   A->IsPackExpansion = IsPackExpansion;
    6462           0 :   A->Implicit = Implicit;
    6463           0 :   return A;
    6464             : }
    6465             : 
    6466           0 : void OverloadableAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    6467           0 :   switch (SpellingListIndex) {
    6468           0 :   default:
    6469           0 :     llvm_unreachable("Unknown attribute spelling!");
    6470             :     break;
    6471           0 :   case 0 : {
    6472           0 :     OS << " __attribute__((overloadable))";
    6473           0 :     break;
    6474             :   }
    6475           0 :   case 1 : {
    6476           0 :     OS << " [[clang::overloadable]]";
    6477           0 :     break;
    6478             :   }
    6479           0 :   case 2 : {
    6480           0 :     OS << " [[clang::overloadable]]";
    6481           0 :     break;
    6482             :   }
    6483             : }
    6484           0 : }
    6485             : 
    6486           0 : const char *OverloadableAttr::getSpelling() const {
    6487           0 :   switch (SpellingListIndex) {
    6488           0 :   default:
    6489           0 :     llvm_unreachable("Unknown attribute spelling!");
    6490             :     return "(No spelling)";
    6491             :   case 0:
    6492             :     return "overloadable";
    6493             :   case 1:
    6494             :     return "overloadable";
    6495             :   case 2:
    6496             :     return "overloadable";
    6497             :   }
    6498             : }
    6499             : 
    6500          62 : OverrideAttr *OverrideAttr::clone(ASTContext &C) const {
    6501             :   auto *A = new (C) OverrideAttr(getLocation(), C, getSpellingListIndex());
    6502          62 :   A->Inherited = Inherited;
    6503          62 :   A->IsPackExpansion = IsPackExpansion;
    6504          62 :   A->Implicit = Implicit;
    6505          62 :   return A;
    6506             : }
    6507             : 
    6508           0 : void OverrideAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    6509           0 :   switch (SpellingListIndex) {
    6510           0 :   default:
    6511           0 :     llvm_unreachable("Unknown attribute spelling!");
    6512             :     break;
    6513           0 :   case 0 : {
    6514           0 :     OS << " override";
    6515             :     break;
    6516             :   }
    6517             : }
    6518           0 : }
    6519             : 
    6520           0 : const char *OverrideAttr::getSpelling() const {
    6521           0 :   switch (SpellingListIndex) {
    6522           0 :   default:
    6523           0 :     llvm_unreachable("Unknown attribute spelling!");
    6524             :     return "(No spelling)";
    6525           0 :   case 0:
    6526             :     return "override";
    6527             :   }
    6528             : }
    6529             : 
    6530           0 : OwnershipAttr *OwnershipAttr::clone(ASTContext &C) const {
    6531           0 :   auto *A = new (C) OwnershipAttr(getLocation(), C, module, args_, args_Size, getSpellingListIndex());
    6532           0 :   A->Inherited = Inherited;
    6533           0 :   A->IsPackExpansion = IsPackExpansion;
    6534           0 :   A->Implicit = Implicit;
    6535           0 :   return A;
    6536             : }
    6537             : 
    6538          12 : void OwnershipAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    6539          12 :   switch (SpellingListIndex) {
    6540           0 :   default:
    6541           0 :     llvm_unreachable("Unknown attribute spelling!");
    6542             :     break;
    6543           4 :   case 0 : {
    6544           4 :     OS << " __attribute__((ownership_holds(" << (getModule() ? getModule()->getName() : "") << ", ";
    6545             :   bool isFirst = true;
    6546          20 :   for (const auto &Val : args()) {
    6547           8 :     if (isFirst) isFirst = false;
    6548           4 :     else OS << ", ";
    6549             :     OS << Val.getSourceIndex();
    6550             :   }
    6551           4 :   OS << ")))";
    6552           4 :     break;
    6553             :   }
    6554           0 :   case 1 : {
    6555           0 :     OS << " [[clang::ownership_holds(" << (getModule() ? getModule()->getName() : "") << ", ";
    6556             :   bool isFirst = true;
    6557           0 :   for (const auto &Val : args()) {
    6558           0 :     if (isFirst) isFirst = false;
    6559           0 :     else OS << ", ";
    6560             :     OS << Val.getSourceIndex();
    6561             :   }
    6562           0 :   OS << ")]]";
    6563           0 :     break;
    6564             :   }
    6565           0 :   case 2 : {
    6566           0 :     OS << " [[clang::ownership_holds(" << (getModule() ? getModule()->getName() : "") << ", ";
    6567             :   bool isFirst = true;
    6568           0 :   for (const auto &Val : args()) {
    6569           0 :     if (isFirst) isFirst = false;
    6570           0 :     else OS << ", ";
    6571             :     OS << Val.getSourceIndex();
    6572             :   }
    6573           0 :   OS << ")]]";
    6574           0 :     break;
    6575             :   }
    6576           4 :   case 3 : {
    6577           4 :     OS << " __attribute__((ownership_returns(" << (getModule() ? getModule()->getName() : "") << ", ";
    6578             :   bool isFirst = true;
    6579          12 :   for (const auto &Val : args()) {
    6580           4 :     if (isFirst) isFirst = false;
    6581           0 :     else OS << ", ";
    6582             :     OS << Val.getSourceIndex();
    6583             :   }
    6584           4 :   OS << ")))";
    6585           4 :     break;
    6586             :   }
    6587           0 :   case 4 : {
    6588           0 :     OS << " [[clang::ownership_returns(" << (getModule() ? getModule()->getName() : "") << ", ";
    6589             :   bool isFirst = true;
    6590           0 :   for (const auto &Val : args()) {
    6591           0 :     if (isFirst) isFirst = false;
    6592           0 :     else OS << ", ";
    6593             :     OS << Val.getSourceIndex();
    6594             :   }
    6595           0 :   OS << ")]]";
    6596           0 :     break;
    6597             :   }
    6598           0 :   case 5 : {
    6599           0 :     OS << " [[clang::ownership_returns(" << (getModule() ? getModule()->getName() : "") << ", ";
    6600             :   bool isFirst = true;
    6601           0 :   for (const auto &Val : args()) {
    6602           0 :     if (isFirst) isFirst = false;
    6603           0 :     else OS << ", ";
    6604             :     OS << Val.getSourceIndex();
    6605             :   }
    6606           0 :   OS << ")]]";
    6607           0 :     break;
    6608             :   }
    6609           4 :   case 6 : {
    6610           4 :     OS << " __attribute__((ownership_takes(" << (getModule() ? getModule()->getName() : "") << ", ";
    6611             :   bool isFirst = true;
    6612          20 :   for (const auto &Val : args()) {
    6613           8 :     if (isFirst) isFirst = false;
    6614           4 :     else OS << ", ";
    6615             :     OS << Val.getSourceIndex();
    6616             :   }
    6617           4 :   OS << ")))";
    6618           4 :     break;
    6619             :   }
    6620           0 :   case 7 : {
    6621           0 :     OS << " [[clang::ownership_takes(" << (getModule() ? getModule()->getName() : "") << ", ";
    6622             :   bool isFirst = true;
    6623           0 :   for (const auto &Val : args()) {
    6624           0 :     if (isFirst) isFirst = false;
    6625           0 :     else OS << ", ";
    6626             :     OS << Val.getSourceIndex();
    6627             :   }
    6628           0 :   OS << ")]]";
    6629           0 :     break;
    6630             :   }
    6631           0 :   case 8 : {
    6632           0 :     OS << " [[clang::ownership_takes(" << (getModule() ? getModule()->getName() : "") << ", ";
    6633             :   bool isFirst = true;
    6634           0 :   for (const auto &Val : args()) {
    6635           0 :     if (isFirst) isFirst = false;
    6636           0 :     else OS << ", ";
    6637             :     OS << Val.getSourceIndex();
    6638             :   }
    6639           0 :   OS << ")]]";
    6640           0 :     break;
    6641             :   }
    6642             : }
    6643          12 : }
    6644             : 
    6645           1 : const char *OwnershipAttr::getSpelling() const {
    6646           1 :   switch (SpellingListIndex) {
    6647           0 :   default:
    6648           0 :     llvm_unreachable("Unknown attribute spelling!");
    6649             :     return "(No spelling)";
    6650             :   case 0:
    6651             :     return "ownership_holds";
    6652             :   case 1:
    6653             :     return "ownership_holds";
    6654             :   case 2:
    6655             :     return "ownership_holds";
    6656           0 :   case 3:
    6657           0 :     return "ownership_returns";
    6658           0 :   case 4:
    6659           0 :     return "ownership_returns";
    6660           0 :   case 5:
    6661           0 :     return "ownership_returns";
    6662           1 :   case 6:
    6663           1 :     return "ownership_takes";
    6664           0 :   case 7:
    6665           0 :     return "ownership_takes";
    6666           0 :   case 8:
    6667           0 :     return "ownership_takes";
    6668             :   }
    6669             : }
    6670             : 
    6671          17 : PackedAttr *PackedAttr::clone(ASTContext &C) const {
    6672             :   auto *A = new (C) PackedAttr(getLocation(), C, getSpellingListIndex());
    6673          17 :   A->Inherited = Inherited;
    6674          17 :   A->IsPackExpansion = IsPackExpansion;
    6675          17 :   A->Implicit = Implicit;
    6676          17 :   return A;
    6677             : }
    6678             : 
    6679           0 : void PackedAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    6680           0 :   switch (SpellingListIndex) {
    6681           0 :   default:
    6682           0 :     llvm_unreachable("Unknown attribute spelling!");
    6683             :     break;
    6684           0 :   case 0 : {
    6685           0 :     OS << " __attribute__((packed))";
    6686           0 :     break;
    6687             :   }
    6688           0 :   case 1 : {
    6689           0 :     OS << " [[gnu::packed]]";
    6690           0 :     break;
    6691             :   }
    6692             : }
    6693           0 : }
    6694             : 
    6695           0 : const char *PackedAttr::getSpelling() const {
    6696           0 :   switch (SpellingListIndex) {
    6697           0 :   default:
    6698           0 :     llvm_unreachable("Unknown attribute spelling!");
    6699             :     return "(No spelling)";
    6700             :   case 0:
    6701             :     return "packed";
    6702             :   case 1:
    6703             :     return "packed";
    6704             :   }
    6705             : }
    6706             : 
    6707           0 : ParamTypestateAttr *ParamTypestateAttr::clone(ASTContext &C) const {
    6708           0 :   auto *A = new (C) ParamTypestateAttr(getLocation(), C, paramState, getSpellingListIndex());
    6709           0 :   A->Inherited = Inherited;
    6710           0 :   A->IsPackExpansion = IsPackExpansion;
    6711           0 :   A->Implicit = Implicit;
    6712           0 :   return A;
    6713             : }
    6714             : 
    6715           0 : void ParamTypestateAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    6716           0 :   switch (SpellingListIndex) {
    6717           0 :   default:
    6718           0 :     llvm_unreachable("Unknown attribute spelling!");
    6719             :     break;
    6720           0 :   case 0 : {
    6721           0 :     OS << " __attribute__((param_typestate(\"" << ParamTypestateAttr::ConvertConsumedStateToStr(getParamState()) << "\")))";
    6722           0 :     break;
    6723             :   }
    6724           0 :   case 1 : {
    6725           0 :     OS << " [[clang::param_typestate(\"" << ParamTypestateAttr::ConvertConsumedStateToStr(getParamState()) << "\")]]";
    6726           0 :     break;
    6727             :   }
    6728             : }
    6729           0 : }
    6730             : 
    6731           0 : const char *ParamTypestateAttr::getSpelling() const {
    6732           0 :   switch (SpellingListIndex) {
    6733           0 :   default:
    6734           0 :     llvm_unreachable("Unknown attribute spelling!");
    6735             :     return "(No spelling)";
    6736             :   case 0:
    6737             :     return "param_typestate";
    6738             :   case 1:
    6739             :     return "param_typestate";
    6740             :   }
    6741             : }
    6742             : 
    6743           0 : PascalAttr *PascalAttr::clone(ASTContext &C) const {
    6744             :   auto *A = new (C) PascalAttr(getLocation(), C, getSpellingListIndex());
    6745           0 :   A->Inherited = Inherited;
    6746           0 :   A->IsPackExpansion = IsPackExpansion;
    6747           0 :   A->Implicit = Implicit;
    6748           0 :   return A;
    6749             : }
    6750             : 
    6751           0 : void PascalAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    6752           0 :   switch (SpellingListIndex) {
    6753           0 :   default:
    6754           0 :     llvm_unreachable("Unknown attribute spelling!");
    6755             :     break;
    6756           0 :   case 0 : {
    6757           0 :     OS << " __attribute__((pascal))";
    6758           0 :     break;
    6759             :   }
    6760           0 :   case 1 : {
    6761           0 :     OS << " [[clang::pascal]]";
    6762           0 :     break;
    6763             :   }
    6764           0 :   case 2 : {
    6765           0 :     OS << " [[clang::pascal]]";
    6766           0 :     break;
    6767             :   }
    6768           0 :   case 3 : {
    6769           0 :     OS << " __pascal";
    6770           0 :     break;
    6771             :   }
    6772           0 :   case 4 : {
    6773           0 :     OS << " _pascal";
    6774           0 :     break;
    6775             :   }
    6776             : }
    6777           0 : }
    6778             : 
    6779           0 : const char *PascalAttr::getSpelling() const {
    6780           0 :   switch (SpellingListIndex) {
    6781           0 :   default:
    6782           0 :     llvm_unreachable("Unknown attribute spelling!");
    6783             :     return "(No spelling)";
    6784             :   case 0:
    6785             :     return "pascal";
    6786             :   case 1:
    6787             :     return "pascal";
    6788             :   case 2:
    6789             :     return "pascal";
    6790           0 :   case 3:
    6791           0 :     return "__pascal";
    6792           0 :   case 4:
    6793           0 :     return "_pascal";
    6794             :   }
    6795             : }
    6796             : 
    6797          31 : PassObjectSizeAttr *PassObjectSizeAttr::clone(ASTContext &C) const {
    6798          31 :   auto *A = new (C) PassObjectSizeAttr(getLocation(), C, type, getSpellingListIndex());
    6799          31 :   A->Inherited = Inherited;
    6800          31 :   A->IsPackExpansion = IsPackExpansion;
    6801          31 :   A->Implicit = Implicit;
    6802          31 :   return A;
    6803             : }
    6804             : 
    6805           0 : void PassObjectSizeAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    6806           0 :   switch (SpellingListIndex) {
    6807           0 :   default:
    6808           0 :     llvm_unreachable("Unknown attribute spelling!");
    6809             :     break;
    6810           0 :   case 0 : {
    6811           0 :     OS << " __attribute__((pass_object_size(" << getType() << ")))";
    6812           0 :     break;
    6813             :   }
    6814           0 :   case 1 : {
    6815           0 :     OS << " [[clang::pass_object_size(" << getType() << ")]]";
    6816           0 :     break;
    6817             :   }
    6818           0 :   case 2 : {
    6819           0 :     OS << " [[clang::pass_object_size(" << getType() << ")]]";
    6820           0 :     break;
    6821             :   }
    6822             : }
    6823           0 : }
    6824             : 
    6825           1 : const char *PassObjectSizeAttr::getSpelling() const {
    6826           1 :   switch (SpellingListIndex) {
    6827           0 :   default:
    6828           0 :     llvm_unreachable("Unknown attribute spelling!");
    6829             :     return "(No spelling)";
    6830             :   case 0:
    6831             :     return "pass_object_size";
    6832             :   case 1:
    6833             :     return "pass_object_size";
    6834             :   case 2:
    6835             :     return "pass_object_size";
    6836             :   }
    6837             : }
    6838             : 
    6839           0 : PcsAttr *PcsAttr::clone(ASTContext &C) const {
    6840           0 :   auto *A = new (C) PcsAttr(getLocation(), C, pCS, getSpellingListIndex());
    6841           0 :   A->Inherited = Inherited;
    6842           0 :   A->IsPackExpansion = IsPackExpansion;
    6843           0 :   A->Implicit = Implicit;
    6844           0 :   return A;
    6845             : }
    6846             : 
    6847           0 : void PcsAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    6848           0 :   switch (SpellingListIndex) {
    6849           0 :   default:
    6850           0 :     llvm_unreachable("Unknown attribute spelling!");
    6851             :     break;
    6852           0 :   case 0 : {
    6853           0 :     OS << " __attribute__((pcs(\"" << PcsAttr::ConvertPCSTypeToStr(getPCS()) << "\")))";
    6854           0 :     break;
    6855             :   }
    6856           0 :   case 1 : {
    6857           0 :     OS << " [[gnu::pcs(\"" << PcsAttr::ConvertPCSTypeToStr(getPCS()) << "\")]]";
    6858           0 :     break;
    6859             :   }
    6860             : }
    6861           0 : }
    6862             : 
    6863           0 : const char *PcsAttr::getSpelling() const {
    6864           0 :   switch (SpellingListIndex) {
    6865           0 :   default:
    6866           0 :     llvm_unreachable("Unknown attribute spelling!");
    6867             :     return "(No spelling)";
    6868             :   case 0:
    6869             :     return "pcs";
    6870             :   case 1:
    6871             :     return "pcs";
    6872             :   }
    6873             : }
    6874             : 
    6875           5 : PragmaClangBSSSectionAttr *PragmaClangBSSSectionAttr::clone(ASTContext &C) const {
    6876          15 :   auto *A = new (C) PragmaClangBSSSectionAttr(getLocation(), C, getName(), getSpellingListIndex());
    6877           5 :   A->Inherited = Inherited;
    6878           5 :   A->IsPackExpansion = IsPackExpansion;
    6879           5 :   A->Implicit = Implicit;
    6880           5 :   return A;
    6881             : }
    6882             : 
    6883           0 : void PragmaClangBSSSectionAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    6884           0 : }
    6885             : 
    6886           0 : const char *PragmaClangBSSSectionAttr::getSpelling() const {
    6887           0 :   return "(No spelling)";
    6888             : }
    6889             : 
    6890           0 : PragmaClangDataSectionAttr *PragmaClangDataSectionAttr::clone(ASTContext &C) const {
    6891           0 :   auto *A = new (C) PragmaClangDataSectionAttr(getLocation(), C, getName(), getSpellingListIndex());
    6892           0 :   A->Inherited = Inherited;
    6893           0 :   A->IsPackExpansion = IsPackExpansion;
    6894           0 :   A->Implicit = Implicit;
    6895           0 :   return A;
    6896             : }
    6897             : 
    6898           0 : void PragmaClangDataSectionAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    6899           0 : }
    6900             : 
    6901           0 : const char *PragmaClangDataSectionAttr::getSpelling() const {
    6902           0 :   return "(No spelling)";
    6903             : }
    6904             : 
    6905           2 : PragmaClangRodataSectionAttr *PragmaClangRodataSectionAttr::clone(ASTContext &C) const {
    6906           6 :   auto *A = new (C) PragmaClangRodataSectionAttr(getLocation(), C, getName(), getSpellingListIndex());
    6907           2 :   A->Inherited = Inherited;
    6908           2 :   A->IsPackExpansion = IsPackExpansion;
    6909           2 :   A->Implicit = Implicit;
    6910           2 :   return A;
    6911             : }
    6912             : 
    6913           0 : void PragmaClangRodataSectionAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    6914           0 : }
    6915             : 
    6916           0 : const char *PragmaClangRodataSectionAttr::getSpelling() const {
    6917           0 :   return "(No spelling)";
    6918             : }
    6919             : 
    6920           0 : PragmaClangTextSectionAttr *PragmaClangTextSectionAttr::clone(ASTContext &C) const {
    6921           0 :   auto *A = new (C) PragmaClangTextSectionAttr(getLocation(), C, getName(), getSpellingListIndex());
    6922           0 :   A->Inherited = Inherited;
    6923           0 :   A->IsPackExpansion = IsPackExpansion;
    6924           0 :   A->Implicit = Implicit;
    6925           0 :   return A;
    6926             : }
    6927             : 
    6928           0 : void PragmaClangTextSectionAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    6929           0 : }
    6930             : 
    6931           0 : const char *PragmaClangTextSectionAttr::getSpelling() const {
    6932           0 :   return "(No spelling)";
    6933             : }
    6934             : 
    6935           0 : PreserveAllAttr *PreserveAllAttr::clone(ASTContext &C) const {
    6936             :   auto *A = new (C) PreserveAllAttr(getLocation(), C, getSpellingListIndex());
    6937           0 :   A->Inherited = Inherited;
    6938           0 :   A->IsPackExpansion = IsPackExpansion;
    6939           0 :   A->Implicit = Implicit;
    6940           0 :   return A;
    6941             : }
    6942             : 
    6943           0 : void PreserveAllAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    6944           0 :   switch (SpellingListIndex) {
    6945           0 :   default:
    6946           0 :     llvm_unreachable("Unknown attribute spelling!");
    6947             :     break;
    6948           0 :   case 0 : {
    6949           0 :     OS << " __attribute__((preserve_all))";
    6950           0 :     break;
    6951             :   }
    6952           0 :   case 1 : {
    6953           0 :     OS << " [[clang::preserve_all]]";
    6954           0 :     break;
    6955             :   }
    6956           0 :   case 2 : {
    6957           0 :     OS << " [[clang::preserve_all]]";
    6958           0 :     break;
    6959             :   }
    6960             : }
    6961           0 : }
    6962             : 
    6963           0 : const char *PreserveAllAttr::getSpelling() const {
    6964           0 :   switch (SpellingListIndex) {
    6965           0 :   default:
    6966           0 :     llvm_unreachable("Unknown attribute spelling!");
    6967             :     return "(No spelling)";
    6968             :   case 0:
    6969             :     return "preserve_all";
    6970             :   case 1:
    6971             :     return "preserve_all";
    6972             :   case 2:
    6973             :     return "preserve_all";
    6974             :   }
    6975             : }
    6976             : 
    6977           0 : PreserveMostAttr *PreserveMostAttr::clone(ASTContext &C) const {
    6978             :   auto *A = new (C) PreserveMostAttr(getLocation(), C, getSpellingListIndex());
    6979           0 :   A->Inherited = Inherited;
    6980           0 :   A->IsPackExpansion = IsPackExpansion;
    6981           0 :   A->Implicit = Implicit;
    6982           0 :   return A;
    6983             : }
    6984             : 
    6985           0 : void PreserveMostAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    6986           0 :   switch (SpellingListIndex) {
    6987           0 :   default:
    6988           0 :     llvm_unreachable("Unknown attribute spelling!");
    6989             :     break;
    6990           0 :   case 0 : {
    6991           0 :     OS << " __attribute__((preserve_most))";
    6992           0 :     break;
    6993             :   }
    6994           0 :   case 1 : {
    6995           0 :     OS << " [[clang::preserve_most]]";
    6996           0 :     break;
    6997             :   }
    6998           0 :   case 2 : {
    6999           0 :     OS << " [[clang::preserve_most]]";
    7000           0 :     break;
    7001             :   }
    7002             : }
    7003           0 : }
    7004             : 
    7005           0 : const char *PreserveMostAttr::getSpelling() const {
    7006           0 :   switch (SpellingListIndex) {
    7007           0 :   default:
    7008           0 :     llvm_unreachable("Unknown attribute spelling!");
    7009             :     return "(No spelling)";
    7010             :   case 0:
    7011             :     return "preserve_most";
    7012             :   case 1:
    7013             :     return "preserve_most";
    7014             :   case 2:
    7015             :     return "preserve_most";
    7016             :   }
    7017             : }
    7018             : 
    7019           0 : PtGuardedByAttr *PtGuardedByAttr::clone(ASTContext &C) const {
    7020           0 :   auto *A = new (C) PtGuardedByAttr(getLocation(), C, arg, getSpellingListIndex());
    7021           0 :   A->Inherited = Inherited;
    7022           0 :   A->IsPackExpansion = IsPackExpansion;
    7023           0 :   A->Implicit = Implicit;
    7024           0 :   return A;
    7025             : }
    7026             : 
    7027           0 : void PtGuardedByAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    7028           0 :   switch (SpellingListIndex) {
    7029           0 :   default:
    7030           0 :     llvm_unreachable("Unknown attribute spelling!");
    7031             :     break;
    7032           0 :   case 0 : {
    7033           0 :     OS << " __attribute__((pt_guarded_by(" << getArg() << ")))";
    7034             :     break;
    7035             :   }
    7036             : }
    7037           0 : }
    7038             : 
    7039           0 : const char *PtGuardedByAttr::getSpelling() const {
    7040           0 :   switch (SpellingListIndex) {
    7041           0 :   default:
    7042           0 :     llvm_unreachable("Unknown attribute spelling!");
    7043             :     return "(No spelling)";
    7044           0 :   case 0:
    7045             :     return "pt_guarded_by";
    7046             :   }
    7047             : }
    7048             : 
    7049           0 : PtGuardedVarAttr *PtGuardedVarAttr::clone(ASTContext &C) const {
    7050             :   auto *A = new (C) PtGuardedVarAttr(getLocation(), C, getSpellingListIndex());
    7051           0 :   A->Inherited = Inherited;
    7052           0 :   A->IsPackExpansion = IsPackExpansion;
    7053           0 :   A->Implicit = Implicit;
    7054           0 :   return A;
    7055             : }
    7056             : 
    7057           0 : void PtGuardedVarAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    7058           0 :   switch (SpellingListIndex) {
    7059           0 :   default:
    7060           0 :     llvm_unreachable("Unknown attribute spelling!");
    7061             :     break;
    7062           0 :   case 0 : {
    7063           0 :     OS << " __attribute__((pt_guarded_var))";
    7064           0 :     break;
    7065             :   }
    7066           0 :   case 1 : {
    7067           0 :     OS << " [[clang::pt_guarded_var]]";
    7068           0 :     break;
    7069             :   }
    7070             : }
    7071           0 : }
    7072             : 
    7073           0 : const char *PtGuardedVarAttr::getSpelling() const {
    7074           0 :   switch (SpellingListIndex) {
    7075           0 :   default:
    7076           0 :     llvm_unreachable("Unknown attribute spelling!");
    7077             :     return "(No spelling)";
    7078             :   case 0:
    7079             :     return "pt_guarded_var";
    7080             :   case 1:
    7081             :     return "pt_guarded_var";
    7082             :   }
    7083             : }
    7084             : 
    7085         422 : PureAttr *PureAttr::clone(ASTContext &C) const {
    7086             :   auto *A = new (C) PureAttr(getLocation(), C, getSpellingListIndex());
    7087         422 :   A->Inherited = Inherited;
    7088         422 :   A->IsPackExpansion = IsPackExpansion;
    7089         422 :   A->Implicit = Implicit;
    7090         422 :   return A;
    7091             : }
    7092             : 
    7093           5 : void PureAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    7094           5 :   switch (SpellingListIndex) {
    7095           0 :   default:
    7096           0 :     llvm_unreachable("Unknown attribute spelling!");
    7097             :     break;
    7098           3 :   case 0 : {
    7099           3 :     OS << " __attribute__((pure))";
    7100           3 :     break;
    7101             :   }
    7102           2 :   case 1 : {
    7103           2 :     OS << " [[gnu::pure]]";
    7104           2 :     break;
    7105             :   }
    7106             : }
    7107           5 : }
    7108             : 
    7109           0 : const char *PureAttr::getSpelling() const {
    7110           0 :   switch (SpellingListIndex) {
    7111           0 :   default:
    7112           0 :     llvm_unreachable("Unknown attribute spelling!");
    7113             :     return "(No spelling)";
    7114             :   case 0:
    7115             :     return "pure";
    7116             :   case 1:
    7117             :     return "pure";
    7118             :   }
    7119             : }
    7120             : 
    7121           0 : RegCallAttr *RegCallAttr::clone(ASTContext &C) const {
    7122             :   auto *A = new (C) RegCallAttr(getLocation(), C, getSpellingListIndex());
    7123           0 :   A->Inherited = Inherited;
    7124           0 :   A->IsPackExpansion = IsPackExpansion;
    7125           0 :   A->Implicit = Implicit;
    7126           0 :   return A;
    7127             : }
    7128             : 
    7129           0 : void RegCallAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    7130           0 :   switch (SpellingListIndex) {
    7131           0 :   default:
    7132           0 :     llvm_unreachable("Unknown attribute spelling!");
    7133             :     break;
    7134           0 :   case 0 : {
    7135           0 :     OS << " __attribute__((regcall))";
    7136           0 :     break;
    7137             :   }
    7138           0 :   case 1 : {
    7139           0 :     OS << " [[gnu::regcall]]";
    7140           0 :     break;
    7141             :   }
    7142           0 :   case 2 : {
    7143           0 :     OS << " __regcall";
    7144           0 :     break;
    7145             :   }
    7146             : }
    7147           0 : }
    7148             : 
    7149           0 : const char *RegCallAttr::getSpelling() const {
    7150           0 :   switch (SpellingListIndex) {
    7151           0 :   default:
    7152           0 :     llvm_unreachable("Unknown attribute spelling!");
    7153             :     return "(No spelling)";
    7154             :   case 0:
    7155             :     return "regcall";
    7156             :   case 1:
    7157             :     return "regcall";
    7158           0 :   case 2:
    7159           0 :     return "__regcall";
    7160             :   }
    7161             : }
    7162             : 
    7163          35 : ReleaseCapabilityAttr *ReleaseCapabilityAttr::clone(ASTContext &C) const {
    7164          35 :   auto *A = new (C) ReleaseCapabilityAttr(getLocation(), C, args_, args_Size, getSpellingListIndex());
    7165          35 :   A->Inherited = Inherited;
    7166          35 :   A->IsPackExpansion = IsPackExpansion;
    7167          35 :   A->Implicit = Implicit;
    7168          35 :   return A;
    7169             : }
    7170             : 
    7171           0 : void ReleaseCapabilityAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    7172           0 :   switch (SpellingListIndex) {
    7173           0 :   default:
    7174           0 :     llvm_unreachable("Unknown attribute spelling!");
    7175             :     break;
    7176           0 :   case 0 : {
    7177           0 :     OS << " __attribute__((release_capability(";
    7178             :   bool isFirst = true;
    7179           0 :   for (const auto &Val : args()) {
    7180           0 :     if (isFirst) isFirst = false;
    7181           0 :     else OS << ", ";
    7182           0 :     OS << Val;
    7183             :   }
    7184           0 :   OS << ")))";
    7185           0 :     break;
    7186             :   }
    7187           0 :   case 1 : {
    7188           0 :     OS << " [[clang::release_capability(";
    7189             :   bool isFirst = true;
    7190           0 :   for (const auto &Val : args()) {
    7191           0 :     if (isFirst) isFirst = false;
    7192           0 :     else OS << ", ";
    7193           0 :     OS << Val;
    7194             :   }
    7195           0 :   OS << ")]]";
    7196           0 :     break;
    7197             :   }
    7198           0 :   case 2 : {
    7199           0 :     OS << " __attribute__((release_shared_capability(";
    7200             :   bool isFirst = true;
    7201           0 :   for (const auto &Val : args()) {
    7202           0 :     if (isFirst) isFirst = false;
    7203           0 :     else OS << ", ";
    7204           0 :     OS << Val;
    7205             :   }
    7206           0 :   OS << ")))";
    7207           0 :     break;
    7208             :   }
    7209           0 :   case 3 : {
    7210           0 :     OS << " [[clang::release_shared_capability(";
    7211             :   bool isFirst = true;
    7212           0 :   for (const auto &Val : args()) {
    7213           0 :     if (isFirst) isFirst = false;
    7214           0 :     else OS << ", ";
    7215           0 :     OS << Val;
    7216             :   }
    7217           0 :   OS << ")]]";
    7218           0 :     break;
    7219             :   }
    7220           0 :   case 4 : {
    7221           0 :     OS << " __attribute__((release_generic_capability(";
    7222             :   bool isFirst = true;
    7223           0 :   for (const auto &Val : args()) {
    7224           0 :     if (isFirst) isFirst = false;
    7225           0 :     else OS << ", ";
    7226           0 :     OS << Val;
    7227             :   }
    7228           0 :   OS << ")))";
    7229           0 :     break;
    7230             :   }
    7231           0 :   case 5 : {
    7232           0 :     OS << " [[clang::release_generic_capability(";
    7233             :   bool isFirst = true;
    7234           0 :   for (const auto &Val : args()) {
    7235           0 :     if (isFirst) isFirst = false;
    7236           0 :     else OS << ", ";
    7237           0 :     OS << Val;
    7238             :   }
    7239           0 :   OS << ")]]";
    7240           0 :     break;
    7241             :   }
    7242           0 :   case 6 : {
    7243           0 :     OS << " __attribute__((unlock_function(";
    7244             :   bool isFirst = true;
    7245           0 :   for (const auto &Val : args()) {
    7246           0 :     if (isFirst) isFirst = false;
    7247           0 :     else OS << ", ";
    7248           0 :     OS << Val;
    7249             :   }
    7250           0 :   OS << ")))";
    7251           0 :     break;
    7252             :   }
    7253           0 :   case 7 : {
    7254           0 :     OS << " [[clang::unlock_function(";
    7255             :   bool isFirst = true;
    7256           0 :   for (const auto &Val : args()) {
    7257           0 :     if (isFirst) isFirst = false;
    7258           0 :     else OS << ", ";
    7259           0 :     OS << Val;
    7260             :   }
    7261           0 :   OS << ")]]";
    7262           0 :     break;
    7263             :   }
    7264             : }
    7265           0 : }
    7266             : 
    7267           0 : const char *ReleaseCapabilityAttr::getSpelling() const {
    7268           0 :   switch (SpellingListIndex) {
    7269           0 :   default:
    7270           0 :     llvm_unreachable("Unknown attribute spelling!");
    7271             :     return "(No spelling)";
    7272             :   case 0:
    7273             :     return "release_capability";
    7274             :   case 1:
    7275             :     return "release_capability";
    7276           0 :   case 2:
    7277           0 :     return "release_shared_capability";
    7278           0 :   case 3:
    7279           0 :     return "release_shared_capability";
    7280           0 :   case 4:
    7281           0 :     return "release_generic_capability";
    7282           0 :   case 5:
    7283           0 :     return "release_generic_capability";
    7284           0 :   case 6:
    7285           0 :     return "unlock_function";
    7286           0 :   case 7:
    7287           0 :     return "unlock_function";
    7288             :   }
    7289             : }
    7290             : 
    7291           0 : RenderScriptKernelAttr *RenderScriptKernelAttr::clone(ASTContext &C) const {
    7292             :   auto *A = new (C) RenderScriptKernelAttr(getLocation(), C, getSpellingListIndex());
    7293           0 :   A->Inherited = Inherited;
    7294           0 :   A->IsPackExpansion = IsPackExpansion;
    7295           0 :   A->Implicit = Implicit;
    7296           0 :   return A;
    7297             : }
    7298             : 
    7299           0 : void RenderScriptKernelAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    7300           0 :   switch (SpellingListIndex) {
    7301           0 :   default:
    7302           0 :     llvm_unreachable("Unknown attribute spelling!");
    7303             :     break;
    7304           0 :   case 0 : {
    7305           0 :     OS << " __attribute__((kernel))";
    7306             :     break;
    7307             :   }
    7308             : }
    7309           0 : }
    7310             : 
    7311           0 : const char *RenderScriptKernelAttr::getSpelling() const {
    7312           0 :   switch (SpellingListIndex) {
    7313           0 :   default:
    7314           0 :     llvm_unreachable("Unknown attribute spelling!");
    7315             :     return "(No spelling)";
    7316           0 :   case 0:
    7317             :     return "kernel";
    7318             :   }
    7319             : }
    7320             : 
    7321           0 : ReqdWorkGroupSizeAttr *ReqdWorkGroupSizeAttr::clone(ASTContext &C) const {
    7322           0 :   auto *A = new (C) ReqdWorkGroupSizeAttr(getLocation(), C, xDim, yDim, zDim, getSpellingListIndex());
    7323           0 :   A->Inherited = Inherited;
    7324           0 :   A->IsPackExpansion = IsPackExpansion;
    7325           0 :   A->Implicit = Implicit;
    7326           0 :   return A;
    7327             : }
    7328             : 
    7329           0 : void ReqdWorkGroupSizeAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    7330           0 :   switch (SpellingListIndex) {
    7331           0 :   default:
    7332           0 :     llvm_unreachable("Unknown attribute spelling!");
    7333             :     break;
    7334           0 :   case 0 : {
    7335           0 :     OS << " __attribute__((reqd_work_group_size(" << getXDim() << ", " << getYDim() << ", " << getZDim() << ")))";
    7336             :     break;
    7337             :   }
    7338             : }
    7339           0 : }
    7340             : 
    7341           2 : const char *ReqdWorkGroupSizeAttr::getSpelling() const {
    7342           2 :   switch (SpellingListIndex) {
    7343           0 :   default:
    7344           0 :     llvm_unreachable("Unknown attribute spelling!");
    7345             :     return "(No spelling)";
    7346           2 :   case 0:
    7347             :     return "reqd_work_group_size";
    7348             :   }
    7349             : }
    7350             : 
    7351          22 : RequireConstantInitAttr *RequireConstantInitAttr::clone(ASTContext &C) const {
    7352             :   auto *A = new (C) RequireConstantInitAttr(getLocation(), C, getSpellingListIndex());
    7353          22 :   A->Inherited = Inherited;
    7354          22 :   A->IsPackExpansion = IsPackExpansion;
    7355          22 :   A->Implicit = Implicit;
    7356          22 :   return A;
    7357             : }
    7358             : 
    7359           0 : void RequireConstantInitAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    7360           0 :   switch (SpellingListIndex) {
    7361           0 :   default:
    7362           0 :     llvm_unreachable("Unknown attribute spelling!");
    7363             :     break;
    7364           0 :   case 0 : {
    7365           0 :     OS << " __attribute__((require_constant_initialization))";
    7366           0 :     break;
    7367             :   }
    7368           0 :   case 1 : {
    7369           0 :     OS << " [[clang::require_constant_initialization]]";
    7370           0 :     break;
    7371             :   }
    7372             : }
    7373           0 : }
    7374             : 
    7375           0 : const char *RequireConstantInitAttr::getSpelling() const {
    7376           0 :   switch (SpellingListIndex) {
    7377           0 :   default:
    7378           0 :     llvm_unreachable("Unknown attribute spelling!");
    7379             :     return "(No spelling)";
    7380             :   case 0:
    7381             :     return "require_constant_initialization";
    7382             :   case 1:
    7383             :     return "require_constant_initialization";
    7384             :   }
    7385             : }
    7386             : 
    7387         134 : RequiresCapabilityAttr *RequiresCapabilityAttr::clone(ASTContext &C) const {
    7388         134 :   auto *A = new (C) RequiresCapabilityAttr(getLocation(), C, args_, args_Size, getSpellingListIndex());
    7389         134 :   A->Inherited = Inherited;
    7390         134 :   A->IsPackExpansion = IsPackExpansion;
    7391         134 :   A->Implicit = Implicit;
    7392         134 :   return A;
    7393             : }
    7394             : 
    7395           0 : void RequiresCapabilityAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    7396           0 :   switch (SpellingListIndex) {
    7397           0 :   default:
    7398           0 :     llvm_unreachable("Unknown attribute spelling!");
    7399             :     break;
    7400           0 :   case 0 : {
    7401           0 :     OS << " __attribute__((requires_capability(";
    7402             :   bool isFirst = true;
    7403           0 :   for (const auto &Val : args()) {
    7404           0 :     if (isFirst) isFirst = false;
    7405           0 :     else OS << ", ";
    7406           0 :     OS << Val;
    7407             :   }
    7408           0 :   OS << ")))";
    7409           0 :     break;
    7410             :   }
    7411           0 :   case 1 : {
    7412           0 :     OS << " [[clang::requires_capability(";
    7413             :   bool isFirst = true;
    7414           0 :   for (const auto &Val : args()) {
    7415           0 :     if (isFirst) isFirst = false;
    7416           0 :     else OS << ", ";
    7417           0 :     OS << Val;
    7418             :   }
    7419           0 :   OS << ")]]";
    7420           0 :     break;
    7421             :   }
    7422           0 :   case 2 : {
    7423           0 :     OS << " __attribute__((exclusive_locks_required(";
    7424             :   bool isFirst = true;
    7425           0 :   for (const auto &Val : args()) {
    7426           0 :     if (isFirst) isFirst = false;
    7427           0 :     else OS << ", ";
    7428           0 :     OS << Val;
    7429             :   }
    7430           0 :   OS << ")))";
    7431           0 :     break;
    7432             :   }
    7433           0 :   case 3 : {
    7434           0 :     OS << " [[clang::exclusive_locks_required(";
    7435             :   bool isFirst = true;
    7436           0 :   for (const auto &Val : args()) {
    7437           0 :     if (isFirst) isFirst = false;
    7438           0 :     else OS << ", ";
    7439           0 :     OS << Val;
    7440             :   }
    7441           0 :   OS << ")]]";
    7442           0 :     break;
    7443             :   }
    7444           0 :   case 4 : {
    7445           0 :     OS << " __attribute__((requires_shared_capability(";
    7446             :   bool isFirst = true;
    7447           0 :   for (const auto &Val : args()) {
    7448           0 :     if (isFirst) isFirst = false;
    7449           0 :     else OS << ", ";
    7450           0 :     OS << Val;
    7451             :   }
    7452           0 :   OS << ")))";
    7453           0 :     break;
    7454             :   }
    7455           0 :   case 5 : {
    7456           0 :     OS << " [[clang::requires_shared_capability(";
    7457             :   bool isFirst = true;
    7458           0 :   for (const auto &Val : args()) {
    7459           0 :     if (isFirst) isFirst = false;
    7460           0 :     else OS << ", ";
    7461           0 :     OS << Val;
    7462             :   }
    7463           0 :   OS << ")]]";
    7464           0 :     break;
    7465             :   }
    7466           0 :   case 6 : {
    7467           0 :     OS << " __attribute__((shared_locks_required(";
    7468             :   bool isFirst = true;
    7469           0 :   for (const auto &Val : args()) {
    7470           0 :     if (isFirst) isFirst = false;
    7471           0 :     else OS << ", ";
    7472           0 :     OS << Val;
    7473             :   }
    7474           0 :   OS << ")))";
    7475           0 :     break;
    7476             :   }
    7477           0 :   case 7 : {
    7478           0 :     OS << " [[clang::shared_locks_required(";
    7479             :   bool isFirst = true;
    7480           0 :   for (const auto &Val : args()) {
    7481           0 :     if (isFirst) isFirst = false;
    7482           0 :     else OS << ", ";
    7483           0 :     OS << Val;
    7484             :   }
    7485           0 :   OS << ")]]";
    7486           0 :     break;
    7487             :   }
    7488             : }
    7489           0 : }
    7490             : 
    7491           0 : const char *RequiresCapabilityAttr::getSpelling() const {
    7492           0 :   switch (SpellingListIndex) {
    7493           0 :   default:
    7494           0 :     llvm_unreachable("Unknown attribute spelling!");
    7495             :     return "(No spelling)";
    7496             :   case 0:
    7497             :     return "requires_capability";
    7498             :   case 1:
    7499             :     return "requires_capability";
    7500           0 :   case 2:
    7501           0 :     return "exclusive_locks_required";
    7502           0 :   case 3:
    7503           0 :     return "exclusive_locks_required";
    7504           0 :   case 4:
    7505           0 :     return "requires_shared_capability";
    7506           0 :   case 5:
    7507           0 :     return "requires_shared_capability";
    7508           0 :   case 6:
    7509           0 :     return "shared_locks_required";
    7510           0 :   case 7:
    7511           0 :     return "shared_locks_required";
    7512             :   }
    7513             : }
    7514             : 
    7515           6 : RestrictAttr *RestrictAttr::clone(ASTContext &C) const {
    7516             :   auto *A = new (C) RestrictAttr(getLocation(), C, getSpellingListIndex());
    7517           6 :   A->Inherited = Inherited;
    7518           6 :   A->IsPackExpansion = IsPackExpansion;
    7519           6 :   A->Implicit = Implicit;
    7520           6 :   return A;
    7521             : }
    7522             : 
    7523           1 : void RestrictAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    7524           1 :   switch (SpellingListIndex) {
    7525           0 :   default:
    7526           0 :     llvm_unreachable("Unknown attribute spelling!");
    7527             :     break;
    7528           0 :   case 0 : {
    7529           0 :     OS << " __declspec(restrict)";
    7530           0 :     break;
    7531             :   }
    7532           1 :   case 1 : {
    7533           1 :     OS << " __attribute__((malloc))";
    7534           1 :     break;
    7535             :   }
    7536           0 :   case 2 : {
    7537           0 :     OS << " [[gnu::malloc]]";
    7538           0 :     break;
    7539             :   }
    7540             : }
    7541           1 : }
    7542             : 
    7543           0 : const char *RestrictAttr::getSpelling() const {
    7544           0 :   switch (SpellingListIndex) {
    7545           0 :   default:
    7546           0 :     llvm_unreachable("Unknown attribute spelling!");
    7547             :     return "(No spelling)";
    7548             :   case 0:
    7549             :     return "restrict";
    7550           0 :   case 1:
    7551           0 :     return "malloc";
    7552           0 :   case 2:
    7553           0 :     return "malloc";
    7554             :   }
    7555             : }
    7556             : 
    7557           6 : ReturnTypestateAttr *ReturnTypestateAttr::clone(ASTContext &C) const {
    7558           6 :   auto *A = new (C) ReturnTypestateAttr(getLocation(), C, state, getSpellingListIndex());
    7559           6 :   A->Inherited = Inherited;
    7560           6 :   A->IsPackExpansion = IsPackExpansion;
    7561           6 :   A->Implicit = Implicit;
    7562           6 :   return A;
    7563             : }
    7564             : 
    7565           0 : void ReturnTypestateAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    7566           0 :   switch (SpellingListIndex) {
    7567           0 :   default:
    7568           0 :     llvm_unreachable("Unknown attribute spelling!");
    7569             :     break;
    7570           0 :   case 0 : {
    7571           0 :     OS << " __attribute__((return_typestate(\"" << ReturnTypestateAttr::ConvertConsumedStateToStr(getState()) << "\")))";
    7572           0 :     break;
    7573             :   }
    7574           0 :   case 1 : {
    7575           0 :     OS << " [[clang::return_typestate(\"" << ReturnTypestateAttr::ConvertConsumedStateToStr(getState()) << "\")]]";
    7576           0 :     break;
    7577             :   }
    7578             : }
    7579           0 : }
    7580             : 
    7581           0 : const char *ReturnTypestateAttr::getSpelling() const {
    7582           0 :   switch (SpellingListIndex) {
    7583           0 :   default:
    7584           0 :     llvm_unreachable("Unknown attribute spelling!");
    7585             :     return "(No spelling)";
    7586             :   case 0:
    7587             :     return "return_typestate";
    7588             :   case 1:
    7589             :     return "return_typestate";
    7590             :   }
    7591             : }
    7592             : 
    7593           1 : ReturnsNonNullAttr *ReturnsNonNullAttr::clone(ASTContext &C) const {
    7594             :   auto *A = new (C) ReturnsNonNullAttr(getLocation(), C, getSpellingListIndex());
    7595           1 :   A->Inherited = Inherited;
    7596           1 :   A->IsPackExpansion = IsPackExpansion;
    7597           1 :   A->Implicit = Implicit;
    7598           1 :   return A;
    7599             : }
    7600             : 
    7601           0 : void ReturnsNonNullAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    7602           0 :   switch (SpellingListIndex) {
    7603           0 :   default:
    7604           0 :     llvm_unreachable("Unknown attribute spelling!");
    7605             :     break;
    7606           0 :   case 0 : {
    7607           0 :     OS << " __attribute__((returns_nonnull))";
    7608           0 :     break;
    7609             :   }
    7610           0 :   case 1 : {
    7611           0 :     OS << " [[gnu::returns_nonnull]]";
    7612           0 :     break;
    7613             :   }
    7614             : }
    7615           0 : }
    7616             : 
    7617           0 : const char *ReturnsNonNullAttr::getSpelling() const {
    7618           0 :   switch (SpellingListIndex) {
    7619           0 :   default:
    7620           0 :     llvm_unreachable("Unknown attribute spelling!");
    7621             :     return "(No spelling)";
    7622             :   case 0:
    7623             :     return "returns_nonnull";
    7624             :   case 1:
    7625             :     return "returns_nonnull";
    7626             :   }
    7627             : }
    7628             : 
    7629          41 : ReturnsTwiceAttr *ReturnsTwiceAttr::clone(ASTContext &C) const {
    7630             :   auto *A = new (C) ReturnsTwiceAttr(getLocation(), C, getSpellingListIndex());
    7631          41 :   A->Inherited = Inherited;
    7632          41 :   A->IsPackExpansion = IsPackExpansion;
    7633          41 :   A->Implicit = Implicit;
    7634          41 :   return A;
    7635             : }
    7636             : 
    7637           0 : void ReturnsTwiceAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    7638           0 :   switch (SpellingListIndex) {
    7639           0 :   default:
    7640           0 :     llvm_unreachable("Unknown attribute spelling!");
    7641             :     break;
    7642           0 :   case 0 : {
    7643           0 :     OS << " __attribute__((returns_twice))";
    7644           0 :     break;
    7645             :   }
    7646           0 :   case 1 : {
    7647           0 :     OS << " [[gnu::returns_twice]]";
    7648           0 :     break;
    7649             :   }
    7650             : }
    7651           0 : }
    7652             : 
    7653           0 : const char *ReturnsTwiceAttr::getSpelling() const {
    7654           0 :   switch (SpellingListIndex) {
    7655           0 :   default:
    7656           0 :     llvm_unreachable("Unknown attribute spelling!");
    7657             :     return "(No spelling)";
    7658             :   case 0:
    7659             :     return "returns_twice";
    7660             :   case 1:
    7661             :     return "returns_twice";
    7662             :   }
    7663             : }
    7664             : 
    7665           4 : ScopedLockableAttr *ScopedLockableAttr::clone(ASTContext &C) const {
    7666             :   auto *A = new (C) ScopedLockableAttr(getLocation(), C, getSpellingListIndex());
    7667           4 :   A->Inherited = Inherited;
    7668           4 :   A->IsPackExpansion = IsPackExpansion;
    7669           4 :   A->Implicit = Implicit;
    7670           4 :   return A;
    7671             : }
    7672             : 
    7673           0 : void ScopedLockableAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    7674           0 :   switch (SpellingListIndex) {
    7675           0 :   default:
    7676           0 :     llvm_unreachable("Unknown attribute spelling!");
    7677             :     break;
    7678           0 :   case 0 : {
    7679           0 :     OS << " __attribute__((scoped_lockable))";
    7680           0 :     break;
    7681             :   }
    7682           0 :   case 1 : {
    7683           0 :     OS << " [[clang::scoped_lockable]]";
    7684           0 :     break;
    7685             :   }
    7686             : }
    7687           0 : }
    7688             : 
    7689           0 : const char *ScopedLockableAttr::getSpelling() const {
    7690           0 :   switch (SpellingListIndex) {
    7691           0 :   default:
    7692           0 :     llvm_unreachable("Unknown attribute spelling!");
    7693             :     return "(No spelling)";
    7694             :   case 0:
    7695             :     return "scoped_lockable";
    7696             :   case 1:
    7697             :     return "scoped_lockable";
    7698             :   }
    7699             : }
    7700             : 
    7701           0 : SectionAttr *SectionAttr::clone(ASTContext &C) const {
    7702           0 :   auto *A = new (C) SectionAttr(getLocation(), C, getName(), getSpellingListIndex());
    7703           0 :   A->Inherited = Inherited;
    7704           0 :   A->IsPackExpansion = IsPackExpansion;
    7705           0 :   A->Implicit = Implicit;
    7706           0 :   return A;
    7707             : }
    7708             : 
    7709           0 : void SectionAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    7710           0 :   switch (SpellingListIndex) {
    7711           0 :   default:
    7712           0 :     llvm_unreachable("Unknown attribute spelling!");
    7713             :     break;
    7714           0 :   case 0 : {
    7715           0 :     OS << " __attribute__((section(\"" << getName() << "\")))";
    7716           0 :     break;
    7717             :   }
    7718           0 :   case 1 : {
    7719           0 :     OS << " [[gnu::section(\"" << getName() << "\")]]";
    7720           0 :     break;
    7721             :   }
    7722           0 :   case 2 : {
    7723           0 :     OS << " __declspec(allocate(\"" << getName() << "\"))";
    7724           0 :     break;
    7725             :   }
    7726             : }
    7727           0 : }
    7728             : 
    7729           0 : const char *SectionAttr::getSpelling() const {
    7730           0 :   switch (SpellingListIndex) {
    7731           0 :   default:
    7732           0 :     llvm_unreachable("Unknown attribute spelling!");
    7733             :     return "(No spelling)";
    7734             :   case 0:
    7735             :     return "section";
    7736             :   case 1:
    7737             :     return "section";
    7738           0 :   case 2:
    7739           0 :     return "allocate";
    7740             :   }
    7741             : }
    7742             : 
    7743           3 : SelectAnyAttr *SelectAnyAttr::clone(ASTContext &C) const {
    7744             :   auto *A = new (C) SelectAnyAttr(getLocation(), C, getSpellingListIndex());
    7745           3 :   A->Inherited = Inherited;
    7746           3 :   A->IsPackExpansion = IsPackExpansion;
    7747           3 :   A->Implicit = Implicit;
    7748           3 :   return A;
    7749             : }
    7750             : 
    7751           0 : void SelectAnyAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    7752           0 :   switch (SpellingListIndex) {
    7753           0 :   default:
    7754           0 :     llvm_unreachable("Unknown attribute spelling!");
    7755             :     break;
    7756           0 :   case 0 : {
    7757           0 :     OS << " __declspec(selectany)";
    7758           0 :     break;
    7759             :   }
    7760           0 :   case 1 : {
    7761           0 :     OS << " __attribute__((selectany))";
    7762           0 :     break;
    7763             :   }
    7764           0 :   case 2 : {
    7765           0 :     OS << " [[gnu::selectany]]";
    7766           0 :     break;
    7767             :   }
    7768             : }
    7769           0 : }
    7770             : 
    7771           0 : const char *SelectAnyAttr::getSpelling() const {
    7772           0 :   switch (SpellingListIndex) {
    7773           0 :   default:
    7774           0 :     llvm_unreachable("Unknown attribute spelling!");
    7775             :     return "(No spelling)";
    7776             :   case 0:
    7777             :     return "selectany";
    7778             :   case 1:
    7779             :     return "selectany";
    7780             :   case 2:
    7781             :     return "selectany";
    7782             :   }
    7783             : }
    7784             : 
    7785           0 : SentinelAttr *SentinelAttr::clone(ASTContext &C) const {
    7786           0 :   auto *A = new (C) SentinelAttr(getLocation(), C, sentinel, nullPos, getSpellingListIndex());
    7787           0 :   A->Inherited = Inherited;
    7788           0 :   A->IsPackExpansion = IsPackExpansion;
    7789           0 :   A->Implicit = Implicit;
    7790           0 :   return A;
    7791             : }
    7792             : 
    7793           0 : void SentinelAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    7794           0 :   switch (SpellingListIndex) {
    7795           0 :   default:
    7796           0 :     llvm_unreachable("Unknown attribute spelling!");
    7797             :     break;
    7798           0 :   case 0 : {
    7799           0 :     OS << " __attribute__((sentinel(" << getSentinel() << ", " << getNullPos() << ")))";
    7800           0 :     break;
    7801             :   }
    7802           0 :   case 1 : {
    7803           0 :     OS << " [[gnu::sentinel(" << getSentinel() << ", " << getNullPos() << ")]]";
    7804           0 :     break;
    7805             :   }
    7806             : }
    7807           0 : }
    7808             : 
    7809           0 : const char *SentinelAttr::getSpelling() const {
    7810           0 :   switch (SpellingListIndex) {
    7811           0 :   default:
    7812           0 :     llvm_unreachable("Unknown attribute spelling!");
    7813             :     return "(No spelling)";
    7814             :   case 0:
    7815             :     return "sentinel";
    7816             :   case 1:
    7817             :     return "sentinel";
    7818             :   }
    7819             : }
    7820             : 
    7821           8 : SetTypestateAttr *SetTypestateAttr::clone(ASTContext &C) const {
    7822           8 :   auto *A = new (C) SetTypestateAttr(getLocation(), C, newState, getSpellingListIndex());
    7823           8 :   A->Inherited = Inherited;
    7824           8 :   A->IsPackExpansion = IsPackExpansion;
    7825           8 :   A->Implicit = Implicit;
    7826           8 :   return A;
    7827             : }
    7828             : 
    7829           0 : void SetTypestateAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    7830           0 :   switch (SpellingListIndex) {
    7831           0 :   default:
    7832           0 :     llvm_unreachable("Unknown attribute spelling!");
    7833             :     break;
    7834           0 :   case 0 : {
    7835           0 :     OS << " __attribute__((set_typestate(\"" << SetTypestateAttr::ConvertConsumedStateToStr(getNewState()) << "\")))";
    7836           0 :     break;
    7837             :   }
    7838           0 :   case 1 : {
    7839           0 :     OS << " [[clang::set_typestate(\"" << SetTypestateAttr::ConvertConsumedStateToStr(getNewState()) << "\")]]";
    7840           0 :     break;
    7841             :   }
    7842             : }
    7843           0 : }
    7844             : 
    7845           0 : const char *SetTypestateAttr::getSpelling() const {
    7846           0 :   switch (SpellingListIndex) {
    7847           0 :   default:
    7848           0 :     llvm_unreachable("Unknown attribute spelling!");
    7849             :     return "(No spelling)";
    7850             :   case 0:
    7851             :     return "set_typestate";
    7852             :   case 1:
    7853             :     return "set_typestate";
    7854             :   }
    7855             : }
    7856             : 
    7857           9 : SharedTrylockFunctionAttr *SharedTrylockFunctionAttr::clone(ASTContext &C) const {
    7858           9 :   auto *A = new (C) SharedTrylockFunctionAttr(getLocation(), C, successValue, args_, args_Size, getSpellingListIndex());
    7859           9 :   A->Inherited = Inherited;
    7860           9 :   A->IsPackExpansion = IsPackExpansion;
    7861           9 :   A->Implicit = Implicit;
    7862           9 :   return A;
    7863             : }
    7864             : 
    7865           0 : void SharedTrylockFunctionAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    7866           0 :   switch (SpellingListIndex) {
    7867           0 :   default:
    7868           0 :     llvm_unreachable("Unknown attribute spelling!");
    7869             :     break;
    7870           0 :   case 0 : {
    7871           0 :     OS << " __attribute__((shared_trylock_function(" << getSuccessValue() << ", ";
    7872             :   bool isFirst = true;
    7873           0 :   for (const auto &Val : args()) {
    7874           0 :     if (isFirst) isFirst = false;
    7875           0 :     else OS << ", ";
    7876           0 :     OS << Val;
    7877             :   }
    7878           0 :   OS << ")))";
    7879             :     break;
    7880             :   }
    7881             : }
    7882           0 : }
    7883             : 
    7884           0 : const char *SharedTrylockFunctionAttr::getSpelling() const {
    7885           0 :   switch (SpellingListIndex) {
    7886           0 :   default:
    7887           0 :     llvm_unreachable("Unknown attribute spelling!");
    7888             :     return "(No spelling)";
    7889           0 :   case 0:
    7890             :     return "shared_trylock_function";
    7891             :   }
    7892             : }
    7893             : 
    7894           0 : StdCallAttr *StdCallAttr::clone(ASTContext &C) const {
    7895             :   auto *A = new (C) StdCallAttr(getLocation(), C, getSpellingListIndex());
    7896           0 :   A->Inherited = Inherited;
    7897           0 :   A->IsPackExpansion = IsPackExpansion;
    7898           0 :   A->Implicit = Implicit;
    7899           0 :   return A;
    7900             : }
    7901             : 
    7902           0 : void StdCallAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    7903           0 :   switch (SpellingListIndex) {
    7904           0 :   default:
    7905           0 :     llvm_unreachable("Unknown attribute spelling!");
    7906             :     break;
    7907           0 :   case 0 : {
    7908           0 :     OS << " __attribute__((stdcall))";
    7909           0 :     break;
    7910             :   }
    7911           0 :   case 1 : {
    7912           0 :     OS << " [[gnu::stdcall]]";
    7913           0 :     break;
    7914             :   }
    7915           0 :   case 2 : {
    7916           0 :     OS << " __stdcall";
    7917           0 :     break;
    7918             :   }
    7919           0 :   case 3 : {
    7920           0 :     OS << " _stdcall";
    7921           0 :     break;
    7922             :   }
    7923             : }
    7924           0 : }
    7925             : 
    7926           0 : const char *StdCallAttr::getSpelling() const {
    7927           0 :   switch (SpellingListIndex) {
    7928           0 :   default:
    7929           0 :     llvm_unreachable("Unknown attribute spelling!");
    7930             :     return "(No spelling)";
    7931             :   case 0:
    7932             :     return "stdcall";
    7933             :   case 1:
    7934             :     return "stdcall";
    7935           0 :   case 2:
    7936           0 :     return "__stdcall";
    7937           0 :   case 3:
    7938           0 :     return "_stdcall";
    7939             :   }
    7940             : }
    7941             : 
    7942           0 : SuppressAttr *SuppressAttr::clone(ASTContext &C) const {
    7943           0 :   auto *A = new (C) SuppressAttr(getLocation(), C, diagnosticIdentifiers_, diagnosticIdentifiers_Size, getSpellingListIndex());
    7944           0 :   A->Inherited = Inherited;
    7945           0 :   A->IsPackExpansion = IsPackExpansion;
    7946           0 :   A->Implicit = Implicit;
    7947           0 :   return A;
    7948             : }
    7949             : 
    7950           0 : void SuppressAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    7951           0 :   switch (SpellingListIndex) {
    7952           0 :   default:
    7953           0 :     llvm_unreachable("Unknown attribute spelling!");
    7954             :     break;
    7955           0 :   case 0 : {
    7956           0 :     OS << " [[gsl::suppress(";
    7957             :   bool isFirst = true;
    7958           0 :   for (const auto &Val : diagnosticIdentifiers()) {
    7959           0 :     if (isFirst) isFirst = false;
    7960           0 :     else OS << ", ";
    7961           0 :     OS << "\"" << Val << "\"";
    7962             :   }
    7963           0 :   OS << ")]]";
    7964             :     break;
    7965             :   }
    7966             : }
    7967           0 : }
    7968             : 
    7969           0 : const char *SuppressAttr::getSpelling() const {
    7970           0 :   switch (SpellingListIndex) {
    7971           0 :   default:
    7972           0 :     llvm_unreachable("Unknown attribute spelling!");
    7973             :     return "(No spelling)";
    7974           0 :   case 0:
    7975             :     return "suppress";
    7976             :   }
    7977             : }
    7978             : 
    7979           0 : SwiftCallAttr *SwiftCallAttr::clone(ASTContext &C) const {
    7980             :   auto *A = new (C) SwiftCallAttr(getLocation(), C, getSpellingListIndex());
    7981           0 :   A->Inherited = Inherited;
    7982           0 :   A->IsPackExpansion = IsPackExpansion;
    7983           0 :   A->Implicit = Implicit;
    7984           0 :   return A;
    7985             : }
    7986             : 
    7987           0 : void SwiftCallAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    7988           0 :   switch (SpellingListIndex) {
    7989           0 :   default:
    7990           0 :     llvm_unreachable("Unknown attribute spelling!");
    7991             :     break;
    7992           0 :   case 0 : {
    7993           0 :     OS << " __attribute__((swiftcall))";
    7994           0 :     break;
    7995             :   }
    7996           0 :   case 1 : {
    7997           0 :     OS << " [[clang::swiftcall]]";
    7998           0 :     break;
    7999             :   }
    8000           0 :   case 2 : {
    8001           0 :     OS << " [[clang::swiftcall]]";
    8002           0 :     break;
    8003             :   }
    8004             : }
    8005           0 : }
    8006             : 
    8007           0 : const char *SwiftCallAttr::getSpelling() const {
    8008           0 :   switch (SpellingListIndex) {
    8009           0 :   default:
    8010           0 :     llvm_unreachable("Unknown attribute spelling!");
    8011             :     return "(No spelling)";
    8012             :   case 0:
    8013             :     return "swiftcall";
    8014             :   case 1:
    8015             :     return "swiftcall";
    8016             :   case 2:
    8017             :     return "swiftcall";
    8018             :   }
    8019             : }
    8020             : 
    8021           0 : SwiftContextAttr *SwiftContextAttr::clone(ASTContext &C) const {
    8022             :   auto *A = new (C) SwiftContextAttr(getLocation(), C, getSpellingListIndex());
    8023           0 :   A->Inherited = Inherited;
    8024           0 :   A->IsPackExpansion = IsPackExpansion;
    8025           0 :   A->Implicit = Implicit;
    8026           0 :   return A;
    8027             : }
    8028             : 
    8029           0 : void SwiftContextAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    8030           0 :   switch (SpellingListIndex) {
    8031           0 :   default:
    8032           0 :     llvm_unreachable("Unknown attribute spelling!");
    8033             :     break;
    8034           0 :   case 0 : {
    8035           0 :     OS << " __attribute__((swift_context))";
    8036           0 :     break;
    8037             :   }
    8038           0 :   case 1 : {
    8039           0 :     OS << " [[clang::swift_context]]";
    8040           0 :     break;
    8041             :   }
    8042           0 :   case 2 : {
    8043           0 :     OS << " [[clang::swift_context]]";
    8044           0 :     break;
    8045             :   }
    8046             : }
    8047           0 : }
    8048             : 
    8049           0 : const char *SwiftContextAttr::getSpelling() const {
    8050           0 :   switch (SpellingListIndex) {
    8051           0 :   default:
    8052           0 :     llvm_unreachable("Unknown attribute spelling!");
    8053             :     return "(No spelling)";
    8054             :   case 0:
    8055             :     return "swift_context";
    8056             :   case 1:
    8057             :     return "swift_context";
    8058             :   case 2:
    8059             :     return "swift_context";
    8060             :   }
    8061             : }
    8062             : 
    8063           0 : SwiftErrorResultAttr *SwiftErrorResultAttr::clone(ASTContext &C) const {
    8064             :   auto *A = new (C) SwiftErrorResultAttr(getLocation(), C, getSpellingListIndex());
    8065           0 :   A->Inherited = Inherited;
    8066           0 :   A->IsPackExpansion = IsPackExpansion;
    8067           0 :   A->Implicit = Implicit;
    8068           0 :   return A;
    8069             : }
    8070             : 
    8071           0 : void SwiftErrorResultAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    8072           0 :   switch (SpellingListIndex) {
    8073           0 :   default:
    8074           0 :     llvm_unreachable("Unknown attribute spelling!");
    8075             :     break;
    8076           0 :   case 0 : {
    8077           0 :     OS << " __attribute__((swift_error_result))";
    8078           0 :     break;
    8079             :   }
    8080           0 :   case 1 : {
    8081           0 :     OS << " [[clang::swift_error_result]]";
    8082           0 :     break;
    8083             :   }
    8084           0 :   case 2 : {
    8085           0 :     OS << " [[clang::swift_error_result]]";
    8086           0 :     break;
    8087             :   }
    8088             : }
    8089           0 : }
    8090             : 
    8091           0 : const char *SwiftErrorResultAttr::getSpelling() const {
    8092           0 :   switch (SpellingListIndex) {
    8093           0 :   default:
    8094           0 :     llvm_unreachable("Unknown attribute spelling!");
    8095             :     return "(No spelling)";
    8096             :   case 0:
    8097             :     return "swift_error_result";
    8098             :   case 1:
    8099             :     return "swift_error_result";
    8100             :   case 2:
    8101             :     return "swift_error_result";
    8102             :   }
    8103             : }
    8104             : 
    8105           0 : SwiftIndirectResultAttr *SwiftIndirectResultAttr::clone(ASTContext &C) const {
    8106             :   auto *A = new (C) SwiftIndirectResultAttr(getLocation(), C, getSpellingListIndex());
    8107           0 :   A->Inherited = Inherited;
    8108           0 :   A->IsPackExpansion = IsPackExpansion;
    8109           0 :   A->Implicit = Implicit;
    8110           0 :   return A;
    8111             : }
    8112             : 
    8113           0 : void SwiftIndirectResultAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    8114           0 :   switch (SpellingListIndex) {
    8115           0 :   default:
    8116           0 :     llvm_unreachable("Unknown attribute spelling!");
    8117             :     break;
    8118           0 :   case 0 : {
    8119           0 :     OS << " __attribute__((swift_indirect_result))";
    8120           0 :     break;
    8121             :   }
    8122           0 :   case 1 : {
    8123           0 :     OS << " [[clang::swift_indirect_result]]";
    8124           0 :     break;
    8125             :   }
    8126           0 :   case 2 : {
    8127           0 :     OS << " [[clang::swift_indirect_result]]";
    8128           0 :     break;
    8129             :   }
    8130             : }
    8131           0 : }
    8132             : 
    8133           0 : const char *SwiftIndirectResultAttr::getSpelling() const {
    8134           0 :   switch (SpellingListIndex) {
    8135           0 :   default:
    8136           0 :     llvm_unreachable("Unknown attribute spelling!");
    8137             :     return "(No spelling)";
    8138             :   case 0:
    8139             :     return "swift_indirect_result";
    8140             :   case 1:
    8141             :     return "swift_indirect_result";
    8142             :   case 2:
    8143             :     return "swift_indirect_result";
    8144             :   }
    8145             : }
    8146             : 
    8147           0 : SysVABIAttr *SysVABIAttr::clone(ASTContext &C) const {
    8148             :   auto *A = new (C) SysVABIAttr(getLocation(), C, getSpellingListIndex());
    8149           0 :   A->Inherited = Inherited;
    8150           0 :   A->IsPackExpansion = IsPackExpansion;
    8151           0 :   A->Implicit = Implicit;
    8152           0 :   return A;
    8153             : }
    8154             : 
    8155           0 : void SysVABIAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    8156           0 :   switch (SpellingListIndex) {
    8157           0 :   default:
    8158           0 :     llvm_unreachable("Unknown attribute spelling!");
    8159             :     break;
    8160           0 :   case 0 : {
    8161           0 :     OS << " __attribute__((sysv_abi))";
    8162           0 :     break;
    8163             :   }
    8164           0 :   case 1 : {
    8165           0 :     OS << " [[gnu::sysv_abi]]";
    8166           0 :     break;
    8167             :   }
    8168             : }
    8169           0 : }
    8170             : 
    8171           0 : const char *SysVABIAttr::getSpelling() const {
    8172           0 :   switch (SpellingListIndex) {
    8173           0 :   default:
    8174           0 :     llvm_unreachable("Unknown attribute spelling!");
    8175             :     return "(No spelling)";
    8176             :   case 0:
    8177             :     return "sysv_abi";
    8178             :   case 1:
    8179             :     return "sysv_abi";
    8180             :   }
    8181             : }
    8182             : 
    8183           3 : TLSModelAttr *TLSModelAttr::clone(ASTContext &C) const {
    8184           9 :   auto *A = new (C) TLSModelAttr(getLocation(), C, getModel(), getSpellingListIndex());
    8185           3 :   A->Inherited = Inherited;
    8186           3 :   A->IsPackExpansion = IsPackExpansion;
    8187           3 :   A->Implicit = Implicit;
    8188           3 :   return A;
    8189             : }
    8190             : 
    8191           0 : void TLSModelAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    8192           0 :   switch (SpellingListIndex) {
    8193           0 :   default:
    8194           0 :     llvm_unreachable("Unknown attribute spelling!");
    8195             :     break;
    8196           0 :   case 0 : {
    8197           0 :     OS << " __attribute__((tls_model(\"" << getModel() << "\")))";
    8198           0 :     break;
    8199             :   }
    8200           0 :   case 1 : {
    8201           0 :     OS << " [[gnu::tls_model(\"" << getModel() << "\")]]";
    8202           0 :     break;
    8203             :   }
    8204             : }
    8205           0 : }
    8206             : 
    8207           0 : const char *TLSModelAttr::getSpelling() const {
    8208           0 :   switch (SpellingListIndex) {
    8209           0 :   default:
    8210           0 :     llvm_unreachable("Unknown attribute spelling!");
    8211             :     return "(No spelling)";
    8212             :   case 0:
    8213             :     return "tls_model";
    8214             :   case 1:
    8215             :     return "tls_model";
    8216             :   }
    8217             : }
    8218             : 
    8219          15 : TargetAttr *TargetAttr::clone(ASTContext &C) const {
    8220          45 :   auto *A = new (C) TargetAttr(getLocation(), C, getFeaturesStr(), getSpellingListIndex());
    8221          15 :   A->Inherited = Inherited;
    8222          15 :   A->IsPackExpansion = IsPackExpansion;
    8223          15 :   A->Implicit = Implicit;
    8224          15 :   return A;
    8225             : }
    8226             : 
    8227           0 : void TargetAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    8228           0 :   switch (SpellingListIndex) {
    8229           0 :   default:
    8230           0 :     llvm_unreachable("Unknown attribute spelling!");
    8231             :     break;
    8232           0 :   case 0 : {
    8233           0 :     OS << " __attribute__((target(\"" << getFeaturesStr() << "\")))";
    8234           0 :     break;
    8235             :   }
    8236           0 :   case 1 : {
    8237           0 :     OS << " [[gnu::target(\"" << getFeaturesStr() << "\")]]";
    8238           0 :     break;
    8239             :   }
    8240             : }
    8241           0 : }
    8242             : 
    8243           0 : const char *TargetAttr::getSpelling() const {
    8244           0 :   switch (SpellingListIndex) {
    8245           0 :   default:
    8246           0 :     llvm_unreachable("Unknown attribute spelling!");
    8247             :     return "(No spelling)";
    8248             :   case 0:
    8249             :     return "target";
    8250             :   case 1:
    8251             :     return "target";
    8252             :   }
    8253             : }
    8254             : 
    8255           8 : TestTypestateAttr *TestTypestateAttr::clone(ASTContext &C) const {
    8256           8 :   auto *A = new (C) TestTypestateAttr(getLocation(), C, testState, getSpellingListIndex());
    8257           8 :   A->Inherited = Inherited;
    8258           8 :   A->IsPackExpansion = IsPackExpansion;
    8259           8 :   A->Implicit = Implicit;
    8260           8 :   return A;
    8261             : }
    8262             : 
    8263           0 : void TestTypestateAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    8264           0 :   switch (SpellingListIndex) {
    8265           0 :   default:
    8266           0 :     llvm_unreachable("Unknown attribute spelling!");
    8267             :     break;
    8268           0 :   case 0 : {
    8269           0 :     OS << " __attribute__((test_typestate(\"" << TestTypestateAttr::ConvertConsumedStateToStr(getTestState()) << "\")))";
    8270           0 :     break;
    8271             :   }
    8272           0 :   case 1 : {
    8273           0 :     OS << " [[clang::test_typestate(\"" << TestTypestateAttr::ConvertConsumedStateToStr(getTestState()) << "\")]]";
    8274           0 :     break;
    8275             :   }
    8276             : }
    8277           0 : }
    8278             : 
    8279           0 : const char *TestTypestateAttr::getSpelling() const {
    8280           0 :   switch (SpellingListIndex) {
    8281           0 :   default:
    8282           0 :     llvm_unreachable("Unknown attribute spelling!");
    8283             :     return "(No spelling)";
    8284             :   case 0:
    8285             :     return "test_typestate";
    8286             :   case 1:
    8287             :     return "test_typestate";
    8288             :   }
    8289             : }
    8290             : 
    8291           0 : ThisCallAttr *ThisCallAttr::clone(ASTContext &C) const {
    8292             :   auto *A = new (C) ThisCallAttr(getLocation(), C, getSpellingListIndex());
    8293           0 :   A->Inherited = Inherited;
    8294           0 :   A->IsPackExpansion = IsPackExpansion;
    8295           0 :   A->Implicit = Implicit;
    8296           0 :   return A;
    8297             : }
    8298             : 
    8299           0 : void ThisCallAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    8300           0 :   switch (SpellingListIndex) {
    8301           0 :   default:
    8302           0 :     llvm_unreachable("Unknown attribute spelling!");
    8303             :     break;
    8304           0 :   case 0 : {
    8305           0 :     OS << " __attribute__((thiscall))";
    8306           0 :     break;
    8307             :   }
    8308           0 :   case 1 : {
    8309           0 :     OS << " [[gnu::thiscall]]";
    8310           0 :     break;
    8311             :   }
    8312           0 :   case 2 : {
    8313           0 :     OS << " __thiscall";
    8314           0 :     break;
    8315             :   }
    8316           0 :   case 3 : {
    8317           0 :     OS << " _thiscall";
    8318           0 :     break;
    8319             :   }
    8320             : }
    8321           0 : }
    8322             : 
    8323           0 : const char *ThisCallAttr::getSpelling() const {
    8324           0 :   switch (SpellingListIndex) {
    8325           0 :   default:
    8326           0 :     llvm_unreachable("Unknown attribute spelling!");
    8327             :     return "(No spelling)";
    8328             :   case 0:
    8329             :     return "thiscall";
    8330             :   case 1:
    8331             :     return "thiscall";
    8332           0 :   case 2:
    8333           0 :     return "__thiscall";
    8334           0 :   case 3:
    8335           0 :     return "_thiscall";
    8336             :   }
    8337             : }
    8338             : 
    8339           0 : ThreadAttr *ThreadAttr::clone(ASTContext &C) const {
    8340             :   auto *A = new (C) ThreadAttr(getLocation(), C, getSpellingListIndex());
    8341           0 :   A->Inherited = Inherited;
    8342           0 :   A->IsPackExpansion = IsPackExpansion;
    8343           0 :   A->Implicit = Implicit;
    8344           0 :   return A;
    8345             : }
    8346             : 
    8347           1 : void ThreadAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    8348           1 :   switch (SpellingListIndex) {
    8349           0 :   default:
    8350           0 :     llvm_unreachable("Unknown attribute spelling!");
    8351             :     break;
    8352           1 :   case 0 : {
    8353           1 :     OS << " __declspec(thread)";
    8354             :     break;
    8355             :   }
    8356             : }
    8357           1 : }
    8358             : 
    8359           0 : const char *ThreadAttr::getSpelling() const {
    8360           0 :   switch (SpellingListIndex) {
    8361           0 :   default:
    8362           0 :     llvm_unreachable("Unknown attribute spelling!");
    8363             :     return "(No spelling)";
    8364           0 :   case 0:
    8365             :     return "thread";
    8366             :   }
    8367             : }
    8368             : 
    8369           0 : TransparentUnionAttr *TransparentUnionAttr::clone(ASTContext &C) const {
    8370             :   auto *A = new (C) TransparentUnionAttr(getLocation(), C, getSpellingListIndex());
    8371           0 :   A->Inherited = Inherited;
    8372           0 :   A->IsPackExpansion = IsPackExpansion;
    8373           0 :   A->Implicit = Implicit;
    8374           0 :   return A;
    8375             : }
    8376             : 
    8377           0 : void TransparentUnionAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    8378           0 :   switch (SpellingListIndex) {
    8379           0 :   default:
    8380           0 :     llvm_unreachable("Unknown attribute spelling!");
    8381             :     break;
    8382           0 :   case 0 : {
    8383           0 :     OS << " __attribute__((transparent_union))";
    8384           0 :     break;
    8385             :   }
    8386           0 :   case 1 : {
    8387           0 :     OS << " [[gnu::transparent_union]]";
    8388           0 :     break;
    8389             :   }
    8390             : }
    8391           0 : }
    8392             : 
    8393           0 : const char *TransparentUnionAttr::getSpelling() const {
    8394           0 :   switch (SpellingListIndex) {
    8395           0 :   default:
    8396           0 :     llvm_unreachable("Unknown attribute spelling!");
    8397             :     return "(No spelling)";
    8398             :   case 0:
    8399             :     return "transparent_union";
    8400             :   case 1:
    8401             :     return "transparent_union";
    8402             :   }
    8403             : }
    8404             : 
    8405           6 : TrivialABIAttr *TrivialABIAttr::clone(ASTContext &C) const {
    8406             :   auto *A = new (C) TrivialABIAttr(getLocation(), C, getSpellingListIndex());
    8407           6 :   A->Inherited = Inherited;
    8408           6 :   A->IsPackExpansion = IsPackExpansion;
    8409           6 :   A->Implicit = Implicit;
    8410           6 :   return A;
    8411             : }
    8412             : 
    8413           0 : void TrivialABIAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    8414           0 :   switch (SpellingListIndex) {
    8415           0 :   default:
    8416           0 :     llvm_unreachable("Unknown attribute spelling!");
    8417             :     break;
    8418           0 :   case 0 : {
    8419           0 :     OS << " __attribute__((trivial_abi))";
    8420           0 :     break;
    8421             :   }
    8422           0 :   case 1 : {
    8423           0 :     OS << " [[clang::trivial_abi]]";
    8424           0 :     break;
    8425             :   }
    8426             : }
    8427           0 : }
    8428             : 
    8429           0 : const char *TrivialABIAttr::getSpelling() const {
    8430           0 :   switch (SpellingListIndex) {
    8431           0 :   default:
    8432           0 :     llvm_unreachable("Unknown attribute spelling!");
    8433             :     return "(No spelling)";
    8434             :   case 0:
    8435             :     return "trivial_abi";
    8436             :   case 1:
    8437             :     return "trivial_abi";
    8438             :   }
    8439             : }
    8440             : 
    8441           5 : TryAcquireCapabilityAttr *TryAcquireCapabilityAttr::clone(ASTContext &C) const {
    8442           5 :   auto *A = new (C) TryAcquireCapabilityAttr(getLocation(), C, successValue, args_, args_Size, getSpellingListIndex());
    8443           5 :   A->Inherited = Inherited;
    8444           5 :   A->IsPackExpansion = IsPackExpansion;
    8445           5 :   A->Implicit = Implicit;
    8446           5 :   return A;
    8447             : }
    8448             : 
    8449           0 : void TryAcquireCapabilityAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    8450           0 :   switch (SpellingListIndex) {
    8451           0 :   default:
    8452           0 :     llvm_unreachable("Unknown attribute spelling!");
    8453             :     break;
    8454           0 :   case 0 : {
    8455           0 :     OS << " __attribute__((try_acquire_capability(" << getSuccessValue() << ", ";
    8456             :   bool isFirst = true;
    8457           0 :   for (const auto &Val : args()) {
    8458           0 :     if (isFirst) isFirst = false;
    8459           0 :     else OS << ", ";
    8460           0 :     OS << Val;
    8461             :   }
    8462           0 :   OS << ")))";
    8463           0 :     break;
    8464             :   }
    8465           0 :   case 1 : {
    8466           0 :     OS << " [[clang::try_acquire_capability(" << getSuccessValue() << ", ";
    8467             :   bool isFirst = true;
    8468           0 :   for (const auto &Val : args()) {
    8469           0 :     if (isFirst) isFirst = false;
    8470           0 :     else OS << ", ";
    8471           0 :     OS << Val;
    8472             :   }
    8473           0 :   OS << ")]]";
    8474           0 :     break;
    8475             :   }
    8476           0 :   case 2 : {
    8477           0 :     OS << " __attribute__((try_acquire_shared_capability(" << getSuccessValue() << ", ";
    8478             :   bool isFirst = true;
    8479           0 :   for (const auto &Val : args()) {
    8480           0 :     if (isFirst) isFirst = false;
    8481           0 :     else OS << ", ";
    8482           0 :     OS << Val;
    8483             :   }
    8484           0 :   OS << ")))";
    8485           0 :     break;
    8486             :   }
    8487           0 :   case 3 : {
    8488           0 :     OS << " [[clang::try_acquire_shared_capability(" << getSuccessValue() << ", ";
    8489             :   bool isFirst = true;
    8490           0 :   for (const auto &Val : args()) {
    8491           0 :     if (isFirst) isFirst = false;
    8492           0 :     else OS << ", ";
    8493           0 :     OS << Val;
    8494             :   }
    8495           0 :   OS << ")]]";
    8496           0 :     break;
    8497             :   }
    8498             : }
    8499           0 : }
    8500             : 
    8501           0 : const char *TryAcquireCapabilityAttr::getSpelling() const {
    8502           0 :   switch (SpellingListIndex) {
    8503           0 :   default:
    8504           0 :     llvm_unreachable("Unknown attribute spelling!");
    8505             :     return "(No spelling)";
    8506             :   case 0:
    8507             :     return "try_acquire_capability";
    8508             :   case 1:
    8509             :     return "try_acquire_capability";
    8510           0 :   case 2:
    8511           0 :     return "try_acquire_shared_capability";
    8512           0 :   case 3:
    8513           0 :     return "try_acquire_shared_capability";
    8514             :   }
    8515             : }
    8516             : 
    8517           0 : TypeTagForDatatypeAttr *TypeTagForDatatypeAttr::clone(ASTContext &C) const {
    8518           0 :   auto *A = new (C) TypeTagForDatatypeAttr(getLocation(), C, argumentKind, matchingCType, layoutCompatible, mustBeNull, getSpellingListIndex());
    8519           0 :   A->Inherited = Inherited;
    8520           0 :   A->IsPackExpansion = IsPackExpansion;
    8521           0 :   A->Implicit = Implicit;
    8522           0 :   return A;
    8523             : }
    8524             : 
    8525           0 : void TypeTagForDatatypeAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    8526           0 :   switch (SpellingListIndex) {
    8527           0 :   default:
    8528           0 :     llvm_unreachable("Unknown attribute spelling!");
    8529             :     break;
    8530           0 :   case 0 : {
    8531           0 :     OS << " __attribute__((type_tag_for_datatype(" << (getArgumentKind() ? getArgumentKind()->getName() : "") << ", " << getMatchingCType().getAsString() << ", " << getLayoutCompatible() << ", " << getMustBeNull() << ")))";
    8532           0 :     break;
    8533             :   }
    8534           0 :   case 1 : {
    8535           0 :     OS << " [[clang::type_tag_for_datatype(" << (getArgumentKind() ? getArgumentKind()->getName() : "") << ", " << getMatchingCType().getAsString() << ", " << getLayoutCompatible() << ", " << getMustBeNull() << ")]]";
    8536           0 :     break;
    8537             :   }
    8538           0 :   case 2 : {
    8539           0 :     OS << " [[clang::type_tag_for_datatype(" << (getArgumentKind() ? getArgumentKind()->getName() : "") << ", " << getMatchingCType().getAsString() << ", " << getLayoutCompatible() << ", " << getMustBeNull() << ")]]";
    8540           0 :     break;
    8541             :   }
    8542             : }
    8543           0 : }
    8544             : 
    8545           0 : const char *TypeTagForDatatypeAttr::getSpelling() const {
    8546           0 :   switch (SpellingListIndex) {
    8547           0 :   default:
    8548           0 :     llvm_unreachable("Unknown attribute spelling!");
    8549             :     return "(No spelling)";
    8550             :   case 0:
    8551             :     return "type_tag_for_datatype";
    8552             :   case 1:
    8553             :     return "type_tag_for_datatype";
    8554             :   case 2:
    8555             :     return "type_tag_for_datatype";
    8556             :   }
    8557             : }
    8558             : 
    8559         315 : TypeVisibilityAttr *TypeVisibilityAttr::clone(ASTContext &C) const {
    8560         315 :   auto *A = new (C) TypeVisibilityAttr(getLocation(), C, visibility, getSpellingListIndex());
    8561         315 :   A->Inherited = Inherited;
    8562         315 :   A->IsPackExpansion = IsPackExpansion;
    8563         315 :   A->Implicit = Implicit;
    8564         315 :   return A;
    8565             : }
    8566             : 
    8567           0 : void TypeVisibilityAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    8568           0 :   switch (SpellingListIndex) {
    8569           0 :   default:
    8570           0 :     llvm_unreachable("Unknown attribute spelling!");
    8571             :     break;
    8572           0 :   case 0 : {
    8573           0 :     OS << " __attribute__((type_visibility(\"" << TypeVisibilityAttr::ConvertVisibilityTypeToStr(getVisibility()) << "\")))";
    8574           0 :     break;
    8575             :   }
    8576           0 :   case 1 : {
    8577           0 :     OS << " [[clang::type_visibility(\"" << TypeVisibilityAttr::ConvertVisibilityTypeToStr(getVisibility()) << "\")]]";
    8578           0 :     break;
    8579             :   }
    8580           0 :   case 2 : {
    8581           0 :     OS << " [[clang::type_visibility(\"" << TypeVisibilityAttr::ConvertVisibilityTypeToStr(getVisibility()) << "\")]]";
    8582           0 :     break;
    8583             :   }
    8584             : }
    8585           0 : }
    8586             : 
    8587           0 : const char *TypeVisibilityAttr::getSpelling() const {
    8588           0 :   switch (SpellingListIndex) {
    8589           0 :   default:
    8590           0 :     llvm_unreachable("Unknown attribute spelling!");
    8591             :     return "(No spelling)";
    8592             :   case 0:
    8593             :     return "type_visibility";
    8594             :   case 1:
    8595             :     return "type_visibility";
    8596             :   case 2:
    8597             :     return "type_visibility";
    8598             :   }
    8599             : }
    8600             : 
    8601          58 : UnavailableAttr *UnavailableAttr::clone(ASTContext &C) const {
    8602         174 :   auto *A = new (C) UnavailableAttr(getLocation(), C, getMessage(), implicitReason, getSpellingListIndex());
    8603          58 :   A->Inherited = Inherited;
    8604          58 :   A->IsPackExpansion = IsPackExpansion;
    8605          58 :   A->Implicit = Implicit;
    8606          58 :   return A;
    8607             : }
    8608             : 
    8609           1 : void UnavailableAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    8610           1 :   switch (SpellingListIndex) {
    8611           0 :   default:
    8612           0 :     llvm_unreachable("Unknown attribute spelling!");
    8613             :     break;
    8614           1 :   case 0 : {
    8615           2 :     OS << " __attribute__((unavailable(\"" << getMessage() << "\")))";
    8616           1 :     break;
    8617             :   }
    8618           0 :   case 1 : {
    8619           0 :     OS << " [[clang::unavailable(\"" << getMessage() << "\")]]";
    8620           0 :     break;
    8621             :   }
    8622           0 :   case 2 : {
    8623           0 :     OS << " [[clang::unavailable(\"" << getMessage() << "\")]]";
    8624           0 :     break;
    8625             :   }
    8626             : }
    8627           1 : }
    8628             : 
    8629           0 : const char *UnavailableAttr::getSpelling() const {
    8630           0 :   switch (SpellingListIndex) {
    8631           0 :   default:
    8632           0 :     llvm_unreachable("Unknown attribute spelling!");
    8633             :     return "(No spelling)";
    8634             :   case 0:
    8635             :     return "unavailable";
    8636             :   case 1:
    8637             :     return "unavailable";
    8638             :   case 2:
    8639             :     return "unavailable";
    8640             :   }
    8641             : }
    8642             : 
    8643         348 : UnusedAttr *UnusedAttr::clone(ASTContext &C) const {
    8644             :   auto *A = new (C) UnusedAttr(getLocation(), C, getSpellingListIndex());
    8645         348 :   A->Inherited = Inherited;
    8646         348 :   A->IsPackExpansion = IsPackExpansion;
    8647         348 :   A->Implicit = Implicit;
    8648         348 :   return A;
    8649             : }
    8650             : 
    8651           0 : void UnusedAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    8652           0 :   switch (SpellingListIndex) {
    8653           0 :   default:
    8654           0 :     llvm_unreachable("Unknown attribute spelling!");
    8655             :     break;
    8656           0 :   case 0 : {
    8657           0 :     OS << " [[maybe_unused]]";
    8658           0 :     break;
    8659             :   }
    8660           0 :   case 1 : {
    8661           0 :     OS << " __attribute__((unused))";
    8662           0 :     break;
    8663             :   }
    8664           0 :   case 2 : {
    8665           0 :     OS << " [[gnu::unused]]";
    8666           0 :     break;
    8667             :   }
    8668           0 :   case 3 : {
    8669           0 :     OS << " [[maybe_unused]]";
    8670           0 :     break;
    8671             :   }
    8672             : }
    8673           0 : }
    8674             : 
    8675           4 : const char *UnusedAttr::getSpelling() const {
    8676           4 :   switch (SpellingListIndex) {
    8677           0 :   default:
    8678           0 :     llvm_unreachable("Unknown attribute spelling!");
    8679             :     return "(No spelling)";
    8680             :   case 0:
    8681             :     return "maybe_unused";
    8682           4 :   case 1:
    8683           4 :     return "unused";
    8684           0 :   case 2:
    8685           0 :     return "unused";
    8686             :   case 3:
    8687             :     return "maybe_unused";
    8688             :   }
    8689             : }
    8690             : 
    8691          27 : UsedAttr *UsedAttr::clone(ASTContext &C) const {
    8692             :   auto *A = new (C) UsedAttr(getLocation(), C, getSpellingListIndex());
    8693          27 :   A->Inherited = Inherited;
    8694          27 :   A->IsPackExpansion = IsPackExpansion;
    8695          27 :   A->Implicit = Implicit;
    8696          27 :   return A;
    8697             : }
    8698             : 
    8699           0 : void UsedAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    8700           0 :   switch (SpellingListIndex) {
    8701           0 :   default:
    8702           0 :     llvm_unreachable("Unknown attribute spelling!");
    8703             :     break;
    8704           0 :   case 0 : {
    8705           0 :     OS << " __attribute__((used))";
    8706           0 :     break;
    8707             :   }
    8708           0 :   case 1 : {
    8709           0 :     OS << " [[gnu::used]]";
    8710           0 :     break;
    8711             :   }
    8712             : }
    8713           0 : }
    8714             : 
    8715           4 : const char *UsedAttr::getSpelling() const {
    8716           4 :   switch (SpellingListIndex) {
    8717           0 :   default:
    8718           0 :     llvm_unreachable("Unknown attribute spelling!");
    8719             :     return "(No spelling)";
    8720             :   case 0:
    8721             :     return "used";
    8722             :   case 1:
    8723             :     return "used";
    8724             :   }
    8725             : }
    8726             : 
    8727           0 : UuidAttr *UuidAttr::clone(ASTContext &C) const {
    8728           0 :   auto *A = new (C) UuidAttr(getLocation(), C, getGuid(), getSpellingListIndex());
    8729           0 :   A->Inherited = Inherited;
    8730           0 :   A->IsPackExpansion = IsPackExpansion;
    8731           0 :   A->Implicit = Implicit;
    8732           0 :   return A;
    8733             : }
    8734             : 
    8735           0 : void UuidAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    8736           0 :   switch (SpellingListIndex) {
    8737           0 :   default:
    8738           0 :     llvm_unreachable("Unknown attribute spelling!");
    8739             :     break;
    8740           0 :   case 0 : {
    8741           0 :     OS << " __declspec(uuid(\"" << getGuid() << "\"))";
    8742           0 :     break;
    8743             :   }
    8744           0 :   case 1 : {
    8745           0 :     OS << "[uuid(\"" << getGuid() << "\")]";
    8746           0 :     break;
    8747             :   }
    8748             : }
    8749           0 : }
    8750             : 
    8751           0 : const char *UuidAttr::getSpelling() const {
    8752           0 :   switch (SpellingListIndex) {
    8753           0 :   default:
    8754           0 :     llvm_unreachable("Unknown attribute spelling!");
    8755             :     return "(No spelling)";
    8756             :   case 0:
    8757             :     return "uuid";
    8758             :   case 1:
    8759             :     return "uuid";
    8760             :   }
    8761             : }
    8762             : 
    8763           0 : VecReturnAttr *VecReturnAttr::clone(ASTContext &C) const {
    8764             :   auto *A = new (C) VecReturnAttr(getLocation(), C, getSpellingListIndex());
    8765           0 :   A->Inherited = Inherited;
    8766           0 :   A->IsPackExpansion = IsPackExpansion;
    8767           0 :   A->Implicit = Implicit;
    8768           0 :   return A;
    8769             : }
    8770             : 
    8771           0 : void VecReturnAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    8772           0 :   switch (SpellingListIndex) {
    8773           0 :   default:
    8774           0 :     llvm_unreachable("Unknown attribute spelling!");
    8775             :     break;
    8776           0 :   case 0 : {
    8777           0 :     OS << " __attribute__((vecreturn))";
    8778           0 :     break;
    8779             :   }
    8780           0 :   case 1 : {
    8781           0 :     OS << " [[clang::vecreturn]]";
    8782           0 :     break;
    8783             :   }
    8784             : }
    8785           0 : }
    8786             : 
    8787           1 : const char *VecReturnAttr::getSpelling() const {
    8788           1 :   switch (SpellingListIndex) {
    8789           0 :   default:
    8790           0 :     llvm_unreachable("Unknown attribute spelling!");
    8791             :     return "(No spelling)";
    8792             :   case 0:
    8793             :     return "vecreturn";
    8794             :   case 1:
    8795             :     return "vecreturn";
    8796             :   }
    8797             : }
    8798             : 
    8799           0 : VecTypeHintAttr *VecTypeHintAttr::clone(ASTContext &C) const {
    8800           0 :   auto *A = new (C) VecTypeHintAttr(getLocation(), C, typeHint, getSpellingListIndex());
    8801           0 :   A->Inherited = Inherited;
    8802           0 :   A->IsPackExpansion = IsPackExpansion;
    8803           0 :   A->Implicit = Implicit;
    8804           0 :   return A;
    8805             : }
    8806             : 
    8807           0 : void VecTypeHintAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    8808           0 :   switch (SpellingListIndex) {
    8809           0 :   default:
    8810           0 :     llvm_unreachable("Unknown attribute spelling!");
    8811             :     break;
    8812           0 :   case 0 : {
    8813           0 :     OS << " __attribute__((vec_type_hint(" << getTypeHint().getAsString() << ")))";
    8814             :     break;
    8815             :   }
    8816             : }
    8817           0 : }
    8818             : 
    8819           2 : const char *VecTypeHintAttr::getSpelling() const {
    8820           2 :   switch (SpellingListIndex) {
    8821           0 :   default:
    8822           0 :     llvm_unreachable("Unknown attribute spelling!");
    8823             :     return "(No spelling)";
    8824           2 :   case 0:
    8825             :     return "vec_type_hint";
    8826             :   }
    8827             : }
    8828             : 
    8829           0 : VectorCallAttr *VectorCallAttr::clone(ASTContext &C) const {
    8830             :   auto *A = new (C) VectorCallAttr(getLocation(), C, getSpellingListIndex());
    8831           0 :   A->Inherited = Inherited;
    8832           0 :   A->IsPackExpansion = IsPackExpansion;
    8833           0 :   A->Implicit = Implicit;
    8834           0 :   return A;
    8835             : }
    8836             : 
    8837           0 : void VectorCallAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    8838           0 :   switch (SpellingListIndex) {
    8839           0 :   default:
    8840           0 :     llvm_unreachable("Unknown attribute spelling!");
    8841             :     break;
    8842           0 :   case 0 : {
    8843           0 :     OS << " __attribute__((vectorcall))";
    8844           0 :     break;
    8845             :   }
    8846           0 :   case 1 : {
    8847           0 :     OS << " [[clang::vectorcall]]";
    8848           0 :     break;
    8849             :   }
    8850           0 :   case 2 : {
    8851           0 :     OS << " [[clang::vectorcall]]";
    8852           0 :     break;
    8853             :   }
    8854           0 :   case 3 : {
    8855           0 :     OS << " __vectorcall";
    8856           0 :     break;
    8857             :   }
    8858           0 :   case 4 : {
    8859           0 :     OS << " _vectorcall";
    8860           0 :     break;
    8861             :   }
    8862             : }
    8863           0 : }
    8864             : 
    8865           0 : const char *VectorCallAttr::getSpelling() const {
    8866           0 :   switch (SpellingListIndex) {
    8867           0 :   default:
    8868           0 :     llvm_unreachable("Unknown attribute spelling!");
    8869             :     return "(No spelling)";
    8870             :   case 0:
    8871             :     return "vectorcall";
    8872             :   case 1:
    8873             :     return "vectorcall";
    8874             :   case 2:
    8875             :     return "vectorcall";
    8876           0 :   case 3:
    8877           0 :     return "__vectorcall";
    8878           0 :   case 4:
    8879           0 :     return "_vectorcall";
    8880             :   }
    8881             : }
    8882             : 
    8883           8 : VisibilityAttr *VisibilityAttr::clone(ASTContext &C) const {
    8884           8 :   auto *A = new (C) VisibilityAttr(getLocation(), C, visibility, getSpellingListIndex());
    8885           8 :   A->Inherited = Inherited;
    8886           8 :   A->IsPackExpansion = IsPackExpansion;
    8887           8 :   A->Implicit = Implicit;
    8888           8 :   return A;
    8889             : }
    8890             : 
    8891           3 : void VisibilityAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    8892           3 :   switch (SpellingListIndex) {
    8893           0 :   default:
    8894           0 :     llvm_unreachable("Unknown attribute spelling!");
    8895             :     break;
    8896           2 :   case 0 : {
    8897           4 :     OS << " __attribute__((visibility(\"" << VisibilityAttr::ConvertVisibilityTypeToStr(getVisibility()) << "\")))";
    8898           2 :     break;
    8899             :   }
    8900           1 :   case 1 : {
    8901           2 :     OS << " [[gnu::visibility(\"" << VisibilityAttr::ConvertVisibilityTypeToStr(getVisibility()) << "\")]]";
    8902           1 :     break;
    8903             :   }
    8904             : }
    8905           3 : }
    8906             : 
    8907           0 : const char *VisibilityAttr::getSpelling() const {
    8908           0 :   switch (SpellingListIndex) {
    8909           0 :   default:
    8910           0 :     llvm_unreachable("Unknown attribute spelling!");
    8911             :     return "(No spelling)";
    8912             :   case 0:
    8913             :     return "visibility";
    8914             :   case 1:
    8915             :     return "visibility";
    8916             :   }
    8917             : }
    8918             : 
    8919           0 : WarnUnusedAttr *WarnUnusedAttr::clone(ASTContext &C) const {
    8920             :   auto *A = new (C) WarnUnusedAttr(getLocation(), C, getSpellingListIndex());
    8921           0 :   A->Inherited = Inherited;
    8922           0 :   A->IsPackExpansion = IsPackExpansion;
    8923           0 :   A->Implicit = Implicit;
    8924           0 :   return A;
    8925             : }
    8926             : 
    8927           0 : void WarnUnusedAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    8928           0 :   switch (SpellingListIndex) {
    8929           0 :   default:
    8930           0 :     llvm_unreachable("Unknown attribute spelling!");
    8931             :     break;
    8932           0 :   case 0 : {
    8933           0 :     OS << " __attribute__((warn_unused))";
    8934           0 :     break;
    8935             :   }
    8936           0 :   case 1 : {
    8937           0 :     OS << " [[gnu::warn_unused]]";
    8938           0 :     break;
    8939             :   }
    8940             : }
    8941           0 : }
    8942             : 
    8943           0 : const char *WarnUnusedAttr::getSpelling() const {
    8944           0 :   switch (SpellingListIndex) {
    8945           0 :   default:
    8946           0 :     llvm_unreachable("Unknown attribute spelling!");
    8947             :     return "(No spelling)";
    8948             :   case 0:
    8949             :     return "warn_unused";
    8950             :   case 1:
    8951             :     return "warn_unused";
    8952             :   }
    8953             : }
    8954             : 
    8955         304 : WarnUnusedResultAttr *WarnUnusedResultAttr::clone(ASTContext &C) const {
    8956             :   auto *A = new (C) WarnUnusedResultAttr(getLocation(), C, getSpellingListIndex());
    8957         304 :   A->Inherited = Inherited;
    8958         304 :   A->IsPackExpansion = IsPackExpansion;
    8959         304 :   A->Implicit = Implicit;
    8960         304 :   return A;
    8961             : }
    8962             : 
    8963           3 : void WarnUnusedResultAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    8964           3 :   switch (SpellingListIndex) {
    8965           0 :   default:
    8966           0 :     llvm_unreachable("Unknown attribute spelling!");
    8967             :     break;
    8968           0 :   case 0 : {
    8969           0 :     OS << " [[nodiscard]]";
    8970           0 :     break;
    8971             :   }
    8972           0 :   case 1 : {
    8973           0 :     OS << " [[nodiscard]]";
    8974           0 :     break;
    8975             :   }
    8976           1 :   case 2 : {
    8977           1 :     OS << " [[clang::warn_unused_result]]";
    8978           1 :     break;
    8979             :   }
    8980           1 :   case 3 : {
    8981           1 :     OS << " __attribute__((warn_unused_result))";
    8982           1 :     break;
    8983             :   }
    8984           1 :   case 4 : {
    8985           1 :     OS << " [[gnu::warn_unused_result]]";
    8986           1 :     break;
    8987             :   }
    8988             : }
    8989           3 : }
    8990             : 
    8991          48 : const char *WarnUnusedResultAttr::getSpelling() const {
    8992          48 :   switch (SpellingListIndex) {
    8993           0 :   default:
    8994           0 :     llvm_unreachable("Unknown attribute spelling!");
    8995             :     return "(No spelling)";
    8996             :   case 0:
    8997             :     return "nodiscard";
    8998             :   case 1:
    8999             :     return "nodiscard";
    9000          16 :   case 2:
    9001          16 :     return "warn_unused_result";
    9002          15 :   case 3:
    9003          15 :     return "warn_unused_result";
    9004           0 :   case 4:
    9005           0 :     return "warn_unused_result";
    9006             :   }
    9007             : }
    9008             : 
    9009          42 : WeakAttr *WeakAttr::clone(ASTContext &C) const {
    9010             :   auto *A = new (C) WeakAttr(getLocation(), C, getSpellingListIndex());
    9011          42 :   A->Inherited = Inherited;
    9012          42 :   A->IsPackExpansion = IsPackExpansion;
    9013          42 :   A->Implicit = Implicit;
    9014          42 :   return A;
    9015             : }
    9016             : 
    9017           0 : void WeakAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    9018           0 :   switch (SpellingListIndex) {
    9019           0 :   default:
    9020           0 :     llvm_unreachable("Unknown attribute spelling!");
    9021             :     break;
    9022           0 :   case 0 : {
    9023           0 :     OS << " __attribute__((weak))";
    9024           0 :     break;
    9025             :   }
    9026           0 :   case 1 : {
    9027           0 :     OS << " [[gnu::weak]]";
    9028           0 :     break;
    9029             :   }
    9030             : }
    9031           0 : }
    9032             : 
    9033           0 : const char *WeakAttr::getSpelling() const {
    9034           0 :   switch (SpellingListIndex) {
    9035           0 :   default:
    9036           0 :     llvm_unreachable("Unknown attribute spelling!");
    9037             :     return "(No spelling)";
    9038             :   case 0:
    9039             :     return "weak";
    9040             :   case 1:
    9041             :     return "weak";
    9042             :   }
    9043             : }
    9044             : 
    9045           8 : WeakImportAttr *WeakImportAttr::clone(ASTContext &C) const {
    9046             :   auto *A = new (C) WeakImportAttr(getLocation(), C, getSpellingListIndex());
    9047           8 :   A->Inherited = Inherited;
    9048           8 :   A->IsPackExpansion = IsPackExpansion;
    9049           8 :   A->Implicit = Implicit;
    9050           8 :   return A;
    9051             : }
    9052             : 
    9053           0 : void WeakImportAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    9054           0 :   switch (SpellingListIndex) {
    9055           0 :   default:
    9056           0 :     llvm_unreachable("Unknown attribute spelling!");
    9057             :     break;
    9058           0 :   case 0 : {
    9059           0 :     OS << " __attribute__((weak_import))";
    9060           0 :     break;
    9061             :   }
    9062           0 :   case 1 : {
    9063           0 :     OS << " [[clang::weak_import]]";
    9064           0 :     break;
    9065             :   }
    9066           0 :   case 2 : {
    9067           0 :     OS << " [[clang::weak_import]]";
    9068           0 :     break;
    9069             :   }
    9070             : }
    9071           0 : }
    9072             : 
    9073           0 : const char *WeakImportAttr::getSpelling() const {
    9074           0 :   switch (SpellingListIndex) {
    9075           0 :   default:
    9076           0 :     llvm_unreachable("Unknown attribute spelling!");
    9077             :     return "(No spelling)";
    9078             :   case 0:
    9079             :     return "weak_import";
    9080             :   case 1:
    9081             :     return "weak_import";
    9082             :   case 2:
    9083             :     return "weak_import";
    9084             :   }
    9085             : }
    9086             : 
    9087           0 : WeakRefAttr *WeakRefAttr::clone(ASTContext &C) const {
    9088           0 :   auto *A = new (C) WeakRefAttr(getLocation(), C, getAliasee(), getSpellingListIndex());
    9089           0 :   A->Inherited = Inherited;
    9090           0 :   A->IsPackExpansion = IsPackExpansion;
    9091           0 :   A->Implicit = Implicit;
    9092           0 :   return A;
    9093             : }
    9094             : 
    9095           0 : void WeakRefAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    9096           0 :   switch (SpellingListIndex) {
    9097           0 :   default:
    9098           0 :     llvm_unreachable("Unknown attribute spelling!");
    9099             :     break;
    9100           0 :   case 0 : {
    9101           0 :     OS << " __attribute__((weakref(\"" << getAliasee() << "\")))";
    9102           0 :     break;
    9103             :   }
    9104           0 :   case 1 : {
    9105           0 :     OS << " [[gnu::weakref(\"" << getAliasee() << "\")]]";
    9106           0 :     break;
    9107             :   }
    9108             : }
    9109           0 : }
    9110             : 
    9111           0 : const char *WeakRefAttr::getSpelling() const {
    9112           0 :   switch (SpellingListIndex) {
    9113           0 :   default:
    9114           0 :     llvm_unreachable("Unknown attribute spelling!");
    9115             :     return "(No spelling)";
    9116             :   case 0:
    9117             :     return "weakref";
    9118             :   case 1:
    9119             :     return "weakref";
    9120             :   }
    9121             : }
    9122             : 
    9123           0 : WorkGroupSizeHintAttr *WorkGroupSizeHintAttr::clone(ASTContext &C) const {
    9124           0 :   auto *A = new (C) WorkGroupSizeHintAttr(getLocation(), C, xDim, yDim, zDim, getSpellingListIndex());
    9125           0 :   A->Inherited = Inherited;
    9126           0 :   A->IsPackExpansion = IsPackExpansion;
    9127           0 :   A->Implicit = Implicit;
    9128           0 :   return A;
    9129             : }
    9130             : 
    9131           0 : void WorkGroupSizeHintAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    9132           0 :   switch (SpellingListIndex) {
    9133           0 :   default:
    9134           0 :     llvm_unreachable("Unknown attribute spelling!");
    9135             :     break;
    9136           0 :   case 0 : {
    9137           0 :     OS << " __attribute__((work_group_size_hint(" << getXDim() << ", " << getYDim() << ", " << getZDim() << ")))";
    9138             :     break;
    9139             :   }
    9140             : }
    9141           0 : }
    9142             : 
    9143           2 : const char *WorkGroupSizeHintAttr::getSpelling() const {
    9144           2 :   switch (SpellingListIndex) {
    9145           0 :   default:
    9146           0 :     llvm_unreachable("Unknown attribute spelling!");
    9147             :     return "(No spelling)";
    9148           2 :   case 0:
    9149             :     return "work_group_size_hint";
    9150             :   }
    9151             : }
    9152             : 
    9153           1 : X86ForceAlignArgPointerAttr *X86ForceAlignArgPointerAttr::clone(ASTContext &C) const {
    9154             :   auto *A = new (C) X86ForceAlignArgPointerAttr(getLocation(), C, getSpellingListIndex());
    9155           1 :   A->Inherited = Inherited;
    9156           1 :   A->IsPackExpansion = IsPackExpansion;
    9157           1 :   A->Implicit = Implicit;
    9158           1 :   return A;
    9159             : }
    9160             : 
    9161           0 : void X86ForceAlignArgPointerAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    9162           0 :   switch (SpellingListIndex) {
    9163           0 :   default:
    9164           0 :     llvm_unreachable("Unknown attribute spelling!");
    9165             :     break;
    9166           0 :   case 0 : {
    9167           0 :     OS << " __attribute__((force_align_arg_pointer))";
    9168           0 :     break;
    9169             :   }
    9170           0 :   case 1 : {
    9171           0 :     OS << " [[gnu::force_align_arg_pointer]]";
    9172           0 :     break;
    9173             :   }
    9174             : }
    9175           0 : }
    9176             : 
    9177           0 : const char *X86ForceAlignArgPointerAttr::getSpelling() const {
    9178           0 :   switch (SpellingListIndex) {
    9179           0 :   default:
    9180           0 :     llvm_unreachable("Unknown attribute spelling!");
    9181             :     return "(No spelling)";
    9182             :   case 0:
    9183             :     return "force_align_arg_pointer";
    9184             :   case 1:
    9185             :     return "force_align_arg_pointer";
    9186             :   }
    9187             : }
    9188             : 
    9189           0 : XRayInstrumentAttr *XRayInstrumentAttr::clone(ASTContext &C) const {
    9190             :   auto *A = new (C) XRayInstrumentAttr(getLocation(), C, getSpellingListIndex());
    9191           0 :   A->Inherited = Inherited;
    9192           0 :   A->IsPackExpansion = IsPackExpansion;
    9193           0 :   A->Implicit = Implicit;
    9194           0 :   return A;
    9195             : }
    9196             : 
    9197           0 : void XRayInstrumentAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    9198           0 :   switch (SpellingListIndex) {
    9199           0 :   default:
    9200           0 :     llvm_unreachable("Unknown attribute spelling!");
    9201             :     break;
    9202           0 :   case 0 : {
    9203           0 :     OS << " __attribute__((xray_always_instrument))";
    9204           0 :     break;
    9205             :   }
    9206           0 :   case 1 : {
    9207           0 :     OS << " [[clang::xray_always_instrument]]";
    9208           0 :     break;
    9209             :   }
    9210           0 :   case 2 : {
    9211           0 :     OS << " [[clang::xray_always_instrument]]";
    9212           0 :     break;
    9213             :   }
    9214           0 :   case 3 : {
    9215           0 :     OS << " __attribute__((xray_never_instrument))";
    9216           0 :     break;
    9217             :   }
    9218           0 :   case 4 : {
    9219           0 :     OS << " [[clang::xray_never_instrument]]";
    9220           0 :     break;
    9221             :   }
    9222           0 :   case 5 : {
    9223           0 :     OS << " [[clang::xray_never_instrument]]";
    9224           0 :     break;
    9225             :   }
    9226             : }
    9227           0 : }
    9228             : 
    9229           0 : const char *XRayInstrumentAttr::getSpelling() const {
    9230           0 :   switch (SpellingListIndex) {
    9231           0 :   default:
    9232           0 :     llvm_unreachable("Unknown attribute spelling!");
    9233             :     return "(No spelling)";
    9234             :   case 0:
    9235             :     return "xray_always_instrument";
    9236             :   case 1:
    9237             :     return "xray_always_instrument";
    9238             :   case 2:
    9239             :     return "xray_always_instrument";
    9240           0 :   case 3:
    9241           0 :     return "xray_never_instrument";
    9242           0 :   case 4:
    9243           0 :     return "xray_never_instrument";
    9244           0 :   case 5:
    9245           0 :     return "xray_never_instrument";
    9246             :   }
    9247             : }
    9248             : 
    9249           0 : XRayLogArgsAttr *XRayLogArgsAttr::clone(ASTContext &C) const {
    9250           0 :   auto *A = new (C) XRayLogArgsAttr(getLocation(), C, argumentCount, getSpellingListIndex());
    9251           0 :   A->Inherited = Inherited;
    9252           0 :   A->IsPackExpansion = IsPackExpansion;
    9253           0 :   A->Implicit = Implicit;
    9254           0 :   return A;
    9255             : }
    9256             : 
    9257           4 : void XRayLogArgsAttr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
    9258           4 :   switch (SpellingListIndex) {
    9259           0 :   default:
    9260           0 :     llvm_unreachable("Unknown attribute spelling!");
    9261             :     break;
    9262           4 :   case 0 : {
    9263           8 :     OS << " __attribute__((xray_log_args(" << getArgumentCount() << ")))";
    9264           4 :     break;
    9265             :   }
    9266           0 :   case 1 : {
    9267           0 :     OS << " [[clang::xray_log_args(" << getArgumentCount() << ")]]";
    9268           0 :     break;
    9269             :   }
    9270           0 :   case 2 : {
    9271           0 :     OS << " [[clang::xray_log_args(" << getArgumentCount() << ")]]";
    9272           0 :     break;
    9273             :   }
    9274             : }
    9275           4 : }
    9276             : 
    9277           0 : const char *XRayLogArgsAttr::getSpelling() const {
    9278           0 :   switch (SpellingListIndex) {
    9279           0 :   default:
    9280           0 :     llvm_unreachable("Unknown attribute spelling!");
    9281             :     return "(No spelling)";
    9282             :   case 0:
    9283             :     return "xray_log_args";
    9284             :   case 1:
    9285             :     return "xray_log_args";
    9286             :   case 2:
    9287             :     return "xray_log_args";
    9288             :   }
    9289             : }
    9290             : 
    9291        1393 : const char *Attr::getSpelling() const {
    9292        1393 :   switch (getKind()) {
    9293             :   case attr::AMDGPUFlatWorkGroupSize:
    9294           1 :     return cast<AMDGPUFlatWorkGroupSizeAttr>(this)->getSpelling();
    9295             :   case attr::AMDGPUNumSGPR:
    9296           1 :     return cast<AMDGPUNumSGPRAttr>(this)->getSpelling();
    9297             :   case attr::AMDGPUNumVGPR:
    9298           1 :     return cast<AMDGPUNumVGPRAttr>(this)->getSpelling();
    9299             :   case attr::AMDGPUWavesPerEU:
    9300           2 :     return cast<AMDGPUWavesPerEUAttr>(this)->getSpelling();
    9301             :   case attr::ARMInterrupt:
    9302           0 :     return cast<ARMInterruptAttr>(this)->getSpelling();
    9303             :   case attr::AVRInterrupt:
    9304           0 :     return cast<AVRInterruptAttr>(this)->getSpelling();
    9305             :   case attr::AVRSignal:
    9306           0 :     return cast<AVRSignalAttr>(this)->getSpelling();
    9307             :   case attr::AbiTag:
    9308           0 :     return cast<AbiTagAttr>(this)->getSpelling();
    9309             :   case attr::AcquireCapability:
    9310           0 :     return cast<AcquireCapabilityAttr>(this)->getSpelling();
    9311             :   case attr::AcquiredAfter:
    9312           0 :     return cast<AcquiredAfterAttr>(this)->getSpelling();
    9313             :   case attr::AcquiredBefore:
    9314           0 :     return cast<AcquiredBeforeAttr>(this)->getSpelling();
    9315             :   case attr::Alias:
    9316           0 :     return cast<AliasAttr>(this)->getSpelling();
    9317             :   case attr::AlignMac68k:
    9318           0 :     return cast<AlignMac68kAttr>(this)->getSpelling();
    9319             :   case attr::AlignValue:
    9320           1 :     return cast<AlignValueAttr>(this)->getSpelling();
    9321             :   case attr::Aligned:
    9322          47 :     return cast<AlignedAttr>(this)->getSpelling();
    9323             :   case attr::AllocAlign:
    9324          10 :     return cast<AllocAlignAttr>(this)->getSpelling();
    9325             :   case attr::AllocSize:
    9326           0 :     return cast<AllocSizeAttr>(this)->getSpelling();
    9327             :   case attr::AlwaysInline:
    9328           8 :     return cast<AlwaysInlineAttr>(this)->getSpelling();
    9329             :   case attr::AnalyzerNoReturn:
    9330           0 :     return cast<AnalyzerNoReturnAttr>(this)->getSpelling();
    9331             :   case attr::Annotate:
    9332           0 :     return cast<AnnotateAttr>(this)->getSpelling();
    9333             :   case attr::AnyX86Interrupt:
    9334           0 :     return cast<AnyX86InterruptAttr>(this)->getSpelling();
    9335             :   case attr::AnyX86NoCallerSavedRegisters:
    9336           2 :     return cast<AnyX86NoCallerSavedRegistersAttr>(this)->getSpelling();
    9337             :   case attr::AnyX86NoCfCheck:
    9338           0 :     return cast<AnyX86NoCfCheckAttr>(this)->getSpelling();
    9339             :   case attr::ArcWeakrefUnavailable:
    9340           0 :     return cast<ArcWeakrefUnavailableAttr>(this)->getSpelling();
    9341             :   case attr::ArgumentWithTypeTag:
    9342           3 :     return cast<ArgumentWithTypeTagAttr>(this)->getSpelling();
    9343             :   case attr::Artificial:
    9344           0 :     return cast<ArtificialAttr>(this)->getSpelling();
    9345             :   case attr::AsmLabel:
    9346           0 :     return cast<AsmLabelAttr>(this)->getSpelling();
    9347             :   case attr::AssertCapability:
    9348           0 :     return cast<AssertCapabilityAttr>(this)->getSpelling();
    9349             :   case attr::AssertExclusiveLock:
    9350           0 :     return cast<AssertExclusiveLockAttr>(this)->getSpelling();
    9351             :   case attr::AssertSharedLock:
    9352           0 :     return cast<AssertSharedLockAttr>(this)->getSpelling();
    9353             :   case attr::AssumeAligned:
    9354           3 :     return cast<AssumeAlignedAttr>(this)->getSpelling();
    9355             :   case attr::Availability:
    9356           0 :     return cast<AvailabilityAttr>(this)->getSpelling();
    9357             :   case attr::Blocks:
    9358           0 :     return cast<BlocksAttr>(this)->getSpelling();
    9359             :   case attr::C11NoReturn:
    9360           0 :     return cast<C11NoReturnAttr>(this)->getSpelling();
    9361             :   case attr::CDecl:
    9362           0 :     return cast<CDeclAttr>(this)->getSpelling();
    9363             :   case attr::CFAuditedTransfer:
    9364           0 :     return cast<CFAuditedTransferAttr>(this)->getSpelling();
    9365             :   case attr::CFConsumed:
    9366           0 :     return cast<CFConsumedAttr>(this)->getSpelling();
    9367             :   case attr::CFReturnsNotRetained:
    9368           0 :     return cast<CFReturnsNotRetainedAttr>(this)->getSpelling();
    9369             :   case attr::CFReturnsRetained:
    9370           0 :     return cast<CFReturnsRetainedAttr>(this)->getSpelling();
    9371             :   case attr::CFUnknownTransfer:
    9372           0 :     return cast<CFUnknownTransferAttr>(this)->getSpelling();
    9373             :   case attr::CUDAConstant:
    9374           2 :     return cast<CUDAConstantAttr>(this)->getSpelling();
    9375             :   case attr::CUDADevice:
    9376           2 :     return cast<CUDADeviceAttr>(this)->getSpelling();
    9377             :   case attr::CUDAGlobal:
    9378           4 :     return cast<CUDAGlobalAttr>(this)->getSpelling();
    9379             :   case attr::CUDAHost:
    9380           2 :     return cast<CUDAHostAttr>(this)->getSpelling();
    9381             :   case attr::CUDAInvalidTarget:
    9382           0 :     return cast<CUDAInvalidTargetAttr>(this)->getSpelling();
    9383             :   case attr::CUDALaunchBounds:
    9384           7 :     return cast<CUDALaunchBoundsAttr>(this)->getSpelling();
    9385             :   case attr::CUDAShared:
    9386           4 :     return cast<CUDASharedAttr>(this)->getSpelling();
    9387             :   case attr::CXX11NoReturn:
    9388           0 :     return cast<CXX11NoReturnAttr>(this)->getSpelling();
    9389             :   case attr::CallableWhen:
    9390           0 :     return cast<CallableWhenAttr>(this)->getSpelling();
    9391             :   case attr::Capability:
    9392           1 :     return cast<CapabilityAttr>(this)->getSpelling();
    9393             :   case attr::CapturedRecord:
    9394           0 :     return cast<CapturedRecordAttr>(this)->getSpelling();
    9395             :   case attr::CarriesDependency:
    9396           0 :     return cast<CarriesDependencyAttr>(this)->getSpelling();
    9397             :   case attr::Cleanup:
    9398           0 :     return cast<CleanupAttr>(this)->getSpelling();
    9399             :   case attr::Cold:
    9400           1 :     return cast<ColdAttr>(this)->getSpelling();
    9401             :   case attr::Common:
    9402           4 :     return cast<CommonAttr>(this)->getSpelling();
    9403             :   case attr::Const:
    9404           0 :     return cast<ConstAttr>(this)->getSpelling();
    9405             :   case attr::Constructor:
    9406           0 :     return cast<ConstructorAttr>(this)->getSpelling();
    9407             :   case attr::Consumable:
    9408           0 :     return cast<ConsumableAttr>(this)->getSpelling();
    9409             :   case attr::ConsumableAutoCast:
    9410           0 :     return cast<ConsumableAutoCastAttr>(this)->getSpelling();
    9411             :   case attr::ConsumableSetOnRead:
    9412           0 :     return cast<ConsumableSetOnReadAttr>(this)->getSpelling();
    9413             :   case attr::Convergent:
    9414           0 :     return cast<ConvergentAttr>(this)->getSpelling();
    9415             :   case attr::DLLExport:
    9416         365 :     return cast<DLLExportAttr>(this)->getSpelling();
    9417             :   case attr::DLLImport:
    9418         830 :     return cast<DLLImportAttr>(this)->getSpelling();
    9419             :   case attr::Deprecated:
    9420           0 :     return cast<DeprecatedAttr>(this)->getSpelling();
    9421             :   case attr::Destructor:
    9422           0 :     return cast<DestructorAttr>(this)->getSpelling();
    9423             :   case attr::DiagnoseIf:
    9424           0 :     return cast<DiagnoseIfAttr>(this)->getSpelling();
    9425             :   case attr::DisableTailCalls:
    9426           1 :     return cast<DisableTailCallsAttr>(this)->getSpelling();
    9427             :   case attr::EmptyBases:
    9428           0 :     return cast<EmptyBasesAttr>(this)->getSpelling();
    9429             :   case attr::EnableIf:
    9430           0 :     return cast<EnableIfAttr>(this)->getSpelling();
    9431             :   case attr::EnumExtensibility:
    9432           0 :     return cast<EnumExtensibilityAttr>(this)->getSpelling();
    9433             :   case attr::ExclusiveTrylockFunction:
    9434           0 :     return cast<ExclusiveTrylockFunctionAttr>(this)->getSpelling();
    9435             :   case attr::ExternalSourceSymbol:
    9436           0 :     return cast<ExternalSourceSymbolAttr>(this)->getSpelling();
    9437             :   case attr::FallThrough:
    9438           1 :     return cast<FallThroughAttr>(this)->getSpelling();
    9439             :   case attr::FastCall:
    9440           0 :     return cast<FastCallAttr>(this)->getSpelling();
    9441             :   case attr::Final:
    9442           0 :     return cast<FinalAttr>(this)->getSpelling();
    9443             :   case attr::FlagEnum:
    9444           0 :     return cast<FlagEnumAttr>(this)->getSpelling();
    9445             :   case attr::Flatten:
    9446           0 :     return cast<FlattenAttr>(this)->getSpelling();
    9447             :   case attr::Format:
    9448           0 :     return cast<FormatAttr>(this)->getSpelling();
    9449             :   case attr::FormatArg:
    9450           0 :     return cast<FormatArgAttr>(this)->getSpelling();
    9451             :   case attr::GNUInline:
    9452           0 :     return cast<GNUInlineAttr>(this)->getSpelling();
    9453             :   case attr::GuardedBy:
    9454           0 :     return cast<GuardedByAttr>(this)->getSpelling();
    9455             :   case attr::GuardedVar:
    9456           0 :     return cast<GuardedVarAttr>(this)->getSpelling();
    9457             :   case attr::Hot:
    9458           1 :     return cast<HotAttr>(this)->getSpelling();
    9459             :   case attr::IBAction:
    9460           0 :     return cast<IBActionAttr>(this)->getSpelling();
    9461             :   case attr::IBOutlet:
    9462           0 :     return cast<IBOutletAttr>(this)->getSpelling();
    9463             :   case attr::IBOutletCollection:
    9464           0 :     return cast<IBOutletCollectionAttr>(this)->getSpelling();
    9465             :   case attr::IFunc:
    9466           0 :     return cast<IFuncAttr>(this)->getSpelling();
    9467             :   case attr::InitPriority:
    9468           0 :     return cast<InitPriorityAttr>(this)->getSpelling();
    9469             :   case attr::InitSeg:
    9470           0 :     return cast<InitSegAttr>(this)->getSpelling();
    9471             :   case attr::IntelOclBicc:
    9472           0 :     return cast<IntelOclBiccAttr>(this)->getSpelling();
    9473             :   case attr::InternalLinkage:
    9474           2 :     return cast<InternalLinkageAttr>(this)->getSpelling();
    9475             :   case attr::LTOVisibilityPublic:
    9476           0 :     return cast<LTOVisibilityPublicAttr>(this)->getSpelling();
    9477             :   case attr::LayoutVersion:
    9478           0 :     return cast<LayoutVersionAttr>(this)->getSpelling();
    9479             :   case attr::LockReturned:
    9480           0 :     return cast<LockReturnedAttr>(this)->getSpelling();
    9481             :   case attr::LocksExcluded:
    9482           0 :     return cast<LocksExcludedAttr>(this)->getSpelling();
    9483             :   case attr::LoopHint:
    9484           1 :     return cast<LoopHintAttr>(this)->getSpelling();
    9485             :   case attr::MSABI:
    9486           0 :     return cast<MSABIAttr>(this)->getSpelling();
    9487             :   case attr::MSInheritance:
    9488           0 :     return cast<MSInheritanceAttr>(this)->getSpelling();
    9489             :   case attr::MSNoVTable:
    9490           0 :     return cast<MSNoVTableAttr>(this)->getSpelling();
    9491             :   case attr::MSP430Interrupt:
    9492           0 :     return cast<MSP430InterruptAttr>(this)->getSpelling();
    9493             :   case attr::MSStruct:
    9494           0 :     return cast<MSStructAttr>(this)->getSpelling();
    9495             :   case attr::MSVtorDisp:
    9496           0 :     return cast<MSVtorDispAttr>(this)->getSpelling();
    9497             :   case attr::MaxFieldAlignment:
    9498           0 :     return cast<MaxFieldAlignmentAttr>(this)->getSpelling();
    9499             :   case attr::MayAlias:
    9500           0 :     return cast<MayAliasAttr>(this)->getSpelling();
    9501             :   case attr::MicroMips:
    9502           1 :     return cast<MicroMipsAttr>(this)->getSpelling();
    9503             :   case attr::MinSize:
    9504           3 :     return cast<MinSizeAttr>(this)->getSpelling();
    9505             :   case attr::MinVectorWidth:
    9506           0 :     return cast<MinVectorWidthAttr>(this)->getSpelling();
    9507             :   case attr::Mips16:
    9508           4 :     return cast<Mips16Attr>(this)->getSpelling();
    9509             :   case attr::MipsInterrupt:
    9510           2 :     return cast<MipsInterruptAttr>(this)->getSpelling();
    9511             :   case attr::MipsLongCall:
    9512           2 :     return cast<MipsLongCallAttr>(this)->getSpelling();
    9513             :   case attr::MipsShortCall:
    9514           2 :     return cast<MipsShortCallAttr>(this)->getSpelling();
    9515             :   case attr::Mode:
    9516           0 :     return cast<ModeAttr>(this)->getSpelling();
    9517             :   case attr::NSConsumed:
    9518           0 :     return cast<NSConsumedAttr>(this)->getSpelling();
    9519             :   case attr::NSConsumesSelf:
    9520           0 :     return cast<NSConsumesSelfAttr>(this)->getSpelling();
    9521             :   case attr::NSReturnsAutoreleased:
    9522           0 :     return cast<NSReturnsAutoreleasedAttr>(this)->getSpelling();
    9523             :   case attr::NSReturnsNotRetained:
    9524           0 :     return cast<NSReturnsNotRetainedAttr>(this)->getSpelling();
    9525             :   case attr::NSReturnsRetained:
    9526           0 :     return cast<NSReturnsRetainedAttr>(this)->getSpelling();
    9527             :   case attr::Naked:
    9528           1 :     return cast<NakedAttr>(this)->getSpelling();
    9529             :   case attr::NoAlias:
    9530           0 :     return cast<NoAliasAttr>(this)->getSpelling();
    9531             :   case attr::NoCommon:
    9532           0 :     return cast<NoCommonAttr>(this)->getSpelling();
    9533             :   case attr::NoDebug:
    9534           0 :     return cast<NoDebugAttr>(this)->getSpelling();
    9535             :   case attr::NoDuplicate:
    9536           0 :     return cast<NoDuplicateAttr>(this)->getSpelling();
    9537             :   case attr::NoEscape:
    9538           0 :     return cast<NoEscapeAttr>(this)->getSpelling();
    9539             :   case attr::NoInline:
    9540           0 :     return cast<NoInlineAttr>(this)->getSpelling();
    9541             :   case attr::NoInstrumentFunction:
    9542           0 :     return cast<NoInstrumentFunctionAttr>(this)->getSpelling();
    9543             :   case attr::NoMicroMips:
    9544           0 :     return cast<NoMicroMipsAttr>(this)->getSpelling();
    9545             :   case attr::NoMips16:
    9546           0 :     return cast<NoMips16Attr>(this)->getSpelling();
    9547             :   case attr::NoReturn:
    9548           0 :     return cast<NoReturnAttr>(this)->getSpelling();
    9549             :   case attr::NoSanitize:
    9550           0 :     return cast<NoSanitizeAttr>(this)->getSpelling();
    9551             :   case attr::NoSplitStack:
    9552           0 :     return cast<NoSplitStackAttr>(this)->getSpelling();
    9553             :   case attr::NoStackProtector:
    9554           0 :     return cast<NoStackProtectorAttr>(this)->getSpelling();
    9555             :   case attr::NoThreadSafetyAnalysis:
    9556           0 :     return cast<NoThreadSafetyAnalysisAttr>(this)->getSpelling();
    9557             :   case attr::NoThrow:
    9558           0 :     return cast<NoThrowAttr>(this)->getSpelling();
    9559             :   case attr::NonNull:
    9560           0 :     return cast<NonNullAttr>(this)->getSpelling();
    9561             :   case attr::NotTailCalled:
    9562           3 :     return cast<NotTailCalledAttr>(this)->getSpelling();
    9563             :   case attr::OMPCaptureKind:
    9564           0 :     return cast<OMPCaptureKindAttr>(this)->getSpelling();
    9565             :   case attr::OMPCaptureNoInit:
    9566           0 :     return cast<OMPCaptureNoInitAttr>(this)->getSpelling();
    9567             :   case attr::OMPDeclareSimdDecl:
    9568           0 :     return cast<OMPDeclareSimdDeclAttr>(this)->getSpelling();
    9569             :   case attr::OMPDeclareTargetDecl:
    9570           0 :     return cast<OMPDeclareTargetDeclAttr>(this)->getSpelling();
    9571             :   case attr::OMPReferencedVar:
    9572           0 :     return cast<OMPReferencedVarAttr>(this)->getSpelling();
    9573             :   case attr::OMPThreadPrivateDecl:
    9574           0 :     return cast<OMPThreadPrivateDeclAttr>(this)->getSpelling();
    9575             :   case attr::ObjCBoxable:
    9576           0 :     return cast<ObjCBoxableAttr>(this)->getSpelling();
    9577             :   case attr::ObjCBridge:
    9578           0 :     return cast<ObjCBridgeAttr>(this)->getSpelling();
    9579             :   case attr::ObjCBridgeMutable:
    9580           0 :     return cast<ObjCBridgeMutableAttr>(this)->getSpelling();
    9581             :   case attr::ObjCBridgeRelated:
    9582           0 :     return cast<ObjCBridgeRelatedAttr>(this)->getSpelling();
    9583             :   case attr::ObjCDesignatedInitializer:
    9584           0 :     return cast<ObjCDesignatedInitializerAttr>(this)->getSpelling();
    9585             :   case attr::ObjCException:
    9586           0 :     return cast<ObjCExceptionAttr>(this)->getSpelling();
    9587             :   case attr::ObjCExplicitProtocolImpl:
    9588           0 :     return cast<ObjCExplicitProtocolImplAttr>(this)->getSpelling();
    9589             :   case attr::ObjCIndependentClass:
    9590           0 :     return cast<ObjCIndependentClassAttr>(this)->getSpelling();
    9591             :   case attr::ObjCMethodFamily:
    9592           0 :     return cast<ObjCMethodFamilyAttr>(this)->getSpelling();
    9593             :   case attr::ObjCNSObject:
    9594           0 :     return cast<ObjCNSObjectAttr>(this)->getSpelling();
    9595             :   case attr::ObjCPreciseLifetime:
    9596           0 :     return cast<ObjCPreciseLifetimeAttr>(this)->getSpelling();
    9597             :   case attr::ObjCRequiresPropertyDefs:
    9598           0 :     return cast<ObjCRequiresPropertyDefsAttr>(this)->getSpelling();
    9599             :   case attr::ObjCRequiresSuper:
    9600           0 :     return cast<ObjCRequiresSuperAttr>(this)->getSpelling();
    9601             :   case attr::ObjCReturnsInnerPointer:
    9602           0 :     return cast<ObjCReturnsInnerPointerAttr>(this)->getSpelling();
    9603             :   case attr::ObjCRootClass:
    9604           0 :     return cast<ObjCRootClassAttr>(this)->getSpelling();
    9605             :   case attr::ObjCRuntimeName:
    9606           0 :     return cast<ObjCRuntimeNameAttr>(this)->getSpelling();
    9607             :   case attr::ObjCRuntimeVisible:
    9608           0 :     return cast<ObjCRuntimeVisibleAttr>(this)->getSpelling();
    9609             :   case attr::ObjCSubclassingRestricted:
    9610           0 :     return cast<ObjCSubclassingRestrictedAttr>(this)->getSpelling();
    9611             :   case attr::OpenCLAccess:
    9612           2 :     return cast<OpenCLAccessAttr>(this)->getSpelling();
    9613             :   case attr::OpenCLIntelReqdSubGroupSize:
    9614           2 :     return cast<OpenCLIntelReqdSubGroupSizeAttr>(this)->getSpelling();
    9615             :   case attr::OpenCLKernel:
    9616           0 :     return cast<OpenCLKernelAttr>(this)->getSpelling();
    9617             :   case attr::OpenCLUnrollHint:
    9618           0 :     return cast<OpenCLUnrollHintAttr>(this)->getSpelling();
    9619             :   case attr::OptimizeNone:
    9620           0 :     return cast<OptimizeNoneAttr>(this)->getSpelling();
    9621             :   case attr::Overloadable:
    9622           0 :     return cast<OverloadableAttr>(this)->getSpelling();
    9623             :   case attr::Override:
    9624           0 :     return cast<OverrideAttr>(this)->getSpelling();
    9625             :   case attr::Ownership:
    9626           1 :     return cast<OwnershipAttr>(this)->getSpelling();
    9627             :   case attr::Packed:
    9628           0 :     return cast<PackedAttr>(this)->getSpelling();
    9629             :   case attr::ParamTypestate:
    9630           0 :     return cast<ParamTypestateAttr>(this)->getSpelling();
    9631             :   case attr::Pascal:
    9632           0 :     return cast<PascalAttr>(this)->getSpelling();
    9633             :   case attr::PassObjectSize:
    9634           0 :     return cast<PassObjectSizeAttr>(this)->getSpelling();
    9635             :   case attr::Pcs:
    9636           0 :     return cast<PcsAttr>(this)->getSpelling();
    9637             :   case attr::PragmaClangBSSSection:
    9638           0 :     return cast<PragmaClangBSSSectionAttr>(this)->getSpelling();
    9639             :   case attr::PragmaClangDataSection:
    9640           0 :     return cast<PragmaClangDataSectionAttr>(this)->getSpelling();
    9641             :   case attr::PragmaClangRodataSection:
    9642           0 :     return cast<PragmaClangRodataSectionAttr>(this)->getSpelling();
    9643             :   case attr::PragmaClangTextSection:
    9644           0 :     return cast<PragmaClangTextSectionAttr>(this)->getSpelling();
    9645             :   case attr::PreserveAll:
    9646           0 :     return cast<PreserveAllAttr>(this)->getSpelling();
    9647             :   case attr::PreserveMost:
    9648           0 :     return cast<PreserveMostAttr>(this)->getSpelling();
    9649             :   case attr::PtGuardedBy:
    9650           0 :     return cast<PtGuardedByAttr>(this)->getSpelling();
    9651             :   case attr::PtGuardedVar:
    9652           0 :     return cast<PtGuardedVarAttr>(this)->getSpelling();
    9653             :   case attr::Pure:
    9654           0 :     return cast<PureAttr>(this)->getSpelling();
    9655             :   case attr::RegCall:
    9656           0 :     return cast<RegCallAttr>(this)->getSpelling();
    9657             :   case attr::ReleaseCapability:
    9658           0 :     return cast<ReleaseCapabilityAttr>(this)->getSpelling();
    9659             :   case attr::RenderScriptKernel:
    9660           0 :     return cast<RenderScriptKernelAttr>(this)->getSpelling();
    9661             :   case attr::ReqdWorkGroupSize:
    9662           2 :     return cast<ReqdWorkGroupSizeAttr>(this)->getSpelling();
    9663             :   case attr::RequireConstantInit:
    9664           0 :     return cast<RequireConstantInitAttr>(this)->getSpelling();
    9665             :   case attr::RequiresCapability:
    9666           0 :     return cast<RequiresCapabilityAttr>(this)->getSpelling();
    9667             :   case attr::Restrict:
    9668           0 :     return cast<RestrictAttr>(this)->getSpelling();
    9669             :   case attr::ReturnTypestate:
    9670           0 :     return cast<ReturnTypestateAttr>(this)->getSpelling();
    9671             :   case attr::ReturnsNonNull:
    9672           0 :     return cast<ReturnsNonNullAttr>(this)->getSpelling();
    9673             :   case attr::ReturnsTwice:
    9674           0 :     return cast<ReturnsTwiceAttr>(this)->getSpelling();
    9675             :   case attr::ScopedLockable:
    9676           0 :     return cast<ScopedLockableAttr>(this)->getSpelling();
    9677             :   case attr::Section:
    9678           0 :     return cast<SectionAttr>(this)->getSpelling();
    9679             :   case attr::SelectAny:
    9680           0 :     return cast<SelectAnyAttr>(this)->getSpelling();
    9681             :   case attr::Sentinel:
    9682           0 :     return cast<SentinelAttr>(this)->getSpelling();
    9683             :   case attr::SetTypestate:
    9684           0 :     return cast<SetTypestateAttr>(this)->getSpelling();
    9685             :   case attr::SharedTrylockFunction:
    9686           0 :     return cast<SharedTrylockFunctionAttr>(this)->getSpelling();
    9687             :   case attr::StdCall:
    9688           0 :     return cast<StdCallAttr>(this)->getSpelling();
    9689             :   case attr::Suppress:
    9690           0 :     return cast<SuppressAttr>(this)->getSpelling();
    9691             :   case attr::SwiftCall:
    9692           0 :     return cast<SwiftCallAttr>(this)->getSpelling();
    9693             :   case attr::SwiftContext:
    9694           0 :     return cast<SwiftContextAttr>(this)->getSpelling();
    9695             :   case attr::SwiftErrorResult:
    9696           0 :     return cast<SwiftErrorResultAttr>(this)->getSpelling();
    9697             :   case attr::SwiftIndirectResult:
    9698           0 :     return cast<SwiftIndirectResultAttr>(this)->getSpelling();
    9699             :   case attr::SysVABI:
    9700           0 :     return cast<SysVABIAttr>(this)->getSpelling();
    9701             :   case attr::TLSModel:
    9702           0 :     return cast<TLSModelAttr>(this)->getSpelling();
    9703             :   case attr::Target:
    9704           0 :     return cast<TargetAttr>(this)->getSpelling();
    9705             :   case attr::TestTypestate:
    9706           0 :     return cast<TestTypestateAttr>(this)->getSpelling();
    9707             :   case attr::ThisCall:
    9708           0 :     return cast<ThisCallAttr>(this)->getSpelling();
    9709             :   case attr::Thread:
    9710           0 :     return cast<ThreadAttr>(this)->getSpelling();
    9711             :   case attr::TransparentUnion:
    9712           0 :     return cast<TransparentUnionAttr>(this)->getSpelling();
    9713             :   case attr::TrivialABI:
    9714           0 :     return cast<TrivialABIAttr>(this)->getSpelling();
    9715             :   case attr::TryAcquireCapability:
    9716           0 :     return cast<TryAcquireCapabilityAttr>(this)->getSpelling();
    9717             :   case attr::TypeTagForDatatype:
    9718           0 :     return cast<TypeTagForDatatypeAttr>(this)->getSpelling();
    9719             :   case attr::TypeVisibility:
    9720           0 :     return cast<TypeVisibilityAttr>(this)->getSpelling();
    9721             :   case attr::Unavailable:
    9722           0 :     return cast<UnavailableAttr>(this)->getSpelling();
    9723             :   case attr::Unused:
    9724           4 :     return cast<UnusedAttr>(this)->getSpelling();
    9725             :   case attr::Used:
    9726           4 :     return cast<UsedAttr>(this)->getSpelling();
    9727             :   case attr::Uuid:
    9728           0 :     return cast<UuidAttr>(this)->getSpelling();
    9729             :   case attr::VecReturn:
    9730           1 :     return cast<VecReturnAttr>(this)->getSpelling();
    9731             :   case attr::VecTypeHint:
    9732           2 :     return cast<VecTypeHintAttr>(this)->getSpelling();
    9733             :   case attr::VectorCall:
    9734           0 :     return cast<VectorCallAttr>(this)->getSpelling();
    9735             :   case attr::Visibility:
    9736           0 :     return cast<VisibilityAttr>(this)->getSpelling();
    9737             :   case attr::WarnUnused:
    9738           0 :     return cast<WarnUnusedAttr>(this)->getSpelling();
    9739             :   case attr::WarnUnusedResult:
    9740          48 :     return cast<WarnUnusedResultAttr>(this)->getSpelling();
    9741             :   case attr::Weak:
    9742           0 :     return cast<WeakAttr>(this)->getSpelling();
    9743             :   case attr::WeakImport:
    9744           0 :     return cast<WeakImportAttr>(this)->getSpelling();
    9745             :   case attr::WeakRef:
    9746           0 :     return cast<WeakRefAttr>(this)->getSpelling();
    9747             :   case attr::WorkGroupSizeHint:
    9748           2 :     return cast<WorkGroupSizeHintAttr>(this)->getSpelling();
    9749             :   case attr::X86ForceAlignArgPointer:
    9750           0 :     return cast<X86ForceAlignArgPointerAttr>(this)->getSpelling();
    9751             :   case attr::XRayInstrument:
    9752           0 :     return cast<XRayInstrumentAttr>(this)->getSpelling();
    9753             :   case attr::XRayLogArgs:
    9754           0 :     return cast<XRayLogArgsAttr>(this)->getSpelling();
    9755             :   }
    9756           0 :   llvm_unreachable("Unexpected attribute kind!");
    9757             : }
    9758             : 
    9759       11065 : Attr *Attr::clone(ASTContext &C) const {
    9760       11065 :   switch (getKind()) {
    9761             :   case attr::AMDGPUFlatWorkGroupSize:
    9762           0 :     return cast<AMDGPUFlatWorkGroupSizeAttr>(this)->clone(C);
    9763             :   case attr::AMDGPUNumSGPR:
    9764           0 :     return cast<AMDGPUNumSGPRAttr>(this)->clone(C);
    9765             :   case attr::AMDGPUNumVGPR:
    9766           0 :     return cast<AMDGPUNumVGPRAttr>(this)->clone(C);
    9767             :   case attr::AMDGPUWavesPerEU:
    9768           0 :     return cast<AMDGPUWavesPerEUAttr>(this)->clone(C);
    9769             :   case attr::ARMInterrupt:
    9770           0 :     return cast<ARMInterruptAttr>(this)->clone(C);
    9771             :   case attr::AVRInterrupt:
    9772           0 :     return cast<AVRInterruptAttr>(this)->clone(C);
    9773             :   case attr::AVRSignal:
    9774           0 :     return cast<AVRSignalAttr>(this)->clone(C);
    9775             :   case attr::AbiTag:
    9776           0 :     return cast<AbiTagAttr>(this)->clone(C);
    9777             :   case attr::AcquireCapability:
    9778          50 :     return cast<AcquireCapabilityAttr>(this)->clone(C);
    9779             :   case attr::AcquiredAfter:
    9780           0 :     return cast<AcquiredAfterAttr>(this)->clone(C);
    9781             :   case attr::AcquiredBefore:
    9782           0 :     return cast<AcquiredBeforeAttr>(this)->clone(C);
    9783             :   case attr::Alias:
    9784           0 :     return cast<AliasAttr>(this)->clone(C);
    9785             :   case attr::AlignMac68k:
    9786           0 :     return cast<AlignMac68kAttr>(this)->clone(C);
    9787             :   case attr::AlignValue:
    9788           0 :     return cast<AlignValueAttr>(this)->clone(C);
    9789             :   case attr::Aligned:
    9790           4 :     return cast<AlignedAttr>(this)->clone(C);
    9791             :   case attr::AllocAlign:
    9792           0 :     return cast<AllocAlignAttr>(this)->clone(C);
    9793             :   case attr::AllocSize:
    9794           0 :     return cast<AllocSizeAttr>(this)->clone(C);
    9795             :   case attr::AlwaysInline:
    9796           1 :     return cast<AlwaysInlineAttr>(this)->clone(C);
    9797             :   case attr::AnalyzerNoReturn:
    9798           0 :     return cast<AnalyzerNoReturnAttr>(this)->clone(C);
    9799             :   case attr::Annotate:
    9800          42 :     return cast<AnnotateAttr>(this)->clone(C);
    9801             :   case attr::AnyX86Interrupt:
    9802           0 :     return cast<AnyX86InterruptAttr>(this)->clone(C);
    9803             :   case attr::AnyX86NoCallerSavedRegisters:
    9804           0 :     return cast<AnyX86NoCallerSavedRegistersAttr>(this)->clone(C);
    9805             :   case attr::AnyX86NoCfCheck:
    9806           0 :     return cast<AnyX86NoCfCheckAttr>(this)->clone(C);
    9807             :   case attr::ArcWeakrefUnavailable:
    9808           0 :     return cast<ArcWeakrefUnavailableAttr>(this)->clone(C);
    9809             :   case attr::ArgumentWithTypeTag:
    9810           0 :     return cast<ArgumentWithTypeTagAttr>(this)->clone(C);
    9811             :   case attr::Artificial:
    9812           0 :     return cast<ArtificialAttr>(this)->clone(C);
    9813             :   case attr::AsmLabel:
    9814          13 :     return cast<AsmLabelAttr>(this)->clone(C);
    9815             :   case attr::AssertCapability:
    9816          12 :     return cast<AssertCapabilityAttr>(this)->clone(C);
    9817             :   case attr::AssertExclusiveLock:
    9818           6 :     return cast<AssertExclusiveLockAttr>(this)->clone(C);
    9819             :   case attr::AssertSharedLock:
    9820           6 :     return cast<AssertSharedLockAttr>(this)->clone(C);
    9821             :   case attr::AssumeAligned:
    9822           4 :     return cast<AssumeAlignedAttr>(this)->clone(C);
    9823             :   case attr::Availability:
    9824         110 :     return cast<AvailabilityAttr>(this)->clone(C);
    9825             :   case attr::Blocks:
    9826           0 :     return cast<BlocksAttr>(this)->clone(C);
    9827             :   case attr::C11NoReturn:
    9828           7 :     return cast<C11NoReturnAttr>(this)->clone(C);
    9829             :   case attr::CDecl:
    9830           0 :     return cast<CDeclAttr>(this)->clone(C);
    9831             :   case attr::CFAuditedTransfer:
    9832           0 :     return cast<CFAuditedTransferAttr>(this)->clone(C);
    9833             :   case attr::CFConsumed:
    9834           5 :     return cast<CFConsumedAttr>(this)->clone(C);
    9835             :   case attr::CFReturnsNotRetained:
    9836           5 :     return cast<CFReturnsNotRetainedAttr>(this)->clone(C);
    9837             :   case attr::CFReturnsRetained:
    9838          16 :     return cast<CFReturnsRetainedAttr>(this)->clone(C);
    9839             :   case attr::CFUnknownTransfer:
    9840           0 :     return cast<CFUnknownTransferAttr>(this)->clone(C);
    9841             :   case attr::CUDAConstant:
    9842           0 :     return cast<CUDAConstantAttr>(this)->clone(C);
    9843             :   case attr::CUDADevice:
    9844           0 :     return cast<CUDADeviceAttr>(this)->clone(C);
    9845             :   case attr::CUDAGlobal:
    9846           0 :     return cast<CUDAGlobalAttr>(this)->clone(C);
    9847             :   case attr::CUDAHost:
    9848           0 :     return cast<CUDAHostAttr>(this)->clone(C);
    9849             :   case attr::CUDAInvalidTarget:
    9850           0 :     return cast<CUDAInvalidTargetAttr>(this)->clone(C);
    9851             :   case attr::CUDALaunchBounds:
    9852           0 :     return cast<CUDALaunchBoundsAttr>(this)->clone(C);
    9853             :   case attr::CUDAShared:
    9854           0 :     return cast<CUDASharedAttr>(this)->clone(C);
    9855             :   case attr::CXX11NoReturn:
    9856           4 :     return cast<CXX11NoReturnAttr>(this)->clone(C);
    9857             :   case attr::CallableWhen:
    9858           0 :     return cast<CallableWhenAttr>(this)->clone(C);
    9859             :   case attr::Capability:
    9860           0 :     return cast<CapabilityAttr>(this)->clone(C);
    9861             :   case attr::CapturedRecord:
    9862           0 :     return cast<CapturedRecordAttr>(this)->clone(C);
    9863             :   case attr::CarriesDependency:
    9864           5 :     return cast<CarriesDependencyAttr>(this)->clone(C);
    9865             :   case attr::Cleanup:
    9866           0 :     return cast<CleanupAttr>(this)->clone(C);
    9867             :   case attr::Cold:
    9868           1 :     return cast<ColdAttr>(this)->clone(C);
    9869             :   case attr::Common:
    9870           0 :     return cast<CommonAttr>(this)->clone(C);
    9871             :   case attr::Const:
    9872         461 :     return cast<ConstAttr>(this)->clone(C);
    9873             :   case attr::Constructor:
    9874          19 :     return cast<ConstructorAttr>(this)->clone(C);
    9875             :   case attr::Consumable:
    9876           0 :     return cast<ConsumableAttr>(this)->clone(C);
    9877             :   case attr::ConsumableAutoCast:
    9878           0 :     return cast<ConsumableAutoCastAttr>(this)->clone(C);
    9879             :   case attr::ConsumableSetOnRead:
    9880           0 :     return cast<ConsumableSetOnReadAttr>(this)->clone(C);
    9881             :   case attr::Convergent:
    9882           0 :     return cast<ConvergentAttr>(this)->clone(C);
    9883             :   case attr::DLLExport:
    9884        1934 :     return cast<DLLExportAttr>(this)->clone(C);
    9885             :   case attr::DLLImport:
    9886        1909 :     return cast<DLLImportAttr>(this)->clone(C);
    9887             :   case attr::Deprecated:
    9888         531 :     return cast<DeprecatedAttr>(this)->clone(C);
    9889             :   case attr::Destructor:
    9890          11 :     return cast<DestructorAttr>(this)->clone(C);
    9891             :   case attr::DiagnoseIf:
    9892           4 :     return cast<DiagnoseIfAttr>(this)->clone(C);
    9893             :   case attr::DisableTailCalls:
    9894           0 :     return cast<DisableTailCallsAttr>(this)->clone(C);
    9895             :   case attr::EmptyBases:
    9896           0 :     return cast<EmptyBasesAttr>(this)->clone(C);
    9897             :   case attr::EnableIf:
    9898           0 :     return cast<EnableIfAttr>(this)->clone(C);
    9899             :   case attr::EnumExtensibility:
    9900           2 :     return cast<EnumExtensibilityAttr>(this)->clone(C);
    9901             :   case attr::ExclusiveTrylockFunction:
    9902          12 :     return cast<ExclusiveTrylockFunctionAttr>(this)->clone(C);
    9903             :   case attr::ExternalSourceSymbol:
    9904           0 :     return cast<ExternalSourceSymbolAttr>(this)->clone(C);
    9905             :   case attr::FallThrough:
    9906           0 :     return cast<FallThroughAttr>(this)->clone(C);
    9907             :   case attr::FastCall:
    9908           0 :     return cast<FastCallAttr>(this)->clone(C);
    9909             :   case attr::Final:
    9910          12 :     return cast<FinalAttr>(this)->clone(C);
    9911             :   case attr::FlagEnum:
    9912           2 :     return cast<FlagEnumAttr>(this)->clone(C);
    9913             :   case attr::Flatten:
    9914           0 :     return cast<FlattenAttr>(this)->clone(C);
    9915             :   case attr::Format:
    9916           0 :     return cast<FormatAttr>(this)->clone(C);
    9917             :   case attr::FormatArg:
    9918           0 :     return cast<FormatArgAttr>(this)->clone(C);
    9919             :   case attr::GNUInline:
    9920           3 :     return cast<GNUInlineAttr>(this)->clone(C);
    9921             :   case attr::GuardedBy:
    9922           0 :     return cast<GuardedByAttr>(this)->clone(C);
    9923             :   case attr::GuardedVar:
    9924           0 :     return cast<GuardedVarAttr>(this)->clone(C);
    9925             :   case attr::Hot:
    9926           0 :     return cast<HotAttr>(this)->clone(C);
    9927             :   case attr::IBAction:
    9928           0 :     return cast<IBActionAttr>(this)->clone(C);
    9929             :   case attr::IBOutlet:
    9930           0 :     return cast<IBOutletAttr>(this)->clone(C);
    9931             :   case attr::IBOutletCollection:
    9932           0 :     return cast<IBOutletCollectionAttr>(this)->clone(C);
    9933             :   case attr::IFunc:
    9934           0 :     return cast<IFuncAttr>(this)->clone(C);
    9935             :   case attr::InitPriority:
    9936           0 :     return cast<InitPriorityAttr>(this)->clone(C);
    9937             :   case attr::InitSeg:
    9938           0 :     return cast<InitSegAttr>(this)->clone(C);
    9939             :   case attr::IntelOclBicc:
    9940           0 :     return cast<IntelOclBiccAttr>(this)->clone(C);
    9941             :   case attr::InternalLinkage:
    9942           0 :     return cast<InternalLinkageAttr>(this)->clone(C);
    9943             :   case attr::LTOVisibilityPublic:
    9944           0 :     return cast<LTOVisibilityPublicAttr>(this)->clone(C);
    9945             :   case attr::LayoutVersion:
    9946           0 :     return cast<LayoutVersionAttr>(this)->clone(C);
    9947             :   case attr::LockReturned:
    9948           3 :     return cast<LockReturnedAttr>(this)->clone(C);
    9949             :   case attr::LocksExcluded:
    9950          19 :     return cast<LocksExcludedAttr>(this)->clone(C);
    9951             :   case attr::LoopHint:
    9952           2 :     return cast<LoopHintAttr>(this)->clone(C);
    9953             :   case attr::MSABI:
    9954           0 :     return cast<MSABIAttr>(this)->clone(C);
    9955             :   case attr::MSInheritance:
    9956           0 :     return cast<MSInheritanceAttr>(this)->clone(C);
    9957             :   case attr::MSNoVTable:
    9958           0 :     return cast<MSNoVTableAttr>(this)->clone(C);
    9959             :   case attr::MSP430Interrupt:
    9960           0 :     return cast<MSP430InterruptAttr>(this)->clone(C);
    9961             :   case attr::MSStruct:
    9962           0 :     return cast<MSStructAttr>(this)->clone(C);
    9963             :   case attr::MSVtorDisp:
    9964           0 :     return cast<MSVtorDispAttr>(this)->clone(C);
    9965             :   case attr::MaxFieldAlignment:
    9966           0 :     return cast<MaxFieldAlignmentAttr>(this)->clone(C);
    9967             :   case attr::MayAlias:
    9968          14 :     return cast<MayAliasAttr>(this)->clone(C);
    9969             :   case attr::MicroMips:
    9970           0 :     return cast<MicroMipsAttr>(this)->clone(C);
    9971             :   case attr::MinSize:
    9972           0 :     return cast<MinSizeAttr>(this)->clone(C);
    9973             :   case attr::MinVectorWidth:
    9974           0 :     return cast<MinVectorWidthAttr>(this)->clone(C);
    9975             :   case attr::Mips16:
    9976           1 :     return cast<Mips16Attr>(this)->clone(C);
    9977             :   case attr::MipsInterrupt:
    9978           0 :     return cast<MipsInterruptAttr>(this)->clone(C);
    9979             :   case attr::MipsLongCall:
    9980           0 :     return cast<MipsLongCallAttr>(this)->clone(C);
    9981             :   case attr::MipsShortCall:
    9982           0 :     return cast<MipsShortCallAttr>(this)->clone(C);
    9983             :   case attr::Mode:
    9984           0 :     return cast<ModeAttr>(this)->clone(C);
    9985             :   case attr::NSConsumed:
    9986           6 :     return cast<NSConsumedAttr>(this)->clone(C);
    9987             :   case attr::NSConsumesSelf:
    9988         137 :     return cast<NSConsumesSelfAttr>(this)->clone(C);
    9989             :   case attr::NSReturnsAutoreleased:
    9990           0 :     return cast<NSReturnsAutoreleasedAttr>(this)->clone(C);
    9991             :   case attr::NSReturnsNotRetained:
    9992           8 :     return cast<NSReturnsNotRetainedAttr>(this)->clone(C);
    9993             :   case attr::NSReturnsRetained:
    9994         175 :     return cast<NSReturnsRetainedAttr>(this)->clone(C);
    9995             :   case attr::Naked:
    9996           1 :     return cast<NakedAttr>(this)->clone(C);
    9997             :   case attr::NoAlias:
    9998           0 :     return cast<NoAliasAttr>(this)->clone(C);
    9999             :   case attr::NoCommon:
   10000           0 :     return cast<NoCommonAttr>(this)->clone(C);
   10001             :   case attr::NoDebug:
   10002           4 :     return cast<NoDebugAttr>(this)->clone(C);
   10003             :   case attr::NoDuplicate:
   10004           0 :     return cast<NoDuplicateAttr>(this)->clone(C);
   10005             :   case attr::NoEscape:
   10006           0 :     return cast<NoEscapeAttr>(this)->clone(C);
   10007             :   case attr::NoInline:
   10008          36 :     return cast<NoInlineAttr>(this)->clone(C);
   10009             :   case attr::NoInstrumentFunction:
   10010           3 :     return cast<NoInstrumentFunctionAttr>(this)->clone(C);
   10011             :   case attr::NoMicroMips:
   10012           0 :     return cast<NoMicroMipsAttr>(this)->clone(C);
   10013             :   case attr::NoMips16:
   10014           2 :     return cast<NoMips16Attr>(this)->clone(C);
   10015             :   case attr::NoReturn:
   10016           0 :     return cast<NoReturnAttr>(this)->clone(C);
   10017             :   case attr::NoSanitize:
   10018          18 :     return cast<NoSanitizeAttr>(this)->clone(C);
   10019             :   case attr::NoSplitStack:
   10020           0 :     return cast<NoSplitStackAttr>(this)->clone(C);
   10021             :   case attr::NoStackProtector:
   10022           0 :     return cast<NoStackProtectorAttr>(this)->clone(C);
   10023             :   case attr::NoThreadSafetyAnalysis:
   10024           7 :     return cast<NoThreadSafetyAnalysisAttr>(this)->clone(C);
   10025             :   case attr::NoThrow:
   10026        2053 :     return cast<NoThrowAttr>(this)->clone(C);
   10027             :   case attr::NonNull:
   10028        1481 :     return cast<NonNullAttr>(this)->clone(C);
   10029             :   case attr::NotTailCalled:
   10030           0 :     return cast<NotTailCalledAttr>(this)->clone(C);
   10031             :   case attr::OMPCaptureKind:
   10032           0 :     return cast<OMPCaptureKindAttr>(this)->clone(C);
   10033             :   case attr::OMPCaptureNoInit:
   10034           0 :     return cast<OMPCaptureNoInitAttr>(this)->clone(C);
   10035             :   case attr::OMPDeclareSimdDecl:
   10036           0 :     return cast<OMPDeclareSimdDeclAttr>(this)->clone(C);
   10037             :   case attr::OMPDeclareTargetDecl:
   10038           0 :     return cast<OMPDeclareTargetDeclAttr>(this)->clone(C);
   10039             :   case attr::OMPReferencedVar:
   10040           0 :     return cast<OMPReferencedVarAttr>(this)->clone(C);
   10041             :   case attr::OMPThreadPrivateDecl:
   10042          40 :     return cast<OMPThreadPrivateDeclAttr>(this)->clone(C);
   10043             :   case attr::ObjCBoxable:
   10044           0 :     return cast<ObjCBoxableAttr>(this)->clone(C);
   10045             :   case attr::ObjCBridge:
   10046           4 :     return cast<ObjCBridgeAttr>(this)->clone(C);
   10047             :   case attr::ObjCBridgeMutable:
   10048           1 :     return cast<ObjCBridgeMutableAttr>(this)->clone(C);
   10049             :   case attr::ObjCBridgeRelated:
   10050           0 :     return cast<ObjCBridgeRelatedAttr>(this)->clone(C);
   10051             :   case attr::ObjCDesignatedInitializer:
   10052           0 :     return cast<ObjCDesignatedInitializerAttr>(this)->clone(C);
   10053             :   case attr::ObjCException:
   10054           0 :     return cast<ObjCExceptionAttr>(this)->clone(C);
   10055             :   case attr::ObjCExplicitProtocolImpl:
   10056           0 :     return cast<ObjCExplicitProtocolImplAttr>(this)->clone(C);
   10057             :   case attr::ObjCIndependentClass:
   10058           0 :     return cast<ObjCIndependentClassAttr>(this)->clone(C);
   10059             :   case attr::ObjCMethodFamily:
   10060           9 :     return cast<ObjCMethodFamilyAttr>(this)->clone(C);
   10061             :   case attr::ObjCNSObject:
   10062           0 :     return cast<ObjCNSObjectAttr>(this)->clone(C);
   10063             :   case attr::ObjCPreciseLifetime:
   10064           0 :     return cast<ObjCPreciseLifetimeAttr>(this)->clone(C);
   10065             :   case attr::ObjCRequiresPropertyDefs:
   10066           0 :     return cast<ObjCRequiresPropertyDefsAttr>(this)->clone(C);
   10067             :   case attr::ObjCRequiresSuper:
   10068          12 :     return cast<ObjCRequiresSuperAttr>(this)->clone(C);
   10069             :   case attr::ObjCReturnsInnerPointer:
   10070           0 :     return cast<ObjCReturnsInnerPointerAttr>(this)->clone(C);
   10071             :   case attr::ObjCRootClass:
   10072           0 :     return cast<ObjCRootClassAttr>(this)->clone(C);
   10073             :   case attr::ObjCRuntimeName:
   10074           0 :     return cast<ObjCRuntimeNameAttr>(this)->clone(C);
   10075             :   case attr::ObjCRuntimeVisible:
   10076           0 :     return cast<ObjCRuntimeVisibleAttr>(this)->clone(C);
   10077             :   case attr::ObjCSubclassingRestricted:
   10078           0 :     return cast<ObjCSubclassingRestrictedAttr>(this)->clone(C);
   10079             :   case attr::OpenCLAccess:
   10080           0 :     return cast<OpenCLAccessAttr>(this)->clone(C);
   10081             :   case attr::OpenCLIntelReqdSubGroupSize:
   10082           0 :     return cast<OpenCLIntelReqdSubGroupSizeAttr>(this)->clone(C);
   10083             :   case attr::OpenCLKernel:
   10084           0 :     return cast<OpenCLKernelAttr>(this)->clone(C);
   10085             :   case attr::OpenCLUnrollHint:
   10086           0 :     return cast<OpenCLUnrollHintAttr>(this)->clone(C);
   10087             :   case attr::OptimizeNone:
   10088           0 :     return cast<OptimizeNoneAttr>(this)->clone(C);
   10089             :   case attr::Overloadable:
   10090           0 :     return cast<OverloadableAttr>(this)->clone(C);
   10091             :   case attr::Override:
   10092          46 :     return cast<OverrideAttr>(this)->clone(C);
   10093             :   case attr::Ownership:
   10094           0 :     return cast<OwnershipAttr>(this)->clone(C);
   10095             :   case attr::Packed:
   10096           9 :     return cast<PackedAttr>(this)->clone(C);
   10097             :   case attr::ParamTypestate:
   10098           0 :     return cast<ParamTypestateAttr>(this)->clone(C);
   10099             :   case attr::Pascal:
   10100           0 :     return cast<PascalAttr>(this)->clone(C);
   10101             :   case attr::PassObjectSize:
   10102          20 :     return cast<PassObjectSizeAttr>(this)->clone(C);
   10103             :   case attr::Pcs:
   10104           0 :     return cast<PcsAttr>(this)->clone(C);
   10105             :   case attr::PragmaClangBSSSection:
   10106           5 :     return cast<PragmaClangBSSSectionAttr>(this)->clone(C);
   10107             :   case attr::PragmaClangDataSection:
   10108           0 :     return cast<PragmaClangDataSectionAttr>(this)->clone(C);
   10109             :   case attr::PragmaClangRodataSection:
   10110           2 :     return cast<PragmaClangRodataSectionAttr>(this)->clone(C);
   10111             :   case attr::PragmaClangTextSection:
   10112           0 :     return cast<PragmaClangTextSectionAttr>(this)->clone(C);
   10113             :   case attr::PreserveAll:
   10114           0 :     return cast<PreserveAllAttr>(this)->clone(C);
   10115             :   case attr::PreserveMost:
   10116           0 :     return cast<PreserveMostAttr>(this)->clone(C);
   10117             :   case attr::PtGuardedBy:
   10118           0 :     return cast<PtGuardedByAttr>(this)->clone(C);
   10119             :   case attr::PtGuardedVar:
   10120           0 :     return cast<PtGuardedVarAttr>(this)->clone(C);
   10121             :   case attr::Pure:
   10122         420 :     return cast<PureAttr>(this)->clone(C);
   10123             :   case attr::RegCall:
   10124           0 :     return cast<RegCallAttr>(this)->clone(C);
   10125             :   case attr::ReleaseCapability:
   10126          35 :     return cast<ReleaseCapabilityAttr>(this)->clone(C);
   10127             :   case attr::RenderScriptKernel:
   10128           0 :     return cast<RenderScriptKernelAttr>(this)->clone(C);
   10129             :   case attr::ReqdWorkGroupSize:
   10130           0 :     return cast<ReqdWorkGroupSizeAttr>(this)->clone(C);
   10131             :   case attr::RequireConstantInit:
   10132          22 :     return cast<RequireConstantInitAttr>(this)->clone(C);
   10133             :   case attr::RequiresCapability:
   10134         134 :     return cast<RequiresCapabilityAttr>(this)->clone(C);
   10135             :   case attr::Restrict:
   10136           6 :     return cast<RestrictAttr>(this)->clone(C);
   10137             :   case attr::ReturnTypestate:
   10138           2 :     return cast<ReturnTypestateAttr>(this)->clone(C);
   10139             :   case attr::ReturnsNonNull:
   10140           1 :     return cast<ReturnsNonNullAttr>(this)->clone(C);
   10141             :   case attr::ReturnsTwice:
   10142          41 :     return cast<ReturnsTwiceAttr>(this)->clone(C);
   10143             :   case attr::ScopedLockable:
   10144           0 :     return cast<ScopedLockableAttr>(this)->clone(C);
   10145             :   case attr::Section:
   10146           0 :     return cast<SectionAttr>(this)->clone(C);
   10147             :   case attr::SelectAny:
   10148           3 :     return cast<SelectAnyAttr>(this)->clone(C);
   10149             :   case attr::Sentinel:
   10150           0 :     return cast<SentinelAttr>(this)->clone(C);
   10151             :   case attr::SetTypestate:
   10152           0 :     return cast<SetTypestateAttr>(this)->clone(C);
   10153             :   case attr::SharedTrylockFunction:
   10154           9 :     return cast<SharedTrylockFunctionAttr>(this)->clone(C);
   10155             :   case attr::StdCall:
   10156           0 :     return cast<StdCallAttr>(this)->clone(C);
   10157             :   case attr::Suppress:
   10158           0 :     return cast<SuppressAttr>(this)->clone(C);
   10159             :   case attr::SwiftCall:
   10160           0 :     return cast<SwiftCallAttr>(this)->clone(C);
   10161             :   case attr::SwiftContext:
   10162           0 :     return cast<SwiftContextAttr>(this)->clone(C);
   10163             :   case attr::SwiftErrorResult:
   10164           0 :     return cast<SwiftErrorResultAttr>(this)->clone(C);
   10165             :   case attr::SwiftIndirectResult:
   10166           0 :     return cast<SwiftIndirectResultAttr>(this)->clone(C);
   10167             :   case attr::SysVABI:
   10168           0 :     return cast<SysVABIAttr>(this)->clone(C);
   10169             :   case attr::TLSModel:
   10170           3 :     return cast<TLSModelAttr>(this)->clone(C);
   10171             :   case attr::Target:
   10172           3 :     return cast<TargetAttr>(this)->clone(C);
   10173             :   case attr::TestTypestate:
   10174           0 :     return cast<TestTypestateAttr>(this)->clone(C);
   10175             :   case attr::ThisCall:
   10176           0 :     return cast<ThisCallAttr>(this)->clone(C);
   10177             :   case attr::Thread:
   10178           0 :     return cast<ThreadAttr>(this)->clone(C);
   10179             :   case attr::TransparentUnion:
   10180           0 :     return cast<TransparentUnionAttr>(this)->clone(C);
   10181             :   case attr::TrivialABI:
   10182           0 :     return cast<TrivialABIAttr>(this)->clone(C);
   10183             :   case attr::TryAcquireCapability:
   10184           5 :     return cast<TryAcquireCapabilityAttr>(this)->clone(C);
   10185             :   case attr::TypeTagForDatatype:
   10186           0 :     return cast<TypeTagForDatatypeAttr>(this)->clone(C);
   10187             :   case attr::TypeVisibility:
   10188         315 :     return cast<TypeVisibilityAttr>(this)->clone(C);
   10189             :   case attr::Unavailable:
   10190          55 :     return cast<UnavailableAttr>(this)->clone(C);
   10191             :   case attr::Unused:
   10192         346 :     return cast<UnusedAttr>(this)->clone(C);
   10193             :   case attr::Used:
   10194           0 :     return cast<UsedAttr>(this)->clone(C);
   10195             :   case attr::Uuid:
   10196           0 :     return cast<UuidAttr>(this)->clone(C);
   10197             :   case attr::VecReturn:
   10198           0 :     return cast<VecReturnAttr>(this)->clone(C);
   10199             :   case attr::VecTypeHint:
   10200           0 :     return cast<VecTypeHintAttr>(this)->clone(C);
   10201             :   case attr::VectorCall:
   10202           0 :     return cast<VectorCallAttr>(this)->clone(C);
   10203             :   case attr::Visibility:
   10204           8 :     return cast<VisibilityAttr>(this)->clone(C);
   10205             :   case attr::WarnUnused:
   10206           0 :     return cast<WarnUnusedAttr>(this)->clone(C);
   10207             :   case attr::WarnUnusedResult:
   10208         303 :     return cast<WarnUnusedResultAttr>(this)->clone(C);
   10209             :   case attr::Weak:
   10210          36 :     return cast<WeakAttr>(this)->clone(C);
   10211             :   case attr::WeakImport:
   10212           8 :     return cast<WeakImportAttr>(this)->clone(C);
   10213             :   case attr::WeakRef:
   10214           0 :     return cast<WeakRefAttr>(this)->clone(C);
   10215             :   case attr::WorkGroupSizeHint:
   10216           0 :     return cast<WorkGroupSizeHintAttr>(this)->clone(C);
   10217             :   case attr::X86ForceAlignArgPointer:
   10218           1 :     return cast<X86ForceAlignArgPointerAttr>(this)->clone(C);
   10219             :   case attr::XRayInstrument:
   10220           0 :     return cast<XRayInstrumentAttr>(this)->clone(C);
   10221             :   case attr::XRayLogArgs:
   10222           0 :     return cast<XRayLogArgsAttr>(this)->clone(C);
   10223             :   }
   10224           0 :   llvm_unreachable("Unexpected attribute kind!");
   10225             : }
   10226             : 
   10227         470 : void Attr::printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const {
   10228         470 :   switch (getKind()) {
   10229             :   case attr::AMDGPUFlatWorkGroupSize:
   10230           0 :     return cast<AMDGPUFlatWorkGroupSizeAttr>(this)->printPretty(OS, Policy);
   10231             :   case attr::AMDGPUNumSGPR:
   10232           0 :     return cast<AMDGPUNumSGPRAttr>(this)->printPretty(OS, Policy);
   10233             :   case attr::AMDGPUNumVGPR:
   10234           0 :     return cast<AMDGPUNumVGPRAttr>(this)->printPretty(OS, Policy);
   10235             :   case attr::AMDGPUWavesPerEU:
   10236           0 :     return cast<AMDGPUWavesPerEUAttr>(this)->printPretty(OS, Policy);
   10237             :   case attr::ARMInterrupt:
   10238           0 :     return cast<ARMInterruptAttr>(this)->printPretty(OS, Policy);
   10239             :   case attr::AVRInterrupt:
   10240           0 :     return cast<AVRInterruptAttr>(this)->printPretty(OS, Policy);
   10241             :   case attr::AVRSignal:
   10242           0 :     return cast<AVRSignalAttr>(this)->printPretty(OS, Policy);
   10243             :   case attr::AbiTag:
   10244           0 :     return cast<AbiTagAttr>(this)->printPretty(OS, Policy);
   10245             :   case attr::AcquireCapability:
   10246           0 :     return cast<AcquireCapabilityAttr>(this)->printPretty(OS, Policy);
   10247             :   case attr::AcquiredAfter:
   10248           0 :     return cast<AcquiredAfterAttr>(this)->printPretty(OS, Policy);
   10249             :   case attr::AcquiredBefore:
   10250           0 :     return cast<AcquiredBeforeAttr>(this)->printPretty(OS, Policy);
   10251             :   case attr::Alias:
   10252           0 :     return cast<AliasAttr>(this)->printPretty(OS, Policy);
   10253             :   case attr::AlignMac68k:
   10254           0 :     return cast<AlignMac68kAttr>(this)->printPretty(OS, Policy);
   10255             :   case attr::AlignValue:
   10256           0 :     return cast<AlignValueAttr>(this)->printPretty(OS, Policy);
   10257             :   case attr::Aligned:
   10258          62 :     return cast<AlignedAttr>(this)->printPretty(OS, Policy);
   10259             :   case attr::AllocAlign:
   10260           4 :     return cast<AllocAlignAttr>(this)->printPretty(OS, Policy);
   10261             :   case attr::AllocSize:
   10262           8 :     return cast<AllocSizeAttr>(this)->printPretty(OS, Policy);
   10263             :   case attr::AlwaysInline:
   10264           0 :     return cast<AlwaysInlineAttr>(this)->printPretty(OS, Policy);
   10265             :   case attr::AnalyzerNoReturn:
   10266           0 :     return cast<AnalyzerNoReturnAttr>(this)->printPretty(OS, Policy);
   10267             :   case attr::Annotate:
   10268           0 :     return cast<AnnotateAttr>(this)->printPretty(OS, Policy);
   10269             :   case attr::AnyX86Interrupt:
   10270           0 :     return cast<AnyX86InterruptAttr>(this)->printPretty(OS, Policy);
   10271             :   case attr::AnyX86NoCallerSavedRegisters:
   10272           0 :     return cast<AnyX86NoCallerSavedRegistersAttr>(this)->printPretty(OS, Policy);
   10273             :   case attr::AnyX86NoCfCheck:
   10274           0 :     return cast<AnyX86NoCfCheckAttr>(this)->printPretty(OS, Policy);
   10275             :   case attr::ArcWeakrefUnavailable:
   10276           0 :     return cast<ArcWeakrefUnavailableAttr>(this)->printPretty(OS, Policy);
   10277             :   case attr::ArgumentWithTypeTag:
   10278           8 :     return cast<ArgumentWithTypeTagAttr>(this)->printPretty(OS, Policy);
   10279             :   case attr::Artificial:
   10280           0 :     return cast<ArtificialAttr>(this)->printPretty(OS, Policy);
   10281             :   case attr::AsmLabel:
   10282           0 :     return cast<AsmLabelAttr>(this)->printPretty(OS, Policy);
   10283             :   case attr::AssertCapability:
   10284           0 :     return cast<AssertCapabilityAttr>(this)->printPretty(OS, Policy);
   10285             :   case attr::AssertExclusiveLock:
   10286           0 :     return cast<AssertExclusiveLockAttr>(this)->printPretty(OS, Policy);
   10287             :   case attr::AssertSharedLock:
   10288           0 :     return cast<AssertSharedLockAttr>(this)->printPretty(OS, Policy);
   10289             :   case attr::AssumeAligned:
   10290           0 :     return cast<AssumeAlignedAttr>(this)->printPretty(OS, Policy);
   10291             :   case attr::Availability:
   10292           6 :     return cast<AvailabilityAttr>(this)->printPretty(OS, Policy);
   10293             :   case attr::Blocks:
   10294           2 :     return cast<BlocksAttr>(this)->printPretty(OS, Policy);
   10295             :   case attr::C11NoReturn:
   10296           0 :     return cast<C11NoReturnAttr>(this)->printPretty(OS, Policy);
   10297             :   case attr::CDecl:
   10298           0 :     return cast<CDeclAttr>(this)->printPretty(OS, Policy);
   10299             :   case attr::CFAuditedTransfer:
   10300           0 :     return cast<CFAuditedTransferAttr>(this)->printPretty(OS, Policy);
   10301             :   case attr::CFConsumed:
   10302           0 :     return cast<CFConsumedAttr>(this)->printPretty(OS, Policy);
   10303             :   case attr::CFReturnsNotRetained:
   10304           0 :     return cast<CFReturnsNotRetainedAttr>(this)->printPretty(OS, Policy);
   10305             :   case attr::CFReturnsRetained:
   10306           0 :     return cast<CFReturnsRetainedAttr>(this)->printPretty(OS, Policy);
   10307             :   case attr::CFUnknownTransfer:
   10308           0 :     return cast<CFUnknownTransferAttr>(this)->printPretty(OS, Policy);
   10309             :   case attr::CUDAConstant:
   10310           0 :     return cast<CUDAConstantAttr>(this)->printPretty(OS, Policy);
   10311             :   case attr::CUDADevice:
   10312           0 :     return cast<CUDADeviceAttr>(this)->printPretty(OS, Policy);
   10313             :   case attr::CUDAGlobal:
   10314           0 :     return cast<CUDAGlobalAttr>(this)->printPretty(OS, Policy);
   10315             :   case attr::CUDAHost:
   10316           0 :     return cast<CUDAHostAttr>(this)->printPretty(OS, Policy);
   10317             :   case attr::CUDAInvalidTarget:
   10318           0 :     return cast<CUDAInvalidTargetAttr>(this)->printPretty(OS, Policy);
   10319             :   case attr::CUDALaunchBounds:
   10320           0 :     return cast<CUDALaunchBoundsAttr>(this)->printPretty(OS, Policy);
   10321             :   case attr::CUDAShared:
   10322