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: 1054 5921 17.8 %
Date: 2018-02-18 16:14:26 Functions: 172 686 25.1 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.13