LCOV - code coverage report
Current view: top level - build-llvm/tools/clang/include/clang/Serialization - AttrPCHWrite.inc (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 311 874 35.6 %
Date: 2018-05-20 00:06:23 Functions: 0 0 -
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
       2             : |*                                                                            *|
       3             : |* Attribute serialization code                                               *|
       4             : |*                                                                            *|
       5             : |* Automatically generated file, do not edit!                                 *|
       6             : |*                                                                            *|
       7             : \*===----------------------------------------------------------------------===*/
       8             : 
       9      206181 :   switch (A->getKind()) {
      10             :   case attr::AMDGPUFlatWorkGroupSize: {
      11             :     const auto *SA = cast<AMDGPUFlatWorkGroupSizeAttr>(A);
      12           0 :     Record.push_back(SA->isInherited());
      13           0 :     Record.push_back(A->isImplicit());
      14           0 :     Record.push_back(A->getSpellingListIndex());
      15           0 :     Record.push_back(SA->getMin());
      16           0 :     Record.push_back(SA->getMax());
      17             :     break;
      18             :   }
      19             :   case attr::AMDGPUNumSGPR: {
      20             :     const auto *SA = cast<AMDGPUNumSGPRAttr>(A);
      21           0 :     Record.push_back(SA->isInherited());
      22           0 :     Record.push_back(A->isImplicit());
      23           0 :     Record.push_back(A->getSpellingListIndex());
      24           0 :     Record.push_back(SA->getNumSGPR());
      25             :     break;
      26             :   }
      27             :   case attr::AMDGPUNumVGPR: {
      28             :     const auto *SA = cast<AMDGPUNumVGPRAttr>(A);
      29           0 :     Record.push_back(SA->isInherited());
      30           0 :     Record.push_back(A->isImplicit());
      31           0 :     Record.push_back(A->getSpellingListIndex());
      32           0 :     Record.push_back(SA->getNumVGPR());
      33             :     break;
      34             :   }
      35             :   case attr::AMDGPUWavesPerEU: {
      36             :     const auto *SA = cast<AMDGPUWavesPerEUAttr>(A);
      37           0 :     Record.push_back(SA->isInherited());
      38           0 :     Record.push_back(A->isImplicit());
      39           0 :     Record.push_back(A->getSpellingListIndex());
      40           0 :     Record.push_back(SA->getMin());
      41           0 :     Record.push_back(SA->getMax());
      42             :     break;
      43             :   }
      44             :   case attr::ARMInterrupt: {
      45             :     const auto *SA = cast<ARMInterruptAttr>(A);
      46           0 :     Record.push_back(SA->isInherited());
      47           0 :     Record.push_back(A->isImplicit());
      48           0 :     Record.push_back(A->getSpellingListIndex());
      49           0 : Record.push_back(SA->getInterrupt());
      50             :     break;
      51             :   }
      52             :   case attr::AVRInterrupt: {
      53             :     const auto *SA = cast<AVRInterruptAttr>(A);
      54           0 :     Record.push_back(SA->isInherited());
      55           0 :     Record.push_back(A->isImplicit());
      56           0 :     Record.push_back(A->getSpellingListIndex());
      57             :     break;
      58             :   }
      59             :   case attr::AVRSignal: {
      60             :     const auto *SA = cast<AVRSignalAttr>(A);
      61           0 :     Record.push_back(SA->isInherited());
      62           0 :     Record.push_back(A->isImplicit());
      63           0 :     Record.push_back(A->getSpellingListIndex());
      64             :     break;
      65             :   }
      66             :   case attr::AbiTag: {
      67             :     const auto *SA = cast<AbiTagAttr>(A);
      68           1 :     Record.push_back(A->isImplicit());
      69           1 :     Record.push_back(A->getSpellingListIndex());
      70           1 :     Record.push_back(SA->tags_size());
      71           7 :     for (auto &Val : SA->tags())
      72           3 :       Record.AddString(Val);
      73             :     break;
      74             :   }
      75             :   case attr::AcquireCapability: {
      76             :     const auto *SA = cast<AcquireCapabilityAttr>(A);
      77          10 :     Record.push_back(SA->isInherited());
      78          10 :     Record.push_back(A->isImplicit());
      79          10 :     Record.push_back(A->getSpellingListIndex());
      80          10 :     Record.push_back(SA->args_size());
      81          22 :     for (auto &Val : SA->args())
      82           6 :       Record.AddStmt(Val);
      83             :     break;
      84             :   }
      85             :   case attr::AcquiredAfter: {
      86             :     const auto *SA = cast<AcquiredAfterAttr>(A);
      87           1 :     Record.push_back(SA->isInherited());
      88           1 :     Record.push_back(A->isImplicit());
      89           1 :     Record.push_back(A->getSpellingListIndex());
      90           1 :     Record.push_back(SA->args_size());
      91           3 :     for (auto &Val : SA->args())
      92           1 :       Record.AddStmt(Val);
      93             :     break;
      94             :   }
      95             :   case attr::AcquiredBefore: {
      96             :     const auto *SA = cast<AcquiredBeforeAttr>(A);
      97             :     Record.push_back(SA->isInherited());
      98           0 :     Record.push_back(A->isImplicit());
      99           0 :     Record.push_back(A->getSpellingListIndex());
     100           0 :     Record.push_back(SA->args_size());
     101           0 :     for (auto &Val : SA->args())
     102           0 :       Record.AddStmt(Val);
     103             :     break;
     104             :   }
     105             :   case attr::Alias: {
     106             :     const auto *SA = cast<AliasAttr>(A);
     107           0 :     Record.push_back(A->isImplicit());
     108           0 :     Record.push_back(A->getSpellingListIndex());
     109           0 :     Record.AddString(SA->getAliasee());
     110             :     break;
     111             :   }
     112             :   case attr::AlignMac68k: {
     113             :     const auto *SA = cast<AlignMac68kAttr>(A);
     114           0 :     Record.push_back(SA->isInherited());
     115           0 :     Record.push_back(A->isImplicit());
     116           0 :     Record.push_back(A->getSpellingListIndex());
     117             :     break;
     118             :   }
     119             :   case attr::AlignValue: {
     120             :     const auto *SA = cast<AlignValueAttr>(A);
     121           4 :     Record.push_back(A->isImplicit());
     122           4 :     Record.push_back(A->getSpellingListIndex());
     123           4 :     Record.AddStmt(SA->getAlignment());
     124             :     break;
     125             :   }
     126             :   case attr::Aligned: {
     127             :     const auto *SA = cast<AlignedAttr>(A);
     128         418 :     Record.push_back(SA->isInherited());
     129         418 :     Record.push_back(A->isImplicit());
     130         418 :     Record.push_back(A->getSpellingListIndex());
     131         418 :     Record.push_back(SA->isAlignmentExpr());
     132         418 :     if (SA->isAlignmentExpr())
     133         418 :       Record.AddStmt(SA->getAlignmentExpr());
     134             :     else
     135           0 :       Record.AddTypeSourceInfo(SA->getAlignmentType());
     136             :     break;
     137             :   }
     138             :   case attr::AllocAlign: {
     139             :     const auto *SA = cast<AllocAlignAttr>(A);
     140           2 :     Record.push_back(SA->isInherited());
     141           2 :     Record.push_back(A->isImplicit());
     142           2 :     Record.push_back(A->getSpellingListIndex());
     143           2 :     Record.push_back(SA->getParamIndex().serialize());
     144           2 :     break;
     145             :   }
     146             :   case attr::AllocSize: {
     147             :     const auto *SA = cast<AllocSizeAttr>(A);
     148           4 :     Record.push_back(SA->isInherited());
     149           4 :     Record.push_back(A->isImplicit());
     150           4 :     Record.push_back(A->getSpellingListIndex());
     151           4 :     Record.push_back(SA->getElemSizeParam().serialize());
     152           4 :     Record.push_back(SA->getNumElemsParam().serialize());
     153           4 :     break;
     154             :   }
     155             :   case attr::AlwaysInline: {
     156             :     const auto *SA = cast<AlwaysInlineAttr>(A);
     157       25109 :     Record.push_back(SA->isInherited());
     158       25109 :     Record.push_back(A->isImplicit());
     159       25109 :     Record.push_back(A->getSpellingListIndex());
     160             :     break;
     161             :   }
     162             :   case attr::AnalyzerNoReturn: {
     163             :     const auto *SA = cast<AnalyzerNoReturnAttr>(A);
     164           0 :     Record.push_back(SA->isInherited());
     165           0 :     Record.push_back(A->isImplicit());
     166           0 :     Record.push_back(A->getSpellingListIndex());
     167             :     break;
     168             :   }
     169             :   case attr::Annotate: {
     170             :     const auto *SA = cast<AnnotateAttr>(A);
     171           0 :     Record.push_back(SA->isInherited());
     172           0 :     Record.push_back(A->isImplicit());
     173           0 :     Record.push_back(A->getSpellingListIndex());
     174           0 :     Record.AddString(SA->getAnnotation());
     175             :     break;
     176             :   }
     177             :   case attr::AnyX86Interrupt: {
     178             :     const auto *SA = cast<AnyX86InterruptAttr>(A);
     179           0 :     Record.push_back(SA->isInherited());
     180           0 :     Record.push_back(A->isImplicit());
     181           0 :     Record.push_back(A->getSpellingListIndex());
     182             :     break;
     183             :   }
     184             :   case attr::AnyX86NoCallerSavedRegisters: {
     185             :     const auto *SA = cast<AnyX86NoCallerSavedRegistersAttr>(A);
     186           0 :     Record.push_back(SA->isInherited());
     187           0 :     Record.push_back(A->isImplicit());
     188           0 :     Record.push_back(A->getSpellingListIndex());
     189             :     break;
     190             :   }
     191             :   case attr::AnyX86NoCfCheck: {
     192             :     const auto *SA = cast<AnyX86NoCfCheckAttr>(A);
     193           0 :     Record.push_back(SA->isInherited());
     194           0 :     Record.push_back(A->isImplicit());
     195           0 :     Record.push_back(A->getSpellingListIndex());
     196             :     break;
     197             :   }
     198             :   case attr::ArcWeakrefUnavailable: {
     199             :     const auto *SA = cast<ArcWeakrefUnavailableAttr>(A);
     200           0 :     Record.push_back(SA->isInherited());
     201           0 :     Record.push_back(A->isImplicit());
     202           0 :     Record.push_back(A->getSpellingListIndex());
     203             :     break;
     204             :   }
     205             :   case attr::ArgumentWithTypeTag: {
     206             :     const auto *SA = cast<ArgumentWithTypeTagAttr>(A);
     207           4 :     Record.push_back(SA->isInherited());
     208           4 :     Record.push_back(A->isImplicit());
     209           4 :     Record.push_back(A->getSpellingListIndex());
     210           4 :     Record.AddIdentifierRef(SA->getArgumentKind());
     211           4 :     Record.push_back(SA->getArgumentIdx().serialize());
     212           4 :     Record.push_back(SA->getTypeTagIdx().serialize());
     213           4 :     Record.push_back(SA->getIsPointer());
     214             :     break;
     215             :   }
     216             :   case attr::Artificial: {
     217             :     const auto *SA = cast<ArtificialAttr>(A);
     218           0 :     Record.push_back(SA->isInherited());
     219           0 :     Record.push_back(A->isImplicit());
     220           0 :     Record.push_back(A->getSpellingListIndex());
     221             :     break;
     222             :   }
     223             :   case attr::AsmLabel: {
     224             :     const auto *SA = cast<AsmLabelAttr>(A);
     225           8 :     Record.push_back(SA->isInherited());
     226           8 :     Record.push_back(A->isImplicit());
     227           8 :     Record.push_back(A->getSpellingListIndex());
     228          16 :     Record.AddString(SA->getLabel());
     229             :     break;
     230             :   }
     231             :   case attr::AssertCapability: {
     232             :     const auto *SA = cast<AssertCapabilityAttr>(A);
     233           0 :     Record.push_back(SA->isInherited());
     234           0 :     Record.push_back(A->isImplicit());
     235           0 :     Record.push_back(A->getSpellingListIndex());
     236           0 :     Record.push_back(SA->args_size());
     237           0 :     for (auto &Val : SA->args())
     238           0 :       Record.AddStmt(Val);
     239             :     break;
     240             :   }
     241             :   case attr::AssertExclusiveLock: {
     242             :     const auto *SA = cast<AssertExclusiveLockAttr>(A);
     243           0 :     Record.push_back(SA->isInherited());
     244           0 :     Record.push_back(A->isImplicit());
     245           0 :     Record.push_back(A->getSpellingListIndex());
     246           0 :     Record.push_back(SA->args_size());
     247           0 :     for (auto &Val : SA->args())
     248           0 :       Record.AddStmt(Val);
     249             :     break;
     250             :   }
     251             :   case attr::AssertSharedLock: {
     252             :     const auto *SA = cast<AssertSharedLockAttr>(A);
     253           0 :     Record.push_back(SA->isInherited());
     254           0 :     Record.push_back(A->isImplicit());
     255           0 :     Record.push_back(A->getSpellingListIndex());
     256           0 :     Record.push_back(SA->args_size());
     257           0 :     for (auto &Val : SA->args())
     258           0 :       Record.AddStmt(Val);
     259             :     break;
     260             :   }
     261             :   case attr::AssumeAligned: {
     262             :     const auto *SA = cast<AssumeAlignedAttr>(A);
     263           0 :     Record.push_back(SA->isInherited());
     264           0 :     Record.push_back(A->isImplicit());
     265           0 :     Record.push_back(A->getSpellingListIndex());
     266           0 :     Record.AddStmt(SA->getAlignment());
     267           0 :     Record.AddStmt(SA->getOffset());
     268             :     break;
     269             :   }
     270             :   case attr::Availability: {
     271             :     const auto *SA = cast<AvailabilityAttr>(A);
     272           4 :     Record.push_back(SA->isInherited());
     273           4 :     Record.push_back(A->isImplicit());
     274           4 :     Record.push_back(A->getSpellingListIndex());
     275           4 :     Record.AddIdentifierRef(SA->getPlatform());
     276           8 :     Record.AddVersionTuple(SA->getIntroduced());
     277           8 :     Record.AddVersionTuple(SA->getDeprecated());
     278           8 :     Record.AddVersionTuple(SA->getObsoleted());
     279           4 :     Record.push_back(SA->getUnavailable());
     280           8 :     Record.AddString(SA->getMessage());
     281           4 :     Record.push_back(SA->getStrict());
     282           8 :     Record.AddString(SA->getReplacement());
     283             :     break;
     284             :   }
     285             :   case attr::Blocks: {
     286             :     const auto *SA = cast<BlocksAttr>(A);
     287           2 :     Record.push_back(SA->isInherited());
     288           2 :     Record.push_back(A->isImplicit());
     289           2 :     Record.push_back(A->getSpellingListIndex());
     290           2 : Record.push_back(SA->getType());
     291             :     break;
     292             :   }
     293             :   case attr::C11NoReturn: {
     294             :     const auto *SA = cast<C11NoReturnAttr>(A);
     295           0 :     Record.push_back(SA->isInherited());
     296           0 :     Record.push_back(A->isImplicit());
     297           0 :     Record.push_back(A->getSpellingListIndex());
     298             :     break;
     299             :   }
     300             :   case attr::CDecl: {
     301             :     const auto *SA = cast<CDeclAttr>(A);
     302           0 :     Record.push_back(SA->isInherited());
     303           0 :     Record.push_back(A->isImplicit());
     304           0 :     Record.push_back(A->getSpellingListIndex());
     305             :     break;
     306             :   }
     307             :   case attr::CFAuditedTransfer: {
     308             :     const auto *SA = cast<CFAuditedTransferAttr>(A);
     309           0 :     Record.push_back(SA->isInherited());
     310           0 :     Record.push_back(A->isImplicit());
     311           0 :     Record.push_back(A->getSpellingListIndex());
     312             :     break;
     313             :   }
     314             :   case attr::CFConsumed: {
     315             :     const auto *SA = cast<CFConsumedAttr>(A);
     316           9 :     Record.push_back(SA->isInherited());
     317           9 :     Record.push_back(A->isImplicit());
     318           9 :     Record.push_back(A->getSpellingListIndex());
     319             :     break;
     320             :   }
     321             :   case attr::CFReturnsNotRetained: {
     322             :     const auto *SA = cast<CFReturnsNotRetainedAttr>(A);
     323           0 :     Record.push_back(SA->isInherited());
     324           0 :     Record.push_back(A->isImplicit());
     325           0 :     Record.push_back(A->getSpellingListIndex());
     326             :     break;
     327             :   }
     328             :   case attr::CFReturnsRetained: {
     329             :     const auto *SA = cast<CFReturnsRetainedAttr>(A);
     330           3 :     Record.push_back(SA->isInherited());
     331           3 :     Record.push_back(A->isImplicit());
     332           3 :     Record.push_back(A->getSpellingListIndex());
     333             :     break;
     334             :   }
     335             :   case attr::CFUnknownTransfer: {
     336             :     const auto *SA = cast<CFUnknownTransferAttr>(A);
     337           0 :     Record.push_back(SA->isInherited());
     338           0 :     Record.push_back(A->isImplicit());
     339           0 :     Record.push_back(A->getSpellingListIndex());
     340             :     break;
     341             :   }
     342             :   case attr::CUDAConstant: {
     343             :     const auto *SA = cast<CUDAConstantAttr>(A);
     344           0 :     Record.push_back(SA->isInherited());
     345           0 :     Record.push_back(A->isImplicit());
     346           0 :     Record.push_back(A->getSpellingListIndex());
     347             :     break;
     348             :   }
     349             :   case attr::CUDADevice: {
     350             :     const auto *SA = cast<CUDADeviceAttr>(A);
     351           4 :     Record.push_back(SA->isInherited());
     352           4 :     Record.push_back(A->isImplicit());
     353           4 :     Record.push_back(A->getSpellingListIndex());
     354             :     break;
     355             :   }
     356             :   case attr::CUDAGlobal: {
     357             :     const auto *SA = cast<CUDAGlobalAttr>(A);
     358           1 :     Record.push_back(SA->isInherited());
     359           1 :     Record.push_back(A->isImplicit());
     360           1 :     Record.push_back(A->getSpellingListIndex());
     361             :     break;
     362             :   }
     363             :   case attr::CUDAHost: {
     364             :     const auto *SA = cast<CUDAHostAttr>(A);
     365           4 :     Record.push_back(SA->isInherited());
     366           4 :     Record.push_back(A->isImplicit());
     367           4 :     Record.push_back(A->getSpellingListIndex());
     368             :     break;
     369             :   }
     370             :   case attr::CUDAInvalidTarget: {
     371             :     const auto *SA = cast<CUDAInvalidTargetAttr>(A);
     372           0 :     Record.push_back(SA->isInherited());
     373           0 :     Record.push_back(A->isImplicit());
     374           0 :     Record.push_back(A->getSpellingListIndex());
     375             :     break;
     376             :   }
     377             :   case attr::CUDALaunchBounds: {
     378             :     const auto *SA = cast<CUDALaunchBoundsAttr>(A);
     379           0 :     Record.push_back(SA->isInherited());
     380           0 :     Record.push_back(A->isImplicit());
     381           0 :     Record.push_back(A->getSpellingListIndex());
     382           0 :     Record.AddStmt(SA->getMaxThreads());
     383           0 :     Record.AddStmt(SA->getMinBlocks());
     384             :     break;
     385             :   }
     386             :   case attr::CUDAShared: {
     387             :     const auto *SA = cast<CUDASharedAttr>(A);
     388           0 :     Record.push_back(SA->isInherited());
     389           0 :     Record.push_back(A->isImplicit());
     390           0 :     Record.push_back(A->getSpellingListIndex());
     391             :     break;
     392             :   }
     393             :   case attr::CXX11NoReturn: {
     394             :     const auto *SA = cast<CXX11NoReturnAttr>(A);
     395           0 :     Record.push_back(SA->isInherited());
     396           0 :     Record.push_back(A->isImplicit());
     397           0 :     Record.push_back(A->getSpellingListIndex());
     398             :     break;
     399             :   }
     400             :   case attr::CallableWhen: {
     401             :     const auto *SA = cast<CallableWhenAttr>(A);
     402           0 :     Record.push_back(SA->isInherited());
     403           0 :     Record.push_back(A->isImplicit());
     404           0 :     Record.push_back(A->getSpellingListIndex());
     405           0 :     Record.push_back(SA->callableStates_size());
     406           0 :     for (CallableWhenAttr::callableStates_iterator i = SA->callableStates_begin(), e = SA->callableStates_end(); i != e; ++i)
     407           0 :       Record.push_back((*i));
     408             :     break;
     409             :   }
     410             :   case attr::Capability: {
     411             :     const auto *SA = cast<CapabilityAttr>(A);
     412           2 :     Record.push_back(SA->isInherited());
     413           2 :     Record.push_back(A->isImplicit());
     414           2 :     Record.push_back(A->getSpellingListIndex());
     415           4 :     Record.AddString(SA->getName());
     416             :     break;
     417             :   }
     418             :   case attr::CapturedRecord: {
     419             :     const auto *SA = cast<CapturedRecordAttr>(A);
     420       19604 :     Record.push_back(SA->isInherited());
     421       19604 :     Record.push_back(A->isImplicit());
     422       19604 :     Record.push_back(A->getSpellingListIndex());
     423             :     break;
     424             :   }
     425             :   case attr::CarriesDependency: {
     426             :     const auto *SA = cast<CarriesDependencyAttr>(A);
     427           0 :     Record.push_back(SA->isInherited());
     428           0 :     Record.push_back(A->isImplicit());
     429           0 :     Record.push_back(A->getSpellingListIndex());
     430             :     break;
     431             :   }
     432             :   case attr::Cleanup: {
     433             :     const auto *SA = cast<CleanupAttr>(A);
     434           0 :     Record.push_back(SA->isInherited());
     435           0 :     Record.push_back(A->isImplicit());
     436           0 :     Record.push_back(A->getSpellingListIndex());
     437           0 :     Record.AddDeclRef(SA->getFunctionDecl());
     438             :     break;
     439             :   }
     440             :   case attr::CodeSeg: {
     441             :     const auto *SA = cast<CodeSegAttr>(A);
     442           0 :     Record.push_back(SA->isInherited());
     443           0 :     Record.push_back(A->isImplicit());
     444           0 :     Record.push_back(A->getSpellingListIndex());
     445           0 :     Record.AddString(SA->getName());
     446             :     break;
     447             :   }
     448             :   case attr::Cold: {
     449             :     const auto *SA = cast<ColdAttr>(A);
     450           8 :     Record.push_back(SA->isInherited());
     451           8 :     Record.push_back(A->isImplicit());
     452           8 :     Record.push_back(A->getSpellingListIndex());
     453             :     break;
     454             :   }
     455             :   case attr::Common: {
     456             :     const auto *SA = cast<CommonAttr>(A);
     457           0 :     Record.push_back(SA->isInherited());
     458           0 :     Record.push_back(A->isImplicit());
     459           0 :     Record.push_back(A->getSpellingListIndex());
     460             :     break;
     461             :   }
     462             :   case attr::Const: {
     463             :     const auto *SA = cast<ConstAttr>(A);
     464       43891 :     Record.push_back(SA->isInherited());
     465       43891 :     Record.push_back(A->isImplicit());
     466       43891 :     Record.push_back(A->getSpellingListIndex());
     467             :     break;
     468             :   }
     469             :   case attr::Constructor: {
     470             :     const auto *SA = cast<ConstructorAttr>(A);
     471           0 :     Record.push_back(SA->isInherited());
     472           0 :     Record.push_back(A->isImplicit());
     473           0 :     Record.push_back(A->getSpellingListIndex());
     474           0 :     Record.push_back(SA->getPriority());
     475             :     break;
     476             :   }
     477             :   case attr::Consumable: {
     478             :     const auto *SA = cast<ConsumableAttr>(A);
     479           0 :     Record.push_back(SA->isInherited());
     480           0 :     Record.push_back(A->isImplicit());
     481           0 :     Record.push_back(A->getSpellingListIndex());
     482           0 : Record.push_back(SA->getDefaultState());
     483             :     break;
     484             :   }
     485             :   case attr::ConsumableAutoCast: {
     486             :     const auto *SA = cast<ConsumableAutoCastAttr>(A);
     487           0 :     Record.push_back(SA->isInherited());
     488           0 :     Record.push_back(A->isImplicit());
     489           0 :     Record.push_back(A->getSpellingListIndex());
     490             :     break;
     491             :   }
     492             :   case attr::ConsumableSetOnRead: {
     493             :     const auto *SA = cast<ConsumableSetOnReadAttr>(A);
     494           0 :     Record.push_back(SA->isInherited());
     495           0 :     Record.push_back(A->isImplicit());
     496           0 :     Record.push_back(A->getSpellingListIndex());
     497             :     break;
     498             :   }
     499             :   case attr::Convergent: {
     500             :     const auto *SA = cast<ConvergentAttr>(A);
     501         849 :     Record.push_back(SA->isInherited());
     502         849 :     Record.push_back(A->isImplicit());
     503         849 :     Record.push_back(A->getSpellingListIndex());
     504             :     break;
     505             :   }
     506             :   case attr::DLLExport: {
     507             :     const auto *SA = cast<DLLExportAttr>(A);
     508           6 :     Record.push_back(SA->isInherited());
     509           6 :     Record.push_back(A->isImplicit());
     510           6 :     Record.push_back(A->getSpellingListIndex());
     511             :     break;
     512             :   }
     513             :   case attr::DLLImport: {
     514             :     const auto *SA = cast<DLLImportAttr>(A);
     515           0 :     Record.push_back(SA->isInherited());
     516           0 :     Record.push_back(A->isImplicit());
     517           0 :     Record.push_back(A->getSpellingListIndex());
     518             :     break;
     519             :   }
     520             :   case attr::Deprecated: {
     521             :     const auto *SA = cast<DeprecatedAttr>(A);
     522           1 :     Record.push_back(SA->isInherited());
     523           1 :     Record.push_back(A->isImplicit());
     524           1 :     Record.push_back(A->getSpellingListIndex());
     525           2 :     Record.AddString(SA->getMessage());
     526           2 :     Record.AddString(SA->getReplacement());
     527             :     break;
     528             :   }
     529             :   case attr::Destructor: {
     530             :     const auto *SA = cast<DestructorAttr>(A);
     531           0 :     Record.push_back(SA->isInherited());
     532           0 :     Record.push_back(A->isImplicit());
     533           0 :     Record.push_back(A->getSpellingListIndex());
     534           0 :     Record.push_back(SA->getPriority());
     535             :     break;
     536             :   }
     537             :   case attr::DiagnoseIf: {
     538             :     const auto *SA = cast<DiagnoseIfAttr>(A);
     539           0 :     Record.push_back(SA->isInherited());
     540           0 :     Record.push_back(A->isImplicit());
     541           0 :     Record.push_back(A->getSpellingListIndex());
     542           0 :     Record.AddStmt(SA->getCond());
     543           0 :     Record.AddString(SA->getMessage());
     544           0 : Record.push_back(SA->getDiagnosticType());
     545           0 :     Record.push_back(SA->getArgDependent());
     546           0 :     Record.AddDeclRef(SA->getParent());
     547             :     break;
     548             :   }
     549             :   case attr::DisableTailCalls: {
     550             :     const auto *SA = cast<DisableTailCallsAttr>(A);
     551           0 :     Record.push_back(SA->isInherited());
     552           0 :     Record.push_back(A->isImplicit());
     553           0 :     Record.push_back(A->getSpellingListIndex());
     554             :     break;
     555             :   }
     556             :   case attr::EmptyBases: {
     557             :     const auto *SA = cast<EmptyBasesAttr>(A);
     558           0 :     Record.push_back(SA->isInherited());
     559           0 :     Record.push_back(A->isImplicit());
     560           0 :     Record.push_back(A->getSpellingListIndex());
     561             :     break;
     562             :   }
     563             :   case attr::EnableIf: {
     564             :     const auto *SA = cast<EnableIfAttr>(A);
     565           6 :     Record.push_back(SA->isInherited());
     566           6 :     Record.push_back(A->isImplicit());
     567           6 :     Record.push_back(A->getSpellingListIndex());
     568           6 :     Record.AddStmt(SA->getCond());
     569          12 :     Record.AddString(SA->getMessage());
     570             :     break;
     571             :   }
     572             :   case attr::EnumExtensibility: {
     573             :     const auto *SA = cast<EnumExtensibilityAttr>(A);
     574           2 :     Record.push_back(SA->isInherited());
     575           2 :     Record.push_back(A->isImplicit());
     576           2 :     Record.push_back(A->getSpellingListIndex());
     577           2 : Record.push_back(SA->getExtensibility());
     578             :     break;
     579             :   }
     580             :   case attr::ExclusiveTrylockFunction: {
     581             :     const auto *SA = cast<ExclusiveTrylockFunctionAttr>(A);
     582           1 :     Record.push_back(SA->isInherited());
     583           1 :     Record.push_back(A->isImplicit());
     584           1 :     Record.push_back(A->getSpellingListIndex());
     585           1 :     Record.AddStmt(SA->getSuccessValue());
     586           1 :     Record.push_back(SA->args_size());
     587           1 :     for (auto &Val : SA->args())
     588           0 :       Record.AddStmt(Val);
     589             :     break;
     590             :   }
     591             :   case attr::ExternalSourceSymbol: {
     592             :     const auto *SA = cast<ExternalSourceSymbolAttr>(A);
     593           0 :     Record.push_back(SA->isInherited());
     594           0 :     Record.push_back(A->isImplicit());
     595           0 :     Record.push_back(A->getSpellingListIndex());
     596           0 :     Record.AddString(SA->getLanguage());
     597           0 :     Record.AddString(SA->getDefinedIn());
     598           0 :     Record.push_back(SA->getGeneratedDeclaration());
     599             :     break;
     600             :   }
     601             :   case attr::FallThrough: {
     602           4 :     Record.push_back(A->isImplicit());
     603           4 :     Record.push_back(A->getSpellingListIndex());
     604             :     break;
     605             :   }
     606             :   case attr::FastCall: {
     607             :     const auto *SA = cast<FastCallAttr>(A);
     608           0 :     Record.push_back(SA->isInherited());
     609           0 :     Record.push_back(A->isImplicit());
     610           0 :     Record.push_back(A->getSpellingListIndex());
     611             :     break;
     612             :   }
     613             :   case attr::Final: {
     614             :     const auto *SA = cast<FinalAttr>(A);
     615           0 :     Record.push_back(SA->isInherited());
     616           0 :     Record.push_back(A->isImplicit());
     617           0 :     Record.push_back(A->getSpellingListIndex());
     618             :     break;
     619             :   }
     620             :   case attr::FlagEnum: {
     621             :     const auto *SA = cast<FlagEnumAttr>(A);
     622           2 :     Record.push_back(SA->isInherited());
     623           2 :     Record.push_back(A->isImplicit());
     624           2 :     Record.push_back(A->getSpellingListIndex());
     625             :     break;
     626             :   }
     627             :   case attr::Flatten: {
     628             :     const auto *SA = cast<FlattenAttr>(A);
     629           0 :     Record.push_back(SA->isInherited());
     630           0 :     Record.push_back(A->isImplicit());
     631           0 :     Record.push_back(A->getSpellingListIndex());
     632             :     break;
     633             :   }
     634             :   case attr::Format: {
     635             :     const auto *SA = cast<FormatAttr>(A);
     636          46 :     Record.push_back(SA->isInherited());
     637          46 :     Record.push_back(A->isImplicit());
     638          46 :     Record.push_back(A->getSpellingListIndex());
     639          46 :     Record.AddIdentifierRef(SA->getType());
     640          46 :     Record.push_back(SA->getFormatIdx());
     641          46 :     Record.push_back(SA->getFirstArg());
     642             :     break;
     643             :   }
     644             :   case attr::FormatArg: {
     645             :     const auto *SA = cast<FormatArgAttr>(A);
     646           2 :     Record.push_back(SA->isInherited());
     647           2 :     Record.push_back(A->isImplicit());
     648           2 :     Record.push_back(A->getSpellingListIndex());
     649           2 :     Record.push_back(SA->getFormatIdx().serialize());
     650           2 :     break;
     651             :   }
     652             :   case attr::GNUInline: {
     653             :     const auto *SA = cast<GNUInlineAttr>(A);
     654           0 :     Record.push_back(SA->isInherited());
     655           0 :     Record.push_back(A->isImplicit());
     656           0 :     Record.push_back(A->getSpellingListIndex());
     657             :     break;
     658             :   }
     659             :   case attr::GuardedBy: {
     660             :     const auto *SA = cast<GuardedByAttr>(A);
     661           4 :     Record.push_back(SA->isInherited());
     662           4 :     Record.push_back(A->isImplicit());
     663           4 :     Record.push_back(A->getSpellingListIndex());
     664           4 :     Record.AddStmt(SA->getArg());
     665             :     break;
     666             :   }
     667             :   case attr::GuardedVar: {
     668             :     const auto *SA = cast<GuardedVarAttr>(A);
     669           1 :     Record.push_back(SA->isInherited());
     670           1 :     Record.push_back(A->isImplicit());
     671           1 :     Record.push_back(A->getSpellingListIndex());
     672             :     break;
     673             :   }
     674             :   case attr::Hot: {
     675             :     const auto *SA = cast<HotAttr>(A);
     676           0 :     Record.push_back(SA->isInherited());
     677           0 :     Record.push_back(A->isImplicit());
     678           0 :     Record.push_back(A->getSpellingListIndex());
     679             :     break;
     680             :   }
     681             :   case attr::IBAction: {
     682             :     const auto *SA = cast<IBActionAttr>(A);
     683           2 :     Record.push_back(SA->isInherited());
     684           2 :     Record.push_back(A->isImplicit());
     685           2 :     Record.push_back(A->getSpellingListIndex());
     686             :     break;
     687             :   }
     688             :   case attr::IBOutlet: {
     689             :     const auto *SA = cast<IBOutletAttr>(A);
     690           3 :     Record.push_back(SA->isInherited());
     691           3 :     Record.push_back(A->isImplicit());
     692           3 :     Record.push_back(A->getSpellingListIndex());
     693             :     break;
     694             :   }
     695             :   case attr::IBOutletCollection: {
     696             :     const auto *SA = cast<IBOutletCollectionAttr>(A);
     697           1 :     Record.push_back(SA->isInherited());
     698           1 :     Record.push_back(A->isImplicit());
     699           1 :     Record.push_back(A->getSpellingListIndex());
     700           1 :     Record.AddTypeSourceInfo(SA->getInterfaceLoc());
     701           1 :     break;
     702             :   }
     703             :   case attr::IFunc: {
     704             :     const auto *SA = cast<IFuncAttr>(A);
     705           0 :     Record.push_back(A->isImplicit());
     706           0 :     Record.push_back(A->getSpellingListIndex());
     707           0 :     Record.AddString(SA->getResolver());
     708             :     break;
     709             :   }
     710             :   case attr::InitPriority: {
     711             :     const auto *SA = cast<InitPriorityAttr>(A);
     712         216 :     Record.push_back(SA->isInherited());
     713         216 :     Record.push_back(A->isImplicit());
     714         216 :     Record.push_back(A->getSpellingListIndex());
     715         216 :     Record.push_back(SA->getPriority());
     716             :     break;
     717             :   }
     718             :   case attr::InitSeg: {
     719             :     const auto *SA = cast<InitSegAttr>(A);
     720           0 :     Record.push_back(A->isImplicit());
     721           0 :     Record.push_back(A->getSpellingListIndex());
     722           0 :     Record.AddString(SA->getSection());
     723             :     break;
     724             :   }
     725             :   case attr::IntelOclBicc: {
     726             :     const auto *SA = cast<IntelOclBiccAttr>(A);
     727           0 :     Record.push_back(SA->isInherited());
     728           0 :     Record.push_back(A->isImplicit());
     729           0 :     Record.push_back(A->getSpellingListIndex());
     730             :     break;
     731             :   }
     732             :   case attr::InternalLinkage: {
     733             :     const auto *SA = cast<InternalLinkageAttr>(A);
     734           0 :     Record.push_back(SA->isInherited());
     735           0 :     Record.push_back(A->isImplicit());
     736           0 :     Record.push_back(A->getSpellingListIndex());
     737             :     break;
     738             :   }
     739             :   case attr::LTOVisibilityPublic: {
     740             :     const auto *SA = cast<LTOVisibilityPublicAttr>(A);
     741           0 :     Record.push_back(SA->isInherited());
     742           0 :     Record.push_back(A->isImplicit());
     743           0 :     Record.push_back(A->getSpellingListIndex());
     744             :     break;
     745             :   }
     746             :   case attr::LayoutVersion: {
     747             :     const auto *SA = cast<LayoutVersionAttr>(A);
     748           0 :     Record.push_back(SA->isInherited());
     749           0 :     Record.push_back(A->isImplicit());
     750           0 :     Record.push_back(A->getSpellingListIndex());
     751           0 :     Record.push_back(SA->getVersion());
     752             :     break;
     753             :   }
     754             :   case attr::LockReturned: {
     755             :     const auto *SA = cast<LockReturnedAttr>(A);
     756           0 :     Record.push_back(SA->isInherited());
     757           0 :     Record.push_back(A->isImplicit());
     758           0 :     Record.push_back(A->getSpellingListIndex());
     759           0 :     Record.AddStmt(SA->getArg());
     760             :     break;
     761             :   }
     762             :   case attr::LocksExcluded: {
     763             :     const auto *SA = cast<LocksExcludedAttr>(A);
     764           0 :     Record.push_back(SA->isInherited());
     765           0 :     Record.push_back(A->isImplicit());
     766           0 :     Record.push_back(A->getSpellingListIndex());
     767           0 :     Record.push_back(SA->args_size());
     768           0 :     for (auto &Val : SA->args())
     769           0 :       Record.AddStmt(Val);
     770             :     break;
     771             :   }
     772             :   case attr::LoopHint: {
     773             :     const auto *SA = cast<LoopHintAttr>(A);
     774          16 :     Record.push_back(A->isImplicit());
     775          16 :     Record.push_back(A->getSpellingListIndex());
     776          16 : Record.push_back(SA->getOption());
     777          16 : Record.push_back(SA->getState());
     778          16 :     Record.AddStmt(SA->getValue());
     779             :     break;
     780             :   }
     781             :   case attr::MSABI: {
     782             :     const auto *SA = cast<MSABIAttr>(A);
     783           0 :     Record.push_back(SA->isInherited());
     784           0 :     Record.push_back(A->isImplicit());
     785           0 :     Record.push_back(A->getSpellingListIndex());
     786             :     break;
     787             :   }
     788             :   case attr::MSInheritance: {
     789             :     const auto *SA = cast<MSInheritanceAttr>(A);
     790           2 :     Record.push_back(SA->isInherited());
     791           2 :     Record.push_back(A->isImplicit());
     792           2 :     Record.push_back(A->getSpellingListIndex());
     793           2 :     Record.push_back(SA->getBestCase());
     794             :     break;
     795             :   }
     796             :   case attr::MSNoVTable: {
     797             :     const auto *SA = cast<MSNoVTableAttr>(A);
     798           0 :     Record.push_back(SA->isInherited());
     799           0 :     Record.push_back(A->isImplicit());
     800           0 :     Record.push_back(A->getSpellingListIndex());
     801             :     break;
     802             :   }
     803             :   case attr::MSP430Interrupt: {
     804             :     const auto *SA = cast<MSP430InterruptAttr>(A);
     805           0 :     Record.push_back(SA->isInherited());
     806           0 :     Record.push_back(A->isImplicit());
     807           0 :     Record.push_back(A->getSpellingListIndex());
     808           0 :     Record.push_back(SA->getNumber());
     809             :     break;
     810             :   }
     811             :   case attr::MSStruct: {
     812             :     const auto *SA = cast<MSStructAttr>(A);
     813           1 :     Record.push_back(SA->isInherited());
     814           1 :     Record.push_back(A->isImplicit());
     815           1 :     Record.push_back(A->getSpellingListIndex());
     816             :     break;
     817             :   }
     818             :   case attr::MSVtorDisp: {
     819             :     const auto *SA = cast<MSVtorDispAttr>(A);
     820           0 :     Record.push_back(SA->isInherited());
     821           0 :     Record.push_back(A->isImplicit());
     822           0 :     Record.push_back(A->getSpellingListIndex());
     823           0 :     Record.push_back(SA->getVdm());
     824             :     break;
     825             :   }
     826             :   case attr::MaxFieldAlignment: {
     827             :     const auto *SA = cast<MaxFieldAlignmentAttr>(A);
     828           0 :     Record.push_back(SA->isInherited());
     829           0 :     Record.push_back(A->isImplicit());
     830           0 :     Record.push_back(A->getSpellingListIndex());
     831           0 :     Record.push_back(SA->getAlignment());
     832             :     break;
     833             :   }
     834             :   case attr::MayAlias: {
     835             :     const auto *SA = cast<MayAliasAttr>(A);
     836         116 :     Record.push_back(SA->isInherited());
     837         116 :     Record.push_back(A->isImplicit());
     838         116 :     Record.push_back(A->getSpellingListIndex());
     839             :     break;
     840             :   }
     841             :   case attr::MicroMips: {
     842             :     const auto *SA = cast<MicroMipsAttr>(A);
     843           0 :     Record.push_back(SA->isInherited());
     844           0 :     Record.push_back(A->isImplicit());
     845           0 :     Record.push_back(A->getSpellingListIndex());
     846             :     break;
     847             :   }
     848             :   case attr::MinSize: {
     849             :     const auto *SA = cast<MinSizeAttr>(A);
     850           0 :     Record.push_back(SA->isInherited());
     851           0 :     Record.push_back(A->isImplicit());
     852           0 :     Record.push_back(A->getSpellingListIndex());
     853             :     break;
     854             :   }
     855             :   case attr::Mips16: {
     856             :     const auto *SA = cast<Mips16Attr>(A);
     857           0 :     Record.push_back(SA->isInherited());
     858           0 :     Record.push_back(A->isImplicit());
     859           0 :     Record.push_back(A->getSpellingListIndex());
     860             :     break;
     861             :   }
     862             :   case attr::MipsInterrupt: {
     863             :     const auto *SA = cast<MipsInterruptAttr>(A);
     864           0 :     Record.push_back(SA->isInherited());
     865           0 :     Record.push_back(A->isImplicit());
     866           0 :     Record.push_back(A->getSpellingListIndex());
     867           0 : Record.push_back(SA->getInterrupt());
     868             :     break;
     869             :   }
     870             :   case attr::MipsLongCall: {
     871             :     const auto *SA = cast<MipsLongCallAttr>(A);
     872           0 :     Record.push_back(SA->isInherited());
     873           0 :     Record.push_back(A->isImplicit());
     874           0 :     Record.push_back(A->getSpellingListIndex());
     875             :     break;
     876             :   }
     877             :   case attr::MipsShortCall: {
     878             :     const auto *SA = cast<MipsShortCallAttr>(A);
     879           0 :     Record.push_back(SA->isInherited());
     880           0 :     Record.push_back(A->isImplicit());
     881           0 :     Record.push_back(A->getSpellingListIndex());
     882             :     break;
     883             :   }
     884             :   case attr::Mode: {
     885             :     const auto *SA = cast<ModeAttr>(A);
     886           0 :     Record.push_back(A->isImplicit());
     887           0 :     Record.push_back(A->getSpellingListIndex());
     888           0 :     Record.AddIdentifierRef(SA->getMode());
     889             :     break;
     890             :   }
     891             :   case attr::NSConsumed: {
     892             :     const auto *SA = cast<NSConsumedAttr>(A);
     893           0 :     Record.push_back(SA->isInherited());
     894           0 :     Record.push_back(A->isImplicit());
     895           0 :     Record.push_back(A->getSpellingListIndex());
     896             :     break;
     897             :   }
     898             :   case attr::NSConsumesSelf: {
     899             :     const auto *SA = cast<NSConsumesSelfAttr>(A);
     900           0 :     Record.push_back(SA->isInherited());
     901           0 :     Record.push_back(A->isImplicit());
     902           0 :     Record.push_back(A->getSpellingListIndex());
     903             :     break;
     904             :   }
     905             :   case attr::NSReturnsAutoreleased: {
     906             :     const auto *SA = cast<NSReturnsAutoreleasedAttr>(A);
     907           0 :     Record.push_back(SA->isInherited());
     908           0 :     Record.push_back(A->isImplicit());
     909           0 :     Record.push_back(A->getSpellingListIndex());
     910             :     break;
     911             :   }
     912             :   case attr::NSReturnsNotRetained: {
     913             :     const auto *SA = cast<NSReturnsNotRetainedAttr>(A);
     914           3 :     Record.push_back(SA->isInherited());
     915           3 :     Record.push_back(A->isImplicit());
     916           3 :     Record.push_back(A->getSpellingListIndex());
     917             :     break;
     918             :   }
     919             :   case attr::NSReturnsRetained: {
     920             :     const auto *SA = cast<NSReturnsRetainedAttr>(A);
     921          14 :     Record.push_back(SA->isInherited());
     922          14 :     Record.push_back(A->isImplicit());
     923          14 :     Record.push_back(A->getSpellingListIndex());
     924             :     break;
     925             :   }
     926             :   case attr::Naked: {
     927             :     const auto *SA = cast<NakedAttr>(A);
     928           0 :     Record.push_back(SA->isInherited());
     929           0 :     Record.push_back(A->isImplicit());
     930           0 :     Record.push_back(A->getSpellingListIndex());
     931             :     break;
     932             :   }
     933             :   case attr::NoAlias: {
     934             :     const auto *SA = cast<NoAliasAttr>(A);
     935           0 :     Record.push_back(SA->isInherited());
     936           0 :     Record.push_back(A->isImplicit());
     937           0 :     Record.push_back(A->getSpellingListIndex());
     938             :     break;
     939             :   }
     940             :   case attr::NoCommon: {
     941             :     const auto *SA = cast<NoCommonAttr>(A);
     942           0 :     Record.push_back(SA->isInherited());
     943           0 :     Record.push_back(A->isImplicit());
     944           0 :     Record.push_back(A->getSpellingListIndex());
     945             :     break;
     946             :   }
     947             :   case attr::NoDebug: {
     948             :     const auto *SA = cast<NoDebugAttr>(A);
     949       19005 :     Record.push_back(SA->isInherited());
     950       19005 :     Record.push_back(A->isImplicit());
     951       19005 :     Record.push_back(A->getSpellingListIndex());
     952             :     break;
     953             :   }
     954             :   case attr::NoDuplicate: {
     955             :     const auto *SA = cast<NoDuplicateAttr>(A);
     956           0 :     Record.push_back(SA->isInherited());
     957           0 :     Record.push_back(A->isImplicit());
     958           0 :     Record.push_back(A->getSpellingListIndex());
     959             :     break;
     960             :   }
     961             :   case attr::NoEscape: {
     962           0 :     Record.push_back(A->isImplicit());
     963           0 :     Record.push_back(A->getSpellingListIndex());
     964             :     break;
     965             :   }
     966             :   case attr::NoInline: {
     967             :     const auto *SA = cast<NoInlineAttr>(A);
     968           0 :     Record.push_back(SA->isInherited());
     969           0 :     Record.push_back(A->isImplicit());
     970           0 :     Record.push_back(A->getSpellingListIndex());
     971             :     break;
     972             :   }
     973             :   case attr::NoInstrumentFunction: {
     974             :     const auto *SA = cast<NoInstrumentFunctionAttr>(A);
     975           0 :     Record.push_back(SA->isInherited());
     976           0 :     Record.push_back(A->isImplicit());
     977           0 :     Record.push_back(A->getSpellingListIndex());
     978             :     break;
     979             :   }
     980             :   case attr::NoMicroMips: {
     981             :     const auto *SA = cast<NoMicroMipsAttr>(A);
     982           0 :     Record.push_back(SA->isInherited());
     983           0 :     Record.push_back(A->isImplicit());
     984           0 :     Record.push_back(A->getSpellingListIndex());
     985             :     break;
     986             :   }
     987             :   case attr::NoMips16: {
     988             :     const auto *SA = cast<NoMips16Attr>(A);
     989           0 :     Record.push_back(SA->isInherited());
     990           0 :     Record.push_back(A->isImplicit());
     991           0 :     Record.push_back(A->getSpellingListIndex());
     992             :     break;
     993             :   }
     994             :   case attr::NoReturn: {
     995             :     const auto *SA = cast<NoReturnAttr>(A);
     996           0 :     Record.push_back(SA->isInherited());
     997           0 :     Record.push_back(A->isImplicit());
     998           0 :     Record.push_back(A->getSpellingListIndex());
     999             :     break;
    1000             :   }
    1001             :   case attr::NoSanitize: {
    1002             :     const auto *SA = cast<NoSanitizeAttr>(A);
    1003           1 :     Record.push_back(SA->isInherited());
    1004           1 :     Record.push_back(A->isImplicit());
    1005           1 :     Record.push_back(A->getSpellingListIndex());
    1006           1 :     Record.push_back(SA->sanitizers_size());
    1007           5 :     for (auto &Val : SA->sanitizers())
    1008           2 :       Record.AddString(Val);
    1009             :     break;
    1010             :   }
    1011             :   case attr::NoSplitStack: {
    1012             :     const auto *SA = cast<NoSplitStackAttr>(A);
    1013           0 :     Record.push_back(SA->isInherited());
    1014           0 :     Record.push_back(A->isImplicit());
    1015           0 :     Record.push_back(A->getSpellingListIndex());
    1016             :     break;
    1017             :   }
    1018             :   case attr::NoStackProtector: {
    1019             :     const auto *SA = cast<NoStackProtectorAttr>(A);
    1020           0 :     Record.push_back(SA->isInherited());
    1021           0 :     Record.push_back(A->isImplicit());
    1022           0 :     Record.push_back(A->getSpellingListIndex());
    1023             :     break;
    1024             :   }
    1025             :   case attr::NoThreadSafetyAnalysis: {
    1026             :     const auto *SA = cast<NoThreadSafetyAnalysisAttr>(A);
    1027           0 :     Record.push_back(SA->isInherited());
    1028           0 :     Record.push_back(A->isImplicit());
    1029           0 :     Record.push_back(A->getSpellingListIndex());
    1030             :     break;
    1031             :   }
    1032             :   case attr::NoThrow: {
    1033             :     const auto *SA = cast<NoThrowAttr>(A);
    1034        6309 :     Record.push_back(SA->isInherited());
    1035        6309 :     Record.push_back(A->isImplicit());
    1036        6309 :     Record.push_back(A->getSpellingListIndex());
    1037             :     break;
    1038             :   }
    1039             :   case attr::NonNull: {
    1040             :     const auto *SA = cast<NonNullAttr>(A);
    1041           2 :     Record.push_back(SA->isInherited());
    1042           2 :     Record.push_back(A->isImplicit());
    1043           2 :     Record.push_back(A->getSpellingListIndex());
    1044           2 :     Record.push_back(SA->args_size());
    1045          10 :     for (auto &Val : SA->args())
    1046           4 :       Record.push_back(Val.serialize());
    1047             :     break;
    1048             :   }
    1049             :   case attr::NotTailCalled: {
    1050             :     const auto *SA = cast<NotTailCalledAttr>(A);
    1051           1 :     Record.push_back(SA->isInherited());
    1052           1 :     Record.push_back(A->isImplicit());
    1053           1 :     Record.push_back(A->getSpellingListIndex());
    1054             :     break;
    1055             :   }
    1056             :   case attr::OMPCaptureKind: {
    1057             :     const auto *SA = cast<OMPCaptureKindAttr>(A);
    1058       17220 :     Record.push_back(A->isImplicit());
    1059       17220 :     Record.push_back(A->getSpellingListIndex());
    1060       17220 :     Record.push_back(SA->getCaptureKind());
    1061             :     break;
    1062             :   }
    1063             :   case attr::OMPCaptureNoInit: {
    1064             :     const auto *SA = cast<OMPCaptureNoInitAttr>(A);
    1065          18 :     Record.push_back(SA->isInherited());
    1066          18 :     Record.push_back(A->isImplicit());
    1067          18 :     Record.push_back(A->getSpellingListIndex());
    1068             :     break;
    1069             :   }
    1070             :   case attr::OMPDeclareSimdDecl: {
    1071             :     const auto *SA = cast<OMPDeclareSimdDeclAttr>(A);
    1072         124 :     Record.push_back(A->isImplicit());
    1073         124 :     Record.push_back(A->getSpellingListIndex());
    1074         124 : Record.push_back(SA->getBranchState());
    1075         124 :     Record.AddStmt(SA->getSimdlen());
    1076         124 :     Record.push_back(SA->uniforms_size());
    1077         196 :     for (auto &Val : SA->uniforms())
    1078          36 :       Record.AddStmt(Val);
    1079         124 :     Record.push_back(SA->aligneds_size());
    1080         288 :     for (auto &Val : SA->aligneds())
    1081          82 :       Record.AddStmt(Val);
    1082         124 :     Record.push_back(SA->alignments_size());
    1083         288 :     for (auto &Val : SA->alignments())
    1084          82 :       Record.AddStmt(Val);
    1085         124 :     Record.push_back(SA->linears_size());
    1086         232 :     for (auto &Val : SA->linears())
    1087          54 :       Record.AddStmt(Val);
    1088         124 :     Record.push_back(SA->modifiers_size());
    1089         232 :     for (auto &Val : SA->modifiers())
    1090          54 :       Record.push_back(Val);
    1091         124 :     Record.push_back(SA->steps_size());
    1092         232 :     for (auto &Val : SA->steps())
    1093          54 :       Record.AddStmt(Val);
    1094             :     break;
    1095             :   }
    1096             :   case attr::OMPDeclareTargetDecl: {
    1097             :     const auto *SA = cast<OMPDeclareTargetDeclAttr>(A);
    1098          76 :     Record.push_back(A->isImplicit());
    1099          76 :     Record.push_back(A->getSpellingListIndex());
    1100          76 : Record.push_back(SA->getMapType());
    1101             :     break;
    1102             :   }
    1103             :   case attr::OMPReferencedVar: {
    1104             :     const auto *SA = cast<OMPReferencedVarAttr>(A);
    1105        8094 :     Record.push_back(A->isImplicit());
    1106        8094 :     Record.push_back(A->getSpellingListIndex());
    1107        8094 :     Record.AddStmt(SA->getRef());
    1108             :     break;
    1109             :   }
    1110             :   case attr::OMPThreadPrivateDecl: {
    1111             :     const auto *SA = cast<OMPThreadPrivateDeclAttr>(A);
    1112         162 :     Record.push_back(SA->isInherited());
    1113         162 :     Record.push_back(A->isImplicit());
    1114         162 :     Record.push_back(A->getSpellingListIndex());
    1115             :     break;
    1116             :   }
    1117             :   case attr::ObjCBoxable: {
    1118           2 :     Record.push_back(A->isImplicit());
    1119           2 :     Record.push_back(A->getSpellingListIndex());
    1120             :     break;
    1121             :   }
    1122             :   case attr::ObjCBridge: {
    1123             :     const auto *SA = cast<ObjCBridgeAttr>(A);
    1124           0 :     Record.push_back(SA->isInherited());
    1125           0 :     Record.push_back(A->isImplicit());
    1126           0 :     Record.push_back(A->getSpellingListIndex());
    1127           0 :     Record.AddIdentifierRef(SA->getBridgedType());
    1128             :     break;
    1129             :   }
    1130             :   case attr::ObjCBridgeMutable: {
    1131             :     const auto *SA = cast<ObjCBridgeMutableAttr>(A);
    1132           0 :     Record.push_back(SA->isInherited());
    1133           0 :     Record.push_back(A->isImplicit());
    1134           0 :     Record.push_back(A->getSpellingListIndex());
    1135           0 :     Record.AddIdentifierRef(SA->getBridgedType());
    1136             :     break;
    1137             :   }
    1138             :   case attr::ObjCBridgeRelated: {
    1139             :     const auto *SA = cast<ObjCBridgeRelatedAttr>(A);
    1140           0 :     Record.push_back(SA->isInherited());
    1141           0 :     Record.push_back(A->isImplicit());
    1142           0 :     Record.push_back(A->getSpellingListIndex());
    1143           0 :     Record.AddIdentifierRef(SA->getRelatedClass());
    1144           0 :     Record.AddIdentifierRef(SA->getClassMethod());
    1145           0 :     Record.AddIdentifierRef(SA->getInstanceMethod());
    1146             :     break;
    1147             :   }
    1148             :   case attr::ObjCDesignatedInitializer: {
    1149           1 :     Record.push_back(A->isImplicit());
    1150           1 :     Record.push_back(A->getSpellingListIndex());
    1151             :     break;
    1152             :   }
    1153             :   case attr::ObjCException: {
    1154             :     const auto *SA = cast<ObjCExceptionAttr>(A);
    1155           0 :     Record.push_back(SA->isInherited());
    1156           0 :     Record.push_back(A->isImplicit());
    1157           0 :     Record.push_back(A->getSpellingListIndex());
    1158             :     break;
    1159             :   }
    1160             :   case attr::ObjCExplicitProtocolImpl: {
    1161             :     const auto *SA = cast<ObjCExplicitProtocolImplAttr>(A);
    1162           0 :     Record.push_back(SA->isInherited());
    1163           0 :     Record.push_back(A->isImplicit());
    1164           0 :     Record.push_back(A->getSpellingListIndex());
    1165             :     break;
    1166             :   }
    1167             :   case attr::ObjCIndependentClass: {
    1168             :     const auto *SA = cast<ObjCIndependentClassAttr>(A);
    1169           0 :     Record.push_back(SA->isInherited());
    1170           0 :     Record.push_back(A->isImplicit());
    1171           0 :     Record.push_back(A->getSpellingListIndex());
    1172             :     break;
    1173             :   }
    1174             :   case attr::ObjCMethodFamily: {
    1175             :     const auto *SA = cast<ObjCMethodFamilyAttr>(A);
    1176           0 :     Record.push_back(SA->isInherited());
    1177           0 :     Record.push_back(A->isImplicit());
    1178           0 :     Record.push_back(A->getSpellingListIndex());
    1179           0 : Record.push_back(SA->getFamily());
    1180             :     break;
    1181             :   }
    1182             :   case attr::ObjCNSObject: {
    1183             :     const auto *SA = cast<ObjCNSObjectAttr>(A);
    1184           0 :     Record.push_back(SA->isInherited());
    1185           0 :     Record.push_back(A->isImplicit());
    1186           0 :     Record.push_back(A->getSpellingListIndex());
    1187             :     break;
    1188             :   }
    1189             :   case attr::ObjCPreciseLifetime: {
    1190             :     const auto *SA = cast<ObjCPreciseLifetimeAttr>(A);
    1191           0 :     Record.push_back(SA->isInherited());
    1192           0 :     Record.push_back(A->isImplicit());
    1193           0 :     Record.push_back(A->getSpellingListIndex());
    1194             :     break;
    1195             :   }
    1196             :   case attr::ObjCRequiresPropertyDefs: {
    1197             :     const auto *SA = cast<ObjCRequiresPropertyDefsAttr>(A);
    1198           0 :     Record.push_back(SA->isInherited());
    1199           0 :     Record.push_back(A->isImplicit());
    1200           0 :     Record.push_back(A->getSpellingListIndex());
    1201             :     break;
    1202             :   }
    1203             :   case attr::ObjCRequiresSuper: {
    1204             :     const auto *SA = cast<ObjCRequiresSuperAttr>(A);
    1205           0 :     Record.push_back(SA->isInherited());
    1206           0 :     Record.push_back(A->isImplicit());
    1207           0 :     Record.push_back(A->getSpellingListIndex());
    1208             :     break;
    1209             :   }
    1210             :   case attr::ObjCReturnsInnerPointer: {
    1211             :     const auto *SA = cast<ObjCReturnsInnerPointerAttr>(A);
    1212           0 :     Record.push_back(SA->isInherited());
    1213           0 :     Record.push_back(A->isImplicit());
    1214           0 :     Record.push_back(A->getSpellingListIndex());
    1215             :     break;
    1216             :   }
    1217             :   case attr::ObjCRootClass: {
    1218             :     const auto *SA = cast<ObjCRootClassAttr>(A);
    1219           2 :     Record.push_back(SA->isInherited());
    1220           2 :     Record.push_back(A->isImplicit());
    1221           2 :     Record.push_back(A->getSpellingListIndex());
    1222             :     break;
    1223             :   }
    1224             :   case attr::ObjCRuntimeName: {
    1225             :     const auto *SA = cast<ObjCRuntimeNameAttr>(A);
    1226           0 :     Record.push_back(A->isImplicit());
    1227           0 :     Record.push_back(A->getSpellingListIndex());
    1228           0 :     Record.AddString(SA->getMetadataName());
    1229             :     break;
    1230             :   }
    1231             :   case attr::ObjCRuntimeVisible: {
    1232           0 :     Record.push_back(A->isImplicit());
    1233           0 :     Record.push_back(A->getSpellingListIndex());
    1234             :     break;
    1235             :   }
    1236             :   case attr::ObjCSubclassingRestricted: {
    1237             :     const auto *SA = cast<ObjCSubclassingRestrictedAttr>(A);
    1238           0 :     Record.push_back(SA->isInherited());
    1239           0 :     Record.push_back(A->isImplicit());
    1240           0 :     Record.push_back(A->getSpellingListIndex());
    1241             :     break;
    1242             :   }
    1243             :   case attr::OpenCLAccess: {
    1244        1383 :     Record.push_back(A->isImplicit());
    1245        1383 :     Record.push_back(A->getSpellingListIndex());
    1246             :     break;
    1247             :   }
    1248             :   case attr::OpenCLIntelReqdSubGroupSize: {
    1249             :     const auto *SA = cast<OpenCLIntelReqdSubGroupSizeAttr>(A);
    1250           0 :     Record.push_back(SA->isInherited());
    1251           0 :     Record.push_back(A->isImplicit());
    1252           0 :     Record.push_back(A->getSpellingListIndex());
    1253           0 :     Record.push_back(SA->getSubGroupSize());
    1254             :     break;
    1255             :   }
    1256             :   case attr::OpenCLKernel: {
    1257             :     const auto *SA = cast<OpenCLKernelAttr>(A);
    1258           0 :     Record.push_back(SA->isInherited());
    1259           0 :     Record.push_back(A->isImplicit());
    1260           0 :     Record.push_back(A->getSpellingListIndex());
    1261             :     break;
    1262             :   }
    1263             :   case attr::OpenCLUnrollHint: {
    1264             :     const auto *SA = cast<OpenCLUnrollHintAttr>(A);
    1265           0 :     Record.push_back(SA->isInherited());
    1266           0 :     Record.push_back(A->isImplicit());
    1267           0 :     Record.push_back(A->getSpellingListIndex());
    1268           0 :     Record.push_back(SA->getUnrollHint());
    1269             :     break;
    1270             :   }
    1271             :   case attr::OptimizeNone: {
    1272             :     const auto *SA = cast<OptimizeNoneAttr>(A);
    1273           0 :     Record.push_back(SA->isInherited());
    1274           0 :     Record.push_back(A->isImplicit());
    1275           0 :     Record.push_back(A->getSpellingListIndex());
    1276             :     break;
    1277             :   }
    1278             :   case attr::Overloadable: {
    1279       47164 :     Record.push_back(A->isImplicit());
    1280       47164 :     Record.push_back(A->getSpellingListIndex());
    1281             :     break;
    1282             :   }
    1283             :   case attr::Override: {
    1284             :     const auto *SA = cast<OverrideAttr>(A);
    1285           2 :     Record.push_back(SA->isInherited());
    1286           2 :     Record.push_back(A->isImplicit());
    1287           2 :     Record.push_back(A->getSpellingListIndex());
    1288             :     break;
    1289             :   }
    1290             :   case attr::Ownership: {
    1291             :     const auto *SA = cast<OwnershipAttr>(A);
    1292           6 :     Record.push_back(SA->isInherited());
    1293           6 :     Record.push_back(A->isImplicit());
    1294           6 :     Record.push_back(A->getSpellingListIndex());
    1295           6 :     Record.AddIdentifierRef(SA->getModule());
    1296           6 :     Record.push_back(SA->args_size());
    1297          26 :     for (auto &Val : SA->args())
    1298          10 :       Record.push_back(Val.serialize());
    1299             :     break;
    1300             :   }
    1301             :   case attr::Packed: {
    1302             :     const auto *SA = cast<PackedAttr>(A);
    1303         153 :     Record.push_back(SA->isInherited());
    1304         153 :     Record.push_back(A->isImplicit());
    1305         153 :     Record.push_back(A->getSpellingListIndex());
    1306             :     break;
    1307             :   }
    1308             :   case attr::ParamTypestate: {
    1309             :     const auto *SA = cast<ParamTypestateAttr>(A);
    1310           0 :     Record.push_back(SA->isInherited());
    1311           0 :     Record.push_back(A->isImplicit());
    1312           0 :     Record.push_back(A->getSpellingListIndex());
    1313           0 : Record.push_back(SA->getParamState());
    1314             :     break;
    1315             :   }
    1316             :   case attr::Pascal: {
    1317             :     const auto *SA = cast<PascalAttr>(A);
    1318           0 :     Record.push_back(SA->isInherited());
    1319           0 :     Record.push_back(A->isImplicit());
    1320           0 :     Record.push_back(A->getSpellingListIndex());
    1321             :     break;
    1322             :   }
    1323             :   case attr::PassObjectSize: {
    1324             :     const auto *SA = cast<PassObjectSizeAttr>(A);
    1325           2 :     Record.push_back(SA->isInherited());
    1326           2 :     Record.push_back(A->isImplicit());
    1327           2 :     Record.push_back(A->getSpellingListIndex());
    1328           2 :     Record.push_back(SA->getType());
    1329             :     break;
    1330             :   }
    1331             :   case attr::Pcs: {
    1332             :     const auto *SA = cast<PcsAttr>(A);
    1333           0 :     Record.push_back(SA->isInherited());
    1334           0 :     Record.push_back(A->isImplicit());
    1335           0 :     Record.push_back(A->getSpellingListIndex());
    1336           0 : Record.push_back(SA->getPCS());
    1337             :     break;
    1338             :   }
    1339             :   case attr::PragmaClangBSSSection: {
    1340             :     const auto *SA = cast<PragmaClangBSSSectionAttr>(A);
    1341           0 :     Record.push_back(SA->isInherited());
    1342           0 :     Record.push_back(A->isImplicit());
    1343           0 :     Record.push_back(A->getSpellingListIndex());
    1344           0 :     Record.AddString(SA->getName());
    1345             :     break;
    1346             :   }
    1347             :   case attr::PragmaClangDataSection: {
    1348             :     const auto *SA = cast<PragmaClangDataSectionAttr>(A);
    1349           0 :     Record.push_back(SA->isInherited());
    1350           0 :     Record.push_back(A->isImplicit());
    1351           0 :     Record.push_back(A->getSpellingListIndex());
    1352           0 :     Record.AddString(SA->getName());
    1353             :     break;
    1354             :   }
    1355             :   case attr::PragmaClangRodataSection: {
    1356             :     const auto *SA = cast<PragmaClangRodataSectionAttr>(A);
    1357           0 :     Record.push_back(SA->isInherited());
    1358           0 :     Record.push_back(A->isImplicit());
    1359           0 :     Record.push_back(A->getSpellingListIndex());
    1360           0 :     Record.AddString(SA->getName());
    1361             :     break;
    1362             :   }
    1363             :   case attr::PragmaClangTextSection: {
    1364             :     const auto *SA = cast<PragmaClangTextSectionAttr>(A);
    1365           0 :     Record.push_back(SA->isInherited());
    1366           0 :     Record.push_back(A->isImplicit());
    1367           0 :     Record.push_back(A->getSpellingListIndex());
    1368           0 :     Record.AddString(SA->getName());
    1369             :     break;
    1370             :   }
    1371             :   case attr::PreserveAll: {
    1372             :     const auto *SA = cast<PreserveAllAttr>(A);
    1373           0 :     Record.push_back(SA->isInherited());
    1374           0 :     Record.push_back(A->isImplicit());
    1375           0 :     Record.push_back(A->getSpellingListIndex());
    1376             :     break;
    1377             :   }
    1378             :   case attr::PreserveMost: {
    1379             :     const auto *SA = cast<PreserveMostAttr>(A);
    1380           0 :     Record.push_back(SA->isInherited());
    1381           0 :     Record.push_back(A->isImplicit());
    1382           0 :     Record.push_back(A->getSpellingListIndex());
    1383             :     break;
    1384             :   }
    1385             :   case attr::PtGuardedBy: {
    1386             :     const auto *SA = cast<PtGuardedByAttr>(A);
    1387           0 :     Record.push_back(SA->isInherited());
    1388           0 :     Record.push_back(A->isImplicit());
    1389           0 :     Record.push_back(A->getSpellingListIndex());
    1390           0 :     Record.AddStmt(SA->getArg());
    1391             :     break;
    1392             :   }
    1393             :   case attr::PtGuardedVar: {
    1394             :     const auto *SA = cast<PtGuardedVarAttr>(A);
    1395           0 :     Record.push_back(SA->isInherited());
    1396           0 :     Record.push_back(A->isImplicit());
    1397           0 :     Record.push_back(A->getSpellingListIndex());
    1398             :     break;
    1399             :   }
    1400             :   case attr::Pure: {
    1401             :     const auto *SA = cast<PureAttr>(A);
    1402         554 :     Record.push_back(SA->isInherited());
    1403         554 :     Record.push_back(A->isImplicit());
    1404         554 :     Record.push_back(A->getSpellingListIndex());
    1405             :     break;
    1406             :   }
    1407             :   case attr::RegCall: {
    1408             :     const auto *SA = cast<RegCallAttr>(A);
    1409           0 :     Record.push_back(SA->isInherited());
    1410           0 :     Record.push_back(A->isImplicit());
    1411           0 :     Record.push_back(A->getSpellingListIndex());
    1412             :     break;
    1413             :   }
    1414             :   case attr::ReleaseCapability: {
    1415             :     const auto *SA = cast<ReleaseCapabilityAttr>(A);
    1416           9 :     Record.push_back(SA->isInherited());
    1417           9 :     Record.push_back(A->isImplicit());
    1418           9 :     Record.push_back(A->getSpellingListIndex());
    1419           9 :     Record.push_back(SA->args_size());
    1420          15 :     for (auto &Val : SA->args())
    1421           3 :       Record.AddStmt(Val);
    1422             :     break;
    1423             :   }
    1424             :   case attr::RenderScriptKernel: {
    1425           0 :     Record.push_back(A->isImplicit());
    1426           0 :     Record.push_back(A->getSpellingListIndex());
    1427             :     break;
    1428             :   }
    1429             :   case attr::ReqdWorkGroupSize: {
    1430             :     const auto *SA = cast<ReqdWorkGroupSizeAttr>(A);
    1431           0 :     Record.push_back(SA->isInherited());
    1432           0 :     Record.push_back(A->isImplicit());
    1433           0 :     Record.push_back(A->getSpellingListIndex());
    1434           0 :     Record.push_back(SA->getXDim());
    1435           0 :     Record.push_back(SA->getYDim());
    1436           0 :     Record.push_back(SA->getZDim());
    1437             :     break;
    1438             :   }
    1439             :   case attr::RequireConstantInit: {
    1440             :     const auto *SA = cast<RequireConstantInitAttr>(A);
    1441           0 :     Record.push_back(SA->isInherited());
    1442           0 :     Record.push_back(A->isImplicit());
    1443           0 :     Record.push_back(A->getSpellingListIndex());
    1444             :     break;
    1445             :   }
    1446             :   case attr::RequiresCapability: {
    1447             :     const auto *SA = cast<RequiresCapabilityAttr>(A);
    1448           0 :     Record.push_back(SA->isInherited());
    1449           0 :     Record.push_back(A->isImplicit());
    1450           0 :     Record.push_back(A->getSpellingListIndex());
    1451           0 :     Record.push_back(SA->args_size());
    1452           0 :     for (auto &Val : SA->args())
    1453           0 :       Record.AddStmt(Val);
    1454             :     break;
    1455             :   }
    1456             :   case attr::Restrict: {
    1457             :     const auto *SA = cast<RestrictAttr>(A);
    1458           2 :     Record.push_back(SA->isInherited());
    1459           2 :     Record.push_back(A->isImplicit());
    1460           2 :     Record.push_back(A->getSpellingListIndex());
    1461             :     break;
    1462             :   }
    1463             :   case attr::ReturnTypestate: {
    1464             :     const auto *SA = cast<ReturnTypestateAttr>(A);
    1465           0 :     Record.push_back(SA->isInherited());
    1466           0 :     Record.push_back(A->isImplicit());
    1467           0 :     Record.push_back(A->getSpellingListIndex());
    1468           0 : Record.push_back(SA->getState());
    1469             :     break;
    1470             :   }
    1471             :   case attr::ReturnsNonNull: {
    1472             :     const auto *SA = cast<ReturnsNonNullAttr>(A);
    1473           0 :     Record.push_back(SA->isInherited());
    1474           0 :     Record.push_back(A->isImplicit());
    1475           0 :     Record.push_back(A->getSpellingListIndex());
    1476             :     break;
    1477             :   }
    1478             :   case attr::ReturnsTwice: {
    1479             :     const auto *SA = cast<ReturnsTwiceAttr>(A);
    1480           0 :     Record.push_back(SA->isInherited());
    1481           0 :     Record.push_back(A->isImplicit());
    1482           0 :     Record.push_back(A->getSpellingListIndex());
    1483             :     break;
    1484             :   }
    1485             :   case attr::ScopedLockable: {
    1486             :     const auto *SA = cast<ScopedLockableAttr>(A);
    1487           3 :     Record.push_back(SA->isInherited());
    1488           3 :     Record.push_back(A->isImplicit());
    1489           3 :     Record.push_back(A->getSpellingListIndex());
    1490             :     break;
    1491             :   }
    1492             :   case attr::Section: {
    1493             :     const auto *SA = cast<SectionAttr>(A);
    1494           0 :     Record.push_back(SA->isInherited());
    1495           0 :     Record.push_back(A->isImplicit());
    1496           0 :     Record.push_back(A->getSpellingListIndex());
    1497           0 :     Record.AddString(SA->getName());
    1498             :     break;
    1499             :   }
    1500             :   case attr::SelectAny: {
    1501             :     const auto *SA = cast<SelectAnyAttr>(A);
    1502           0 :     Record.push_back(SA->isInherited());
    1503           0 :     Record.push_back(A->isImplicit());
    1504           0 :     Record.push_back(A->getSpellingListIndex());
    1505             :     break;
    1506             :   }
    1507             :   case attr::Sentinel: {
    1508             :     const auto *SA = cast<SentinelAttr>(A);
    1509           0 :     Record.push_back(SA->isInherited());
    1510           0 :     Record.push_back(A->isImplicit());
    1511           0 :     Record.push_back(A->getSpellingListIndex());
    1512           0 :     Record.push_back(SA->getSentinel());
    1513           0 :     Record.push_back(SA->getNullPos());
    1514             :     break;
    1515             :   }
    1516             :   case attr::SetTypestate: {
    1517             :     const auto *SA = cast<SetTypestateAttr>(A);
    1518           0 :     Record.push_back(SA->isInherited());
    1519           0 :     Record.push_back(A->isImplicit());
    1520           0 :     Record.push_back(A->getSpellingListIndex());
    1521           0 : Record.push_back(SA->getNewState());
    1522             :     break;
    1523             :   }
    1524             :   case attr::SharedTrylockFunction: {
    1525             :     const auto *SA = cast<SharedTrylockFunctionAttr>(A);
    1526           1 :     Record.push_back(SA->isInherited());
    1527           1 :     Record.push_back(A->isImplicit());
    1528           1 :     Record.push_back(A->getSpellingListIndex());
    1529           1 :     Record.AddStmt(SA->getSuccessValue());
    1530           1 :     Record.push_back(SA->args_size());
    1531           1 :     for (auto &Val : SA->args())
    1532           0 :       Record.AddStmt(Val);
    1533             :     break;
    1534             :   }
    1535             :   case attr::StdCall: {
    1536             :     const auto *SA = cast<StdCallAttr>(A);
    1537           0 :     Record.push_back(SA->isInherited());
    1538           0 :     Record.push_back(A->isImplicit());
    1539           0 :     Record.push_back(A->getSpellingListIndex());
    1540             :     break;
    1541             :   }
    1542             :   case attr::Suppress: {
    1543             :     const auto *SA = cast<SuppressAttr>(A);
    1544           0 :     Record.push_back(A->isImplicit());
    1545           0 :     Record.push_back(A->getSpellingListIndex());
    1546           0 :     Record.push_back(SA->diagnosticIdentifiers_size());
    1547           0 :     for (auto &Val : SA->diagnosticIdentifiers())
    1548           0 :       Record.AddString(Val);
    1549             :     break;
    1550             :   }
    1551             :   case attr::SwiftCall: {
    1552             :     const auto *SA = cast<SwiftCallAttr>(A);
    1553           0 :     Record.push_back(SA->isInherited());
    1554           0 :     Record.push_back(A->isImplicit());
    1555           0 :     Record.push_back(A->getSpellingListIndex());
    1556             :     break;
    1557             :   }
    1558             :   case attr::SwiftContext: {
    1559             :     const auto *SA = cast<SwiftContextAttr>(A);
    1560           0 :     Record.push_back(SA->isInherited());
    1561           0 :     Record.push_back(A->isImplicit());
    1562           0 :     Record.push_back(A->getSpellingListIndex());
    1563             :     break;
    1564             :   }
    1565             :   case attr::SwiftErrorResult: {
    1566             :     const auto *SA = cast<SwiftErrorResultAttr>(A);
    1567           0 :     Record.push_back(SA->isInherited());
    1568           0 :     Record.push_back(A->isImplicit());
    1569           0 :     Record.push_back(A->getSpellingListIndex());
    1570             :     break;
    1571             :   }
    1572             :   case attr::SwiftIndirectResult: {
    1573             :     const auto *SA = cast<SwiftIndirectResultAttr>(A);
    1574           0 :     Record.push_back(SA->isInherited());
    1575           0 :     Record.push_back(A->isImplicit());
    1576           0 :     Record.push_back(A->getSpellingListIndex());
    1577             :     break;
    1578             :   }
    1579             :   case attr::SysVABI: {
    1580             :     const auto *SA = cast<SysVABIAttr>(A);
    1581           0 :     Record.push_back(SA->isInherited());
    1582           0 :     Record.push_back(A->isImplicit());
    1583           0 :     Record.push_back(A->getSpellingListIndex());
    1584             :     break;
    1585             :   }
    1586             :   case attr::TLSModel: {
    1587             :     const auto *SA = cast<TLSModelAttr>(A);
    1588           0 :     Record.push_back(SA->isInherited());
    1589           0 :     Record.push_back(A->isImplicit());
    1590           0 :     Record.push_back(A->getSpellingListIndex());
    1591           0 :     Record.AddString(SA->getModel());
    1592             :     break;
    1593             :   }
    1594             :   case attr::Target: {
    1595             :     const auto *SA = cast<TargetAttr>(A);
    1596       15337 :     Record.push_back(SA->isInherited());
    1597       15337 :     Record.push_back(A->isImplicit());
    1598       15337 :     Record.push_back(A->getSpellingListIndex());
    1599       30674 :     Record.AddString(SA->getFeaturesStr());
    1600             :     break;
    1601             :   }
    1602             :   case attr::TestTypestate: {
    1603             :     const auto *SA = cast<TestTypestateAttr>(A);
    1604           0 :     Record.push_back(SA->isInherited());
    1605           0 :     Record.push_back(A->isImplicit());
    1606           0 :     Record.push_back(A->getSpellingListIndex());
    1607           0 : Record.push_back(SA->getTestState());
    1608             :     break;
    1609             :   }
    1610             :   case attr::ThisCall: {
    1611             :     const auto *SA = cast<ThisCallAttr>(A);
    1612           0 :     Record.push_back(SA->isInherited());
    1613           0 :     Record.push_back(A->isImplicit());
    1614           0 :     Record.push_back(A->getSpellingListIndex());
    1615             :     break;
    1616             :   }
    1617             :   case attr::Thread: {
    1618           0 :     Record.push_back(A->isImplicit());
    1619           0 :     Record.push_back(A->getSpellingListIndex());
    1620             :     break;
    1621             :   }
    1622             :   case attr::TransparentUnion: {
    1623             :     const auto *SA = cast<TransparentUnionAttr>(A);
    1624           0 :     Record.push_back(SA->isInherited());
    1625           0 :     Record.push_back(A->isImplicit());
    1626           0 :     Record.push_back(A->getSpellingListIndex());
    1627             :     break;
    1628             :   }
    1629             :   case attr::TrivialABI: {
    1630             :     const auto *SA = cast<TrivialABIAttr>(A);
    1631           0 :     Record.push_back(SA->isInherited());
    1632           0 :     Record.push_back(A->isImplicit());
    1633           0 :     Record.push_back(A->getSpellingListIndex());
    1634             :     break;
    1635             :   }
    1636             :   case attr::TryAcquireCapability: {
    1637             :     const auto *SA = cast<TryAcquireCapabilityAttr>(A);
    1638           0 :     Record.push_back(SA->isInherited());
    1639           0 :     Record.push_back(A->isImplicit());
    1640           0 :     Record.push_back(A->getSpellingListIndex());
    1641           0 :     Record.AddStmt(SA->getSuccessValue());
    1642           0 :     Record.push_back(SA->args_size());
    1643           0 :     for (auto &Val : SA->args())
    1644           0 :       Record.AddStmt(Val);
    1645             :     break;
    1646             :   }
    1647             :   case attr::TypeTagForDatatype: {
    1648             :     const auto *SA = cast<TypeTagForDatatypeAttr>(A);
    1649           0 :     Record.push_back(SA->isInherited());
    1650           0 :     Record.push_back(A->isImplicit());
    1651           0 :     Record.push_back(A->getSpellingListIndex());
    1652           0 :     Record.AddIdentifierRef(SA->getArgumentKind());
    1653           0 :     Record.AddTypeSourceInfo(SA->getMatchingCTypeLoc());
    1654           0 :     Record.push_back(SA->getLayoutCompatible());
    1655           0 :     Record.push_back(SA->getMustBeNull());
    1656             :     break;
    1657             :   }
    1658             :   case attr::TypeVisibility: {
    1659             :     const auto *SA = cast<TypeVisibilityAttr>(A);
    1660           7 :     Record.push_back(SA->isInherited());
    1661           7 :     Record.push_back(A->isImplicit());
    1662           7 :     Record.push_back(A->getSpellingListIndex());
    1663           7 : Record.push_back(SA->getVisibility());
    1664             :     break;
    1665             :   }
    1666             :   case attr::Unavailable: {
    1667             :     const auto *SA = cast<UnavailableAttr>(A);
    1668           6 :     Record.push_back(SA->isInherited());
    1669           6 :     Record.push_back(A->isImplicit());
    1670           6 :     Record.push_back(A->getSpellingListIndex());
    1671          12 :     Record.AddString(SA->getMessage());
    1672           6 : Record.push_back(SA->getImplicitReason());
    1673             :     break;
    1674             :   }
    1675             :   case attr::Unused: {
    1676             :     const auto *SA = cast<UnusedAttr>(A);
    1677           0 :     Record.push_back(SA->isInherited());
    1678           0 :     Record.push_back(A->isImplicit());
    1679           0 :     Record.push_back(A->getSpellingListIndex());
    1680             :     break;
    1681             :   }
    1682             :   case attr::Used: {
    1683             :     const auto *SA = cast<UsedAttr>(A);
    1684           0 :     Record.push_back(SA->isInherited());
    1685           0 :     Record.push_back(A->isImplicit());
    1686           0 :     Record.push_back(A->getSpellingListIndex());
    1687             :     break;
    1688             :   }
    1689             :   case attr::Uuid: {
    1690             :     const auto *SA = cast<UuidAttr>(A);
    1691           0 :     Record.push_back(SA->isInherited());
    1692           0 :     Record.push_back(A->isImplicit());
    1693           0 :     Record.push_back(A->getSpellingListIndex());
    1694           0 :     Record.AddString(SA->getGuid());
    1695             :     break;
    1696             :   }
    1697             :   case attr::VecReturn: {
    1698             :     const auto *SA = cast<VecReturnAttr>(A);
    1699           0 :     Record.push_back(SA->isInherited());
    1700           0 :     Record.push_back(A->isImplicit());
    1701           0 :     Record.push_back(A->getSpellingListIndex());
    1702             :     break;
    1703             :   }
    1704             :   case attr::VecTypeHint: {
    1705             :     const auto *SA = cast<VecTypeHintAttr>(A);
    1706           0 :     Record.push_back(SA->isInherited());
    1707           0 :     Record.push_back(A->isImplicit());
    1708           0 :     Record.push_back(A->getSpellingListIndex());
    1709           0 :     Record.AddTypeSourceInfo(SA->getTypeHintLoc());
    1710           0 :     break;
    1711             :   }
    1712             :   case attr::VectorCall: {
    1713             :     const auto *SA = cast<VectorCallAttr>(A);
    1714           0 :     Record.push_back(SA->isInherited());
    1715           0 :     Record.push_back(A->isImplicit());
    1716           0 :     Record.push_back(A->getSpellingListIndex());
    1717             :     break;
    1718             :   }
    1719             :   case attr::Visibility: {
    1720             :     const auto *SA = cast<VisibilityAttr>(A);
    1721          76 :     Record.push_back(SA->isInherited());
    1722          76 :     Record.push_back(A->isImplicit());
    1723          76 :     Record.push_back(A->getSpellingListIndex());
    1724          76 : Record.push_back(SA->getVisibility());
    1725             :     break;
    1726             :   }
    1727             :   case attr::WarnUnused: {
    1728             :     const auto *SA = cast<WarnUnusedAttr>(A);
    1729           0 :     Record.push_back(SA->isInherited());
    1730           0 :     Record.push_back(A->isImplicit());
    1731           0 :     Record.push_back(A->getSpellingListIndex());
    1732             :     break;
    1733             :   }
    1734             :   case attr::WarnUnusedResult: {
    1735             :     const auto *SA = cast<WarnUnusedResultAttr>(A);
    1736           0 :     Record.push_back(SA->isInherited());
    1737           0 :     Record.push_back(A->isImplicit());
    1738           0 :     Record.push_back(A->getSpellingListIndex());
    1739             :     break;
    1740             :   }
    1741             :   case attr::Weak: {
    1742             :     const auto *SA = cast<WeakAttr>(A);
    1743          66 :     Record.push_back(SA->isInherited());
    1744          66 :     Record.push_back(A->isImplicit());
    1745          66 :     Record.push_back(A->getSpellingListIndex());
    1746             :     break;
    1747             :   }
    1748             :   case attr::WeakImport: {
    1749             :     const auto *SA = cast<WeakImportAttr>(A);
    1750           0 :     Record.push_back(SA->isInherited());
    1751           0 :     Record.push_back(A->isImplicit());
    1752           0 :     Record.push_back(A->getSpellingListIndex());
    1753             :     break;
    1754             :   }
    1755             :   case attr::WeakRef: {
    1756             :     const auto *SA = cast<WeakRefAttr>(A);
    1757           0 :     Record.push_back(SA->isInherited());
    1758           0 :     Record.push_back(A->isImplicit());
    1759           0 :     Record.push_back(A->getSpellingListIndex());
    1760           0 :     Record.AddString(SA->getAliasee());
    1761             :     break;
    1762             :   }
    1763             :   case attr::WorkGroupSizeHint: {
    1764             :     const auto *SA = cast<WorkGroupSizeHintAttr>(A);
    1765           0 :     Record.push_back(SA->isInherited());
    1766           0 :     Record.push_back(A->isImplicit());
    1767           0 :     Record.push_back(A->getSpellingListIndex());
    1768           0 :     Record.push_back(SA->getXDim());
    1769           0 :     Record.push_back(SA->getYDim());
    1770           0 :     Record.push_back(SA->getZDim());
    1771             :     break;
    1772             :   }
    1773             :   case attr::X86ForceAlignArgPointer: {
    1774             :     const auto *SA = cast<X86ForceAlignArgPointerAttr>(A);
    1775           0 :     Record.push_back(SA->isInherited());
    1776           0 :     Record.push_back(A->isImplicit());
    1777           0 :     Record.push_back(A->getSpellingListIndex());
    1778             :     break;
    1779             :   }
    1780             :   case attr::XRayInstrument: {
    1781             :     const auto *SA = cast<XRayInstrumentAttr>(A);
    1782           0 :     Record.push_back(SA->isInherited());
    1783           0 :     Record.push_back(A->isImplicit());
    1784           0 :     Record.push_back(A->getSpellingListIndex());
    1785             :     break;
    1786             :   }
    1787             :   case attr::XRayLogArgs: {
    1788             :     const auto *SA = cast<XRayLogArgsAttr>(A);
    1789           2 :     Record.push_back(SA->isInherited());
    1790           2 :     Record.push_back(A->isImplicit());
    1791           2 :     Record.push_back(A->getSpellingListIndex());
    1792           2 :     Record.push_back(SA->getArgumentCount());
    1793             :     break;
    1794             :   }
    1795             :   }

Generated by: LCOV version 1.13