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: 1269 6825 18.6 %
Date: 2018-10-20 13:21:21 Functions: 194 776 25.0 %
Legend: Lines: hit not hit

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