LCOV - code coverage report
Current view: top level - build-llvm/tools/clang/include/clang/Serialization - AttrPCHRead.inc (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 448 1537 29.1 %
Date: 2018-07-13 00:08:38 Functions: 0 0 -
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
       2             : |*                                                                            *|
       3             : |* Attribute deserialization code                                             *|
       4             : |*                                                                            *|
       5             : |* Automatically generated file, do not edit!                                 *|
       6             : |*                                                                            *|
       7             : \*===----------------------------------------------------------------------===*/
       8             : 
       9       39274 :   switch (Kind) {
      10             :   case attr::AMDGPUFlatWorkGroupSize: {
      11           0 :     bool isInherited = Record.readInt();
      12           0 :     bool isImplicit = Record.readInt();
      13           0 :     unsigned Spelling = Record.readInt();
      14           0 :     unsigned min = Record.readInt();
      15           0 :     unsigned max = Record.readInt();
      16           0 :     New = new (Context) AMDGPUFlatWorkGroupSizeAttr(Range, Context, min, max, Spelling);
      17           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
      18           0 :     New->setImplicit(isImplicit);
      19             :     break;
      20             :   }
      21             :   case attr::AMDGPUNumSGPR: {
      22           0 :     bool isInherited = Record.readInt();
      23           0 :     bool isImplicit = Record.readInt();
      24           0 :     unsigned Spelling = Record.readInt();
      25           0 :     unsigned numSGPR = Record.readInt();
      26           0 :     New = new (Context) AMDGPUNumSGPRAttr(Range, Context, numSGPR, Spelling);
      27           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
      28           0 :     New->setImplicit(isImplicit);
      29             :     break;
      30             :   }
      31             :   case attr::AMDGPUNumVGPR: {
      32           0 :     bool isInherited = Record.readInt();
      33           0 :     bool isImplicit = Record.readInt();
      34           0 :     unsigned Spelling = Record.readInt();
      35           0 :     unsigned numVGPR = Record.readInt();
      36           0 :     New = new (Context) AMDGPUNumVGPRAttr(Range, Context, numVGPR, Spelling);
      37           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
      38           0 :     New->setImplicit(isImplicit);
      39             :     break;
      40             :   }
      41             :   case attr::AMDGPUWavesPerEU: {
      42           0 :     bool isInherited = Record.readInt();
      43           0 :     bool isImplicit = Record.readInt();
      44           0 :     unsigned Spelling = Record.readInt();
      45           0 :     unsigned min = Record.readInt();
      46           0 :     unsigned max = Record.readInt();
      47           0 :     New = new (Context) AMDGPUWavesPerEUAttr(Range, Context, min, max, Spelling);
      48           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
      49           0 :     New->setImplicit(isImplicit);
      50             :     break;
      51             :   }
      52             :   case attr::ARMInterrupt: {
      53           0 :     bool isInherited = Record.readInt();
      54           0 :     bool isImplicit = Record.readInt();
      55           0 :     unsigned Spelling = Record.readInt();
      56           0 :     ARMInterruptAttr::InterruptType interrupt(static_cast<ARMInterruptAttr::InterruptType>(Record.readInt()));
      57           0 :     New = new (Context) ARMInterruptAttr(Range, Context, interrupt, Spelling);
      58           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
      59           0 :     New->setImplicit(isImplicit);
      60             :     break;
      61             :   }
      62             :   case attr::AVRInterrupt: {
      63           0 :     bool isInherited = Record.readInt();
      64           0 :     bool isImplicit = Record.readInt();
      65           0 :     unsigned Spelling = Record.readInt();
      66           0 :     New = new (Context) AVRInterruptAttr(Range, Context, Spelling);
      67           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
      68           0 :     New->setImplicit(isImplicit);
      69             :     break;
      70             :   }
      71             :   case attr::AVRSignal: {
      72           0 :     bool isInherited = Record.readInt();
      73           0 :     bool isImplicit = Record.readInt();
      74           0 :     unsigned Spelling = Record.readInt();
      75           0 :     New = new (Context) AVRSignalAttr(Range, Context, Spelling);
      76           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
      77           0 :     New->setImplicit(isImplicit);
      78             :     break;
      79             :   }
      80             :   case attr::AbiTag: {
      81           1 :     bool isImplicit = Record.readInt();
      82           1 :     unsigned Spelling = Record.readInt();
      83           1 :     unsigned tagsSize = Record.readInt();
      84             :     SmallVector<StringRef, 4> tags;
      85           1 :     tags.reserve(tagsSize);
      86           1 :     SmallVector<std::string, 4> tagsStorage;
      87           1 :     tagsStorage.reserve(tagsSize);
      88           7 :     for (unsigned i = 0; i != tagsSize; ++i)
      89           6 :       tagsStorage.push_back(Record.readString());
      90           7 :     for (unsigned i = 0; i != tagsSize; ++i)
      91           9 :       tags.push_back(tagsStorage[i]);
      92           2 :     New = new (Context) AbiTagAttr(Range, Context, tags.data(), tagsSize, Spelling);
      93           1 :     New->setImplicit(isImplicit);
      94             :     break;
      95             :   }
      96             :   case attr::AcquireCapability: {
      97           3 :     bool isInherited = Record.readInt();
      98           3 :     bool isImplicit = Record.readInt();
      99           3 :     unsigned Spelling = Record.readInt();
     100           3 :     unsigned argsSize = Record.readInt();
     101             :     SmallVector<Expr *, 4> args;
     102           3 :     args.reserve(argsSize);
     103           5 :     for (unsigned i = 0; i != argsSize; ++i)
     104           2 :       args.push_back(Record.readExpr());
     105           6 :     New = new (Context) AcquireCapabilityAttr(Range, Context, args.data(), argsSize, Spelling);
     106           3 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     107           3 :     New->setImplicit(isImplicit);
     108             :     break;
     109             :   }
     110             :   case attr::AcquiredAfter: {
     111           1 :     bool isInherited = Record.readInt();
     112           1 :     bool isImplicit = Record.readInt();
     113           1 :     unsigned Spelling = Record.readInt();
     114           1 :     unsigned argsSize = Record.readInt();
     115             :     SmallVector<Expr *, 4> args;
     116           1 :     args.reserve(argsSize);
     117           3 :     for (unsigned i = 0; i != argsSize; ++i)
     118           2 :       args.push_back(Record.readExpr());
     119           2 :     New = new (Context) AcquiredAfterAttr(Range, Context, args.data(), argsSize, Spelling);
     120           1 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     121           1 :     New->setImplicit(isImplicit);
     122             :     break;
     123             :   }
     124             :   case attr::AcquiredBefore: {
     125           0 :     bool isInherited = Record.readInt();
     126           0 :     bool isImplicit = Record.readInt();
     127           0 :     unsigned Spelling = Record.readInt();
     128           0 :     unsigned argsSize = Record.readInt();
     129             :     SmallVector<Expr *, 4> args;
     130           0 :     args.reserve(argsSize);
     131           0 :     for (unsigned i = 0; i != argsSize; ++i)
     132           0 :       args.push_back(Record.readExpr());
     133           0 :     New = new (Context) AcquiredBeforeAttr(Range, Context, args.data(), argsSize, Spelling);
     134           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     135           0 :     New->setImplicit(isImplicit);
     136             :     break;
     137             :   }
     138             :   case attr::Alias: {
     139           0 :     bool isImplicit = Record.readInt();
     140           0 :     unsigned Spelling = Record.readInt();
     141             :     std::string aliasee= Record.readString();
     142           0 :     New = new (Context) AliasAttr(Range, Context, aliasee, Spelling);
     143           0 :     New->setImplicit(isImplicit);
     144             :     break;
     145             :   }
     146             :   case attr::AlignMac68k: {
     147           0 :     bool isInherited = Record.readInt();
     148           0 :     bool isImplicit = Record.readInt();
     149           0 :     unsigned Spelling = Record.readInt();
     150           0 :     New = new (Context) AlignMac68kAttr(Range, Context, Spelling);
     151           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     152           0 :     New->setImplicit(isImplicit);
     153             :     break;
     154             :   }
     155             :   case attr::AlignValue: {
     156           0 :     bool isImplicit = Record.readInt();
     157           0 :     unsigned Spelling = Record.readInt();
     158           0 :     Expr * alignment = Record.readExpr();
     159           0 :     New = new (Context) AlignValueAttr(Range, Context, alignment, Spelling);
     160           0 :     New->setImplicit(isImplicit);
     161             :     break;
     162             :   }
     163             :   case attr::Aligned: {
     164         177 :     bool isInherited = Record.readInt();
     165         177 :     bool isImplicit = Record.readInt();
     166         177 :     unsigned Spelling = Record.readInt();
     167         177 :     bool isalignmentExpr = Record.readInt();
     168             :     void *alignmentPtr;
     169         177 :     if (isalignmentExpr)
     170         177 :       alignmentPtr = Record.readExpr();
     171             :     else
     172             :       alignmentPtr = Record.getTypeSourceInfo();
     173         354 :     New = new (Context) AlignedAttr(Range, Context, isalignmentExpr, alignmentPtr, Spelling);
     174         177 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     175         177 :     New->setImplicit(isImplicit);
     176             :     break;
     177             :   }
     178             :   case attr::AllocAlign: {
     179           2 :     bool isInherited = Record.readInt();
     180           2 :     bool isImplicit = Record.readInt();
     181           2 :     unsigned Spelling = Record.readInt();
     182           4 :     ParamIdx paramIndex = ParamIdx::deserialize(Record.readInt());
     183           4 :     New = new (Context) AllocAlignAttr(Range, Context, paramIndex, Spelling);
     184           2 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     185           2 :     New->setImplicit(isImplicit);
     186             :     break;
     187             :   }
     188             :   case attr::AllocSize: {
     189           4 :     bool isInherited = Record.readInt();
     190           4 :     bool isImplicit = Record.readInt();
     191           4 :     unsigned Spelling = Record.readInt();
     192           8 :     ParamIdx elemSizeParam = ParamIdx::deserialize(Record.readInt());
     193           8 :     ParamIdx numElemsParam = ParamIdx::deserialize(Record.readInt());
     194           8 :     New = new (Context) AllocSizeAttr(Range, Context, elemSizeParam, numElemsParam, Spelling);
     195           4 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     196           4 :     New->setImplicit(isImplicit);
     197             :     break;
     198             :   }
     199             :   case attr::AlwaysInline: {
     200        5906 :     bool isInherited = Record.readInt();
     201        5906 :     bool isImplicit = Record.readInt();
     202        5906 :     unsigned Spelling = Record.readInt();
     203       11812 :     New = new (Context) AlwaysInlineAttr(Range, Context, Spelling);
     204        5906 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     205        5906 :     New->setImplicit(isImplicit);
     206             :     break;
     207             :   }
     208             :   case attr::AnalyzerNoReturn: {
     209           0 :     bool isInherited = Record.readInt();
     210           0 :     bool isImplicit = Record.readInt();
     211           0 :     unsigned Spelling = Record.readInt();
     212           0 :     New = new (Context) AnalyzerNoReturnAttr(Range, Context, Spelling);
     213           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     214           0 :     New->setImplicit(isImplicit);
     215             :     break;
     216             :   }
     217             :   case attr::Annotate: {
     218           0 :     bool isInherited = Record.readInt();
     219           0 :     bool isImplicit = Record.readInt();
     220           0 :     unsigned Spelling = Record.readInt();
     221             :     std::string annotation= Record.readString();
     222           0 :     New = new (Context) AnnotateAttr(Range, Context, annotation, Spelling);
     223           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     224           0 :     New->setImplicit(isImplicit);
     225             :     break;
     226             :   }
     227             :   case attr::AnyX86Interrupt: {
     228           0 :     bool isInherited = Record.readInt();
     229           0 :     bool isImplicit = Record.readInt();
     230           0 :     unsigned Spelling = Record.readInt();
     231           0 :     New = new (Context) AnyX86InterruptAttr(Range, Context, Spelling);
     232           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     233           0 :     New->setImplicit(isImplicit);
     234             :     break;
     235             :   }
     236             :   case attr::AnyX86NoCallerSavedRegisters: {
     237           0 :     bool isInherited = Record.readInt();
     238           0 :     bool isImplicit = Record.readInt();
     239           0 :     unsigned Spelling = Record.readInt();
     240           0 :     New = new (Context) AnyX86NoCallerSavedRegistersAttr(Range, Context, Spelling);
     241           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     242           0 :     New->setImplicit(isImplicit);
     243             :     break;
     244             :   }
     245             :   case attr::AnyX86NoCfCheck: {
     246           0 :     bool isInherited = Record.readInt();
     247           0 :     bool isImplicit = Record.readInt();
     248           0 :     unsigned Spelling = Record.readInt();
     249           0 :     New = new (Context) AnyX86NoCfCheckAttr(Range, Context, Spelling);
     250           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     251           0 :     New->setImplicit(isImplicit);
     252             :     break;
     253             :   }
     254             :   case attr::ArcWeakrefUnavailable: {
     255           0 :     bool isInherited = Record.readInt();
     256           0 :     bool isImplicit = Record.readInt();
     257           0 :     unsigned Spelling = Record.readInt();
     258           0 :     New = new (Context) ArcWeakrefUnavailableAttr(Range, Context, Spelling);
     259           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     260           0 :     New->setImplicit(isImplicit);
     261             :     break;
     262             :   }
     263             :   case attr::ArgumentWithTypeTag: {
     264           4 :     bool isInherited = Record.readInt();
     265           4 :     bool isImplicit = Record.readInt();
     266           4 :     unsigned Spelling = Record.readInt();
     267             :     IdentifierInfo * argumentKind = Record.getIdentifierInfo();
     268           8 :     ParamIdx argumentIdx = ParamIdx::deserialize(Record.readInt());
     269           8 :     ParamIdx typeTagIdx = ParamIdx::deserialize(Record.readInt());
     270           4 :     bool isPointer = Record.readInt();
     271           8 :     New = new (Context) ArgumentWithTypeTagAttr(Range, Context, argumentKind, argumentIdx, typeTagIdx, isPointer, Spelling);
     272           4 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     273           4 :     New->setImplicit(isImplicit);
     274             :     break;
     275             :   }
     276             :   case attr::Artificial: {
     277           0 :     bool isInherited = Record.readInt();
     278           0 :     bool isImplicit = Record.readInt();
     279           0 :     unsigned Spelling = Record.readInt();
     280           0 :     New = new (Context) ArtificialAttr(Range, Context, Spelling);
     281           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     282           0 :     New->setImplicit(isImplicit);
     283             :     break;
     284             :   }
     285             :   case attr::AsmLabel: {
     286           8 :     bool isInherited = Record.readInt();
     287           8 :     bool isImplicit = Record.readInt();
     288           8 :     unsigned Spelling = Record.readInt();
     289             :     std::string label= Record.readString();
     290          16 :     New = new (Context) AsmLabelAttr(Range, Context, label, Spelling);
     291           8 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     292           8 :     New->setImplicit(isImplicit);
     293             :     break;
     294             :   }
     295             :   case attr::AssertCapability: {
     296           0 :     bool isInherited = Record.readInt();
     297           0 :     bool isImplicit = Record.readInt();
     298           0 :     unsigned Spelling = Record.readInt();
     299           0 :     unsigned argsSize = Record.readInt();
     300             :     SmallVector<Expr *, 4> args;
     301           0 :     args.reserve(argsSize);
     302           0 :     for (unsigned i = 0; i != argsSize; ++i)
     303           0 :       args.push_back(Record.readExpr());
     304           0 :     New = new (Context) AssertCapabilityAttr(Range, Context, args.data(), argsSize, Spelling);
     305           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     306           0 :     New->setImplicit(isImplicit);
     307             :     break;
     308             :   }
     309             :   case attr::AssertExclusiveLock: {
     310           0 :     bool isInherited = Record.readInt();
     311           0 :     bool isImplicit = Record.readInt();
     312           0 :     unsigned Spelling = Record.readInt();
     313           0 :     unsigned argsSize = Record.readInt();
     314             :     SmallVector<Expr *, 4> args;
     315           0 :     args.reserve(argsSize);
     316           0 :     for (unsigned i = 0; i != argsSize; ++i)
     317           0 :       args.push_back(Record.readExpr());
     318           0 :     New = new (Context) AssertExclusiveLockAttr(Range, Context, args.data(), argsSize, Spelling);
     319           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     320           0 :     New->setImplicit(isImplicit);
     321             :     break;
     322             :   }
     323             :   case attr::AssertSharedLock: {
     324           0 :     bool isInherited = Record.readInt();
     325           0 :     bool isImplicit = Record.readInt();
     326           0 :     unsigned Spelling = Record.readInt();
     327           0 :     unsigned argsSize = Record.readInt();
     328             :     SmallVector<Expr *, 4> args;
     329           0 :     args.reserve(argsSize);
     330           0 :     for (unsigned i = 0; i != argsSize; ++i)
     331           0 :       args.push_back(Record.readExpr());
     332           0 :     New = new (Context) AssertSharedLockAttr(Range, Context, args.data(), argsSize, Spelling);
     333           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     334           0 :     New->setImplicit(isImplicit);
     335             :     break;
     336             :   }
     337             :   case attr::AssumeAligned: {
     338           0 :     bool isInherited = Record.readInt();
     339           0 :     bool isImplicit = Record.readInt();
     340           0 :     unsigned Spelling = Record.readInt();
     341           0 :     Expr * alignment = Record.readExpr();
     342           0 :     Expr * offset = Record.readExpr();
     343           0 :     New = new (Context) AssumeAlignedAttr(Range, Context, alignment, offset, Spelling);
     344           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     345           0 :     New->setImplicit(isImplicit);
     346             :     break;
     347             :   }
     348             :   case attr::Availability: {
     349           4 :     bool isInherited = Record.readInt();
     350           4 :     bool isImplicit = Record.readInt();
     351           4 :     unsigned Spelling = Record.readInt();
     352             :     IdentifierInfo * platform = Record.getIdentifierInfo();
     353           4 :     VersionTuple introduced= Record.readVersionTuple();
     354           4 :     VersionTuple deprecated= Record.readVersionTuple();
     355           4 :     VersionTuple obsoleted= Record.readVersionTuple();
     356           4 :     bool unavailable = Record.readInt();
     357             :     std::string message= Record.readString();
     358           4 :     bool strict = Record.readInt();
     359             :     std::string replacement= Record.readString();
     360           8 :     New = new (Context) AvailabilityAttr(Range, Context, platform, introduced, deprecated, obsoleted, unavailable, message, strict, replacement, Spelling);
     361           4 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     362           4 :     New->setImplicit(isImplicit);
     363             :     break;
     364             :   }
     365             :   case attr::Blocks: {
     366           2 :     bool isInherited = Record.readInt();
     367           2 :     bool isImplicit = Record.readInt();
     368           2 :     unsigned Spelling = Record.readInt();
     369           2 :     BlocksAttr::BlockType type(static_cast<BlocksAttr::BlockType>(Record.readInt()));
     370           4 :     New = new (Context) BlocksAttr(Range, Context, type, Spelling);
     371           2 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     372           2 :     New->setImplicit(isImplicit);
     373             :     break;
     374             :   }
     375             :   case attr::C11NoReturn: {
     376           0 :     bool isInherited = Record.readInt();
     377           0 :     bool isImplicit = Record.readInt();
     378           0 :     unsigned Spelling = Record.readInt();
     379           0 :     New = new (Context) C11NoReturnAttr(Range, Context, Spelling);
     380           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     381           0 :     New->setImplicit(isImplicit);
     382             :     break;
     383             :   }
     384             :   case attr::CDecl: {
     385           0 :     bool isInherited = Record.readInt();
     386           0 :     bool isImplicit = Record.readInt();
     387           0 :     unsigned Spelling = Record.readInt();
     388           0 :     New = new (Context) CDeclAttr(Range, Context, Spelling);
     389           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     390           0 :     New->setImplicit(isImplicit);
     391             :     break;
     392             :   }
     393             :   case attr::CFAuditedTransfer: {
     394           0 :     bool isInherited = Record.readInt();
     395           0 :     bool isImplicit = Record.readInt();
     396           0 :     unsigned Spelling = Record.readInt();
     397           0 :     New = new (Context) CFAuditedTransferAttr(Range, Context, Spelling);
     398           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     399           0 :     New->setImplicit(isImplicit);
     400             :     break;
     401             :   }
     402             :   case attr::CFConsumed: {
     403           0 :     bool isInherited = Record.readInt();
     404           0 :     bool isImplicit = Record.readInt();
     405           0 :     unsigned Spelling = Record.readInt();
     406           0 :     New = new (Context) CFConsumedAttr(Range, Context, Spelling);
     407           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     408           0 :     New->setImplicit(isImplicit);
     409             :     break;
     410             :   }
     411             :   case attr::CFReturnsNotRetained: {
     412           0 :     bool isInherited = Record.readInt();
     413           0 :     bool isImplicit = Record.readInt();
     414           0 :     unsigned Spelling = Record.readInt();
     415           0 :     New = new (Context) CFReturnsNotRetainedAttr(Range, Context, Spelling);
     416           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     417           0 :     New->setImplicit(isImplicit);
     418             :     break;
     419             :   }
     420             :   case attr::CFReturnsRetained: {
     421           0 :     bool isInherited = Record.readInt();
     422           0 :     bool isImplicit = Record.readInt();
     423           0 :     unsigned Spelling = Record.readInt();
     424           0 :     New = new (Context) CFReturnsRetainedAttr(Range, Context, Spelling);
     425           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     426           0 :     New->setImplicit(isImplicit);
     427             :     break;
     428             :   }
     429             :   case attr::CFUnknownTransfer: {
     430           0 :     bool isInherited = Record.readInt();
     431           0 :     bool isImplicit = Record.readInt();
     432           0 :     unsigned Spelling = Record.readInt();
     433           0 :     New = new (Context) CFUnknownTransferAttr(Range, Context, Spelling);
     434           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     435           0 :     New->setImplicit(isImplicit);
     436             :     break;
     437             :   }
     438             :   case attr::CUDAConstant: {
     439           0 :     bool isInherited = Record.readInt();
     440           0 :     bool isImplicit = Record.readInt();
     441           0 :     unsigned Spelling = Record.readInt();
     442           0 :     New = new (Context) CUDAConstantAttr(Range, Context, Spelling);
     443           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     444           0 :     New->setImplicit(isImplicit);
     445             :     break;
     446             :   }
     447             :   case attr::CUDADevice: {
     448           4 :     bool isInherited = Record.readInt();
     449           4 :     bool isImplicit = Record.readInt();
     450           4 :     unsigned Spelling = Record.readInt();
     451           8 :     New = new (Context) CUDADeviceAttr(Range, Context, Spelling);
     452           4 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     453           4 :     New->setImplicit(isImplicit);
     454             :     break;
     455             :   }
     456             :   case attr::CUDAGlobal: {
     457           1 :     bool isInherited = Record.readInt();
     458           1 :     bool isImplicit = Record.readInt();
     459           1 :     unsigned Spelling = Record.readInt();
     460           2 :     New = new (Context) CUDAGlobalAttr(Range, Context, Spelling);
     461           1 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     462           1 :     New->setImplicit(isImplicit);
     463             :     break;
     464             :   }
     465             :   case attr::CUDAHost: {
     466           4 :     bool isInherited = Record.readInt();
     467           4 :     bool isImplicit = Record.readInt();
     468           4 :     unsigned Spelling = Record.readInt();
     469           8 :     New = new (Context) CUDAHostAttr(Range, Context, Spelling);
     470           4 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     471           4 :     New->setImplicit(isImplicit);
     472             :     break;
     473             :   }
     474             :   case attr::CUDAInvalidTarget: {
     475           0 :     bool isInherited = Record.readInt();
     476           0 :     bool isImplicit = Record.readInt();
     477           0 :     unsigned Spelling = Record.readInt();
     478           0 :     New = new (Context) CUDAInvalidTargetAttr(Range, Context, Spelling);
     479           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     480           0 :     New->setImplicit(isImplicit);
     481             :     break;
     482             :   }
     483             :   case attr::CUDALaunchBounds: {
     484           0 :     bool isInherited = Record.readInt();
     485           0 :     bool isImplicit = Record.readInt();
     486           0 :     unsigned Spelling = Record.readInt();
     487           0 :     Expr * maxThreads = Record.readExpr();
     488           0 :     Expr * minBlocks = Record.readExpr();
     489           0 :     New = new (Context) CUDALaunchBoundsAttr(Range, Context, maxThreads, minBlocks, Spelling);
     490           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     491           0 :     New->setImplicit(isImplicit);
     492             :     break;
     493             :   }
     494             :   case attr::CUDAShared: {
     495           0 :     bool isInherited = Record.readInt();
     496           0 :     bool isImplicit = Record.readInt();
     497           0 :     unsigned Spelling = Record.readInt();
     498           0 :     New = new (Context) CUDASharedAttr(Range, Context, Spelling);
     499           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     500           0 :     New->setImplicit(isImplicit);
     501             :     break;
     502             :   }
     503             :   case attr::CXX11NoReturn: {
     504           0 :     bool isInherited = Record.readInt();
     505           0 :     bool isImplicit = Record.readInt();
     506           0 :     unsigned Spelling = Record.readInt();
     507           0 :     New = new (Context) CXX11NoReturnAttr(Range, Context, Spelling);
     508           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     509           0 :     New->setImplicit(isImplicit);
     510             :     break;
     511             :   }
     512             :   case attr::CallableWhen: {
     513           0 :     bool isInherited = Record.readInt();
     514           0 :     bool isImplicit = Record.readInt();
     515           0 :     unsigned Spelling = Record.readInt();
     516           0 :     unsigned callableStatesSize = Record.readInt();
     517             :     SmallVector<CallableWhenAttr::ConsumedState, 4> callableStates;
     518           0 :     callableStates.reserve(callableStatesSize);
     519           0 :     for (unsigned i = callableStatesSize; i; --i)
     520           0 :       callableStates.push_back(static_cast<CallableWhenAttr::ConsumedState>(Record.readInt()));
     521           0 :     New = new (Context) CallableWhenAttr(Range, Context, callableStates.data(), callableStatesSize, Spelling);
     522           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     523           0 :     New->setImplicit(isImplicit);
     524             :     break;
     525             :   }
     526             :   case attr::Capability: {
     527           4 :     bool isInherited = Record.readInt();
     528           4 :     bool isImplicit = Record.readInt();
     529           4 :     unsigned Spelling = Record.readInt();
     530             :     std::string name= Record.readString();
     531           8 :     New = new (Context) CapabilityAttr(Range, Context, name, Spelling);
     532           4 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     533           4 :     New->setImplicit(isImplicit);
     534             :     break;
     535             :   }
     536             :   case attr::CapturedRecord: {
     537       18842 :     bool isInherited = Record.readInt();
     538       18842 :     bool isImplicit = Record.readInt();
     539       18842 :     unsigned Spelling = Record.readInt();
     540       37684 :     New = new (Context) CapturedRecordAttr(Range, Context, Spelling);
     541       18842 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     542       18842 :     New->setImplicit(isImplicit);
     543             :     break;
     544             :   }
     545             :   case attr::CarriesDependency: {
     546           0 :     bool isInherited = Record.readInt();
     547           0 :     bool isImplicit = Record.readInt();
     548           0 :     unsigned Spelling = Record.readInt();
     549           0 :     New = new (Context) CarriesDependencyAttr(Range, Context, Spelling);
     550           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     551           0 :     New->setImplicit(isImplicit);
     552             :     break;
     553             :   }
     554             :   case attr::Cleanup: {
     555           0 :     bool isInherited = Record.readInt();
     556           0 :     bool isImplicit = Record.readInt();
     557           0 :     unsigned Spelling = Record.readInt();
     558           0 :     FunctionDecl * functionDecl = Record.GetLocalDeclAs<FunctionDecl >(Record.readInt());
     559           0 :     New = new (Context) CleanupAttr(Range, Context, functionDecl, Spelling);
     560           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     561           0 :     New->setImplicit(isImplicit);
     562             :     break;
     563             :   }
     564             :   case attr::Cold: {
     565           8 :     bool isInherited = Record.readInt();
     566           8 :     bool isImplicit = Record.readInt();
     567           8 :     unsigned Spelling = Record.readInt();
     568          16 :     New = new (Context) ColdAttr(Range, Context, Spelling);
     569           8 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     570           8 :     New->setImplicit(isImplicit);
     571             :     break;
     572             :   }
     573             :   case attr::Common: {
     574           0 :     bool isInherited = Record.readInt();
     575           0 :     bool isImplicit = Record.readInt();
     576           0 :     unsigned Spelling = Record.readInt();
     577           0 :     New = new (Context) CommonAttr(Range, Context, Spelling);
     578           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     579           0 :     New->setImplicit(isImplicit);
     580             :     break;
     581             :   }
     582             :   case attr::Const: {
     583          62 :     bool isInherited = Record.readInt();
     584          62 :     bool isImplicit = Record.readInt();
     585          62 :     unsigned Spelling = Record.readInt();
     586         124 :     New = new (Context) ConstAttr(Range, Context, Spelling);
     587          62 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     588          62 :     New->setImplicit(isImplicit);
     589             :     break;
     590             :   }
     591             :   case attr::Constructor: {
     592           0 :     bool isInherited = Record.readInt();
     593           0 :     bool isImplicit = Record.readInt();
     594           0 :     unsigned Spelling = Record.readInt();
     595           0 :     int priority = Record.readInt();
     596           0 :     New = new (Context) ConstructorAttr(Range, Context, priority, Spelling);
     597           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     598           0 :     New->setImplicit(isImplicit);
     599             :     break;
     600             :   }
     601             :   case attr::Consumable: {
     602           0 :     bool isInherited = Record.readInt();
     603           0 :     bool isImplicit = Record.readInt();
     604           0 :     unsigned Spelling = Record.readInt();
     605           0 :     ConsumableAttr::ConsumedState defaultState(static_cast<ConsumableAttr::ConsumedState>(Record.readInt()));
     606           0 :     New = new (Context) ConsumableAttr(Range, Context, defaultState, Spelling);
     607           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     608           0 :     New->setImplicit(isImplicit);
     609             :     break;
     610             :   }
     611             :   case attr::ConsumableAutoCast: {
     612           0 :     bool isInherited = Record.readInt();
     613           0 :     bool isImplicit = Record.readInt();
     614           0 :     unsigned Spelling = Record.readInt();
     615           0 :     New = new (Context) ConsumableAutoCastAttr(Range, Context, Spelling);
     616           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     617           0 :     New->setImplicit(isImplicit);
     618             :     break;
     619             :   }
     620             :   case attr::ConsumableSetOnRead: {
     621           0 :     bool isInherited = Record.readInt();
     622           0 :     bool isImplicit = Record.readInt();
     623           0 :     unsigned Spelling = Record.readInt();
     624           0 :     New = new (Context) ConsumableSetOnReadAttr(Range, Context, Spelling);
     625           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     626           0 :     New->setImplicit(isImplicit);
     627             :     break;
     628             :   }
     629             :   case attr::Convergent: {
     630           0 :     bool isInherited = Record.readInt();
     631           0 :     bool isImplicit = Record.readInt();
     632           0 :     unsigned Spelling = Record.readInt();
     633           0 :     New = new (Context) ConvergentAttr(Range, Context, Spelling);
     634           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     635           0 :     New->setImplicit(isImplicit);
     636             :     break;
     637             :   }
     638             :   case attr::DLLExport: {
     639          53 :     bool isInherited = Record.readInt();
     640          53 :     bool isImplicit = Record.readInt();
     641          53 :     unsigned Spelling = Record.readInt();
     642         106 :     New = new (Context) DLLExportAttr(Range, Context, Spelling);
     643          53 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     644          53 :     New->setImplicit(isImplicit);
     645             :     break;
     646             :   }
     647             :   case attr::DLLImport: {
     648           0 :     bool isInherited = Record.readInt();
     649           0 :     bool isImplicit = Record.readInt();
     650           0 :     unsigned Spelling = Record.readInt();
     651           0 :     New = new (Context) DLLImportAttr(Range, Context, Spelling);
     652           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     653           0 :     New->setImplicit(isImplicit);
     654             :     break;
     655             :   }
     656             :   case attr::Deprecated: {
     657           1 :     bool isInherited = Record.readInt();
     658           1 :     bool isImplicit = Record.readInt();
     659           1 :     unsigned Spelling = Record.readInt();
     660             :     std::string message= Record.readString();
     661             :     std::string replacement= Record.readString();
     662           2 :     New = new (Context) DeprecatedAttr(Range, Context, message, replacement, Spelling);
     663           1 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     664           1 :     New->setImplicit(isImplicit);
     665             :     break;
     666             :   }
     667             :   case attr::Destructor: {
     668           0 :     bool isInherited = Record.readInt();
     669           0 :     bool isImplicit = Record.readInt();
     670           0 :     unsigned Spelling = Record.readInt();
     671           0 :     int priority = Record.readInt();
     672           0 :     New = new (Context) DestructorAttr(Range, Context, priority, Spelling);
     673           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     674           0 :     New->setImplicit(isImplicit);
     675             :     break;
     676             :   }
     677             :   case attr::DiagnoseIf: {
     678           0 :     bool isInherited = Record.readInt();
     679           0 :     bool isImplicit = Record.readInt();
     680           0 :     unsigned Spelling = Record.readInt();
     681           0 :     Expr * cond = Record.readExpr();
     682             :     std::string message= Record.readString();
     683           0 :     DiagnoseIfAttr::DiagnosticType diagnosticType(static_cast<DiagnoseIfAttr::DiagnosticType>(Record.readInt()));
     684           0 :     bool argDependent = Record.readInt();
     685           0 :     NamedDecl * parent = Record.GetLocalDeclAs<NamedDecl >(Record.readInt());
     686           0 :     New = new (Context) DiagnoseIfAttr(Range, Context, cond, message, diagnosticType, argDependent, parent, Spelling);
     687           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     688           0 :     New->setImplicit(isImplicit);
     689             :     break;
     690             :   }
     691             :   case attr::DisableTailCalls: {
     692           0 :     bool isInherited = Record.readInt();
     693           0 :     bool isImplicit = Record.readInt();
     694           0 :     unsigned Spelling = Record.readInt();
     695           0 :     New = new (Context) DisableTailCallsAttr(Range, Context, Spelling);
     696           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     697           0 :     New->setImplicit(isImplicit);
     698             :     break;
     699             :   }
     700             :   case attr::EmptyBases: {
     701           0 :     bool isInherited = Record.readInt();
     702           0 :     bool isImplicit = Record.readInt();
     703           0 :     unsigned Spelling = Record.readInt();
     704           0 :     New = new (Context) EmptyBasesAttr(Range, Context, Spelling);
     705           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     706           0 :     New->setImplicit(isImplicit);
     707             :     break;
     708             :   }
     709             :   case attr::EnableIf: {
     710           6 :     bool isInherited = Record.readInt();
     711           6 :     bool isImplicit = Record.readInt();
     712           6 :     unsigned Spelling = Record.readInt();
     713           6 :     Expr * cond = Record.readExpr();
     714             :     std::string message= Record.readString();
     715          12 :     New = new (Context) EnableIfAttr(Range, Context, cond, message, Spelling);
     716           6 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     717           6 :     New->setImplicit(isImplicit);
     718             :     break;
     719             :   }
     720             :   case attr::EnumExtensibility: {
     721           2 :     bool isInherited = Record.readInt();
     722           2 :     bool isImplicit = Record.readInt();
     723           2 :     unsigned Spelling = Record.readInt();
     724           2 :     EnumExtensibilityAttr::Kind extensibility(static_cast<EnumExtensibilityAttr::Kind>(Record.readInt()));
     725           4 :     New = new (Context) EnumExtensibilityAttr(Range, Context, extensibility, Spelling);
     726           2 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     727           2 :     New->setImplicit(isImplicit);
     728             :     break;
     729             :   }
     730             :   case attr::ExclusiveTrylockFunction: {
     731           0 :     bool isInherited = Record.readInt();
     732           0 :     bool isImplicit = Record.readInt();
     733           0 :     unsigned Spelling = Record.readInt();
     734           0 :     Expr * successValue = Record.readExpr();
     735           0 :     unsigned argsSize = Record.readInt();
     736             :     SmallVector<Expr *, 4> args;
     737           0 :     args.reserve(argsSize);
     738           0 :     for (unsigned i = 0; i != argsSize; ++i)
     739           0 :       args.push_back(Record.readExpr());
     740           0 :     New = new (Context) ExclusiveTrylockFunctionAttr(Range, Context, successValue, args.data(), argsSize, Spelling);
     741           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     742           0 :     New->setImplicit(isImplicit);
     743             :     break;
     744             :   }
     745             :   case attr::ExternalSourceSymbol: {
     746           0 :     bool isInherited = Record.readInt();
     747           0 :     bool isImplicit = Record.readInt();
     748           0 :     unsigned Spelling = Record.readInt();
     749             :     std::string language= Record.readString();
     750             :     std::string definedIn= Record.readString();
     751           0 :     bool generatedDeclaration = Record.readInt();
     752           0 :     New = new (Context) ExternalSourceSymbolAttr(Range, Context, language, definedIn, generatedDeclaration, Spelling);
     753           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     754           0 :     New->setImplicit(isImplicit);
     755             :     break;
     756             :   }
     757             :   case attr::FallThrough: {
     758           4 :     bool isImplicit = Record.readInt();
     759           4 :     unsigned Spelling = Record.readInt();
     760           8 :     New = new (Context) FallThroughAttr(Range, Context, Spelling);
     761           4 :     New->setImplicit(isImplicit);
     762             :     break;
     763             :   }
     764             :   case attr::FastCall: {
     765           0 :     bool isInherited = Record.readInt();
     766           0 :     bool isImplicit = Record.readInt();
     767           0 :     unsigned Spelling = Record.readInt();
     768           0 :     New = new (Context) FastCallAttr(Range, Context, Spelling);
     769           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     770           0 :     New->setImplicit(isImplicit);
     771             :     break;
     772             :   }
     773             :   case attr::Final: {
     774           0 :     bool isInherited = Record.readInt();
     775           0 :     bool isImplicit = Record.readInt();
     776           0 :     unsigned Spelling = Record.readInt();
     777           0 :     New = new (Context) FinalAttr(Range, Context, Spelling);
     778           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     779           0 :     New->setImplicit(isImplicit);
     780             :     break;
     781             :   }
     782             :   case attr::FlagEnum: {
     783           2 :     bool isInherited = Record.readInt();
     784           2 :     bool isImplicit = Record.readInt();
     785           2 :     unsigned Spelling = Record.readInt();
     786           4 :     New = new (Context) FlagEnumAttr(Range, Context, Spelling);
     787           2 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     788           2 :     New->setImplicit(isImplicit);
     789             :     break;
     790             :   }
     791             :   case attr::Flatten: {
     792           0 :     bool isInherited = Record.readInt();
     793           0 :     bool isImplicit = Record.readInt();
     794           0 :     unsigned Spelling = Record.readInt();
     795           0 :     New = new (Context) FlattenAttr(Range, Context, Spelling);
     796           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     797           0 :     New->setImplicit(isImplicit);
     798             :     break;
     799             :   }
     800             :   case attr::Format: {
     801          27 :     bool isInherited = Record.readInt();
     802          27 :     bool isImplicit = Record.readInt();
     803          27 :     unsigned Spelling = Record.readInt();
     804             :     IdentifierInfo * type = Record.getIdentifierInfo();
     805          27 :     int formatIdx = Record.readInt();
     806          27 :     int firstArg = Record.readInt();
     807          54 :     New = new (Context) FormatAttr(Range, Context, type, formatIdx, firstArg, Spelling);
     808          27 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     809          27 :     New->setImplicit(isImplicit);
     810             :     break;
     811             :   }
     812             :   case attr::FormatArg: {
     813           2 :     bool isInherited = Record.readInt();
     814           2 :     bool isImplicit = Record.readInt();
     815           2 :     unsigned Spelling = Record.readInt();
     816           4 :     ParamIdx formatIdx = ParamIdx::deserialize(Record.readInt());
     817           4 :     New = new (Context) FormatArgAttr(Range, Context, formatIdx, Spelling);
     818           2 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     819           2 :     New->setImplicit(isImplicit);
     820             :     break;
     821             :   }
     822             :   case attr::GNUInline: {
     823           0 :     bool isInherited = Record.readInt();
     824           0 :     bool isImplicit = Record.readInt();
     825           0 :     unsigned Spelling = Record.readInt();
     826           0 :     New = new (Context) GNUInlineAttr(Range, Context, Spelling);
     827           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     828           0 :     New->setImplicit(isImplicit);
     829             :     break;
     830             :   }
     831             :   case attr::GuardedBy: {
     832           3 :     bool isInherited = Record.readInt();
     833           3 :     bool isImplicit = Record.readInt();
     834           3 :     unsigned Spelling = Record.readInt();
     835           3 :     Expr * arg = Record.readExpr();
     836           6 :     New = new (Context) GuardedByAttr(Range, Context, arg, Spelling);
     837           3 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     838           3 :     New->setImplicit(isImplicit);
     839             :     break;
     840             :   }
     841             :   case attr::GuardedVar: {
     842           1 :     bool isInherited = Record.readInt();
     843           1 :     bool isImplicit = Record.readInt();
     844           1 :     unsigned Spelling = Record.readInt();
     845           2 :     New = new (Context) GuardedVarAttr(Range, Context, Spelling);
     846           1 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     847           1 :     New->setImplicit(isImplicit);
     848             :     break;
     849             :   }
     850             :   case attr::Hot: {
     851           0 :     bool isInherited = Record.readInt();
     852           0 :     bool isImplicit = Record.readInt();
     853           0 :     unsigned Spelling = Record.readInt();
     854           0 :     New = new (Context) HotAttr(Range, Context, Spelling);
     855           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     856           0 :     New->setImplicit(isImplicit);
     857             :     break;
     858             :   }
     859             :   case attr::IBAction: {
     860           2 :     bool isInherited = Record.readInt();
     861           2 :     bool isImplicit = Record.readInt();
     862           2 :     unsigned Spelling = Record.readInt();
     863           4 :     New = new (Context) IBActionAttr(Range, Context, Spelling);
     864           2 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     865           2 :     New->setImplicit(isImplicit);
     866             :     break;
     867             :   }
     868             :   case attr::IBOutlet: {
     869           3 :     bool isInherited = Record.readInt();
     870           3 :     bool isImplicit = Record.readInt();
     871           3 :     unsigned Spelling = Record.readInt();
     872           6 :     New = new (Context) IBOutletAttr(Range, Context, Spelling);
     873           3 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     874           3 :     New->setImplicit(isImplicit);
     875             :     break;
     876             :   }
     877             :   case attr::IBOutletCollection: {
     878           1 :     bool isInherited = Record.readInt();
     879           1 :     bool isImplicit = Record.readInt();
     880           1 :     unsigned Spelling = Record.readInt();
     881             :     TypeSourceInfo * interface_ = Record.getTypeSourceInfo();
     882           2 :     New = new (Context) IBOutletCollectionAttr(Range, Context, interface_, Spelling);
     883           1 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     884           1 :     New->setImplicit(isImplicit);
     885             :     break;
     886             :   }
     887             :   case attr::IFunc: {
     888           0 :     bool isImplicit = Record.readInt();
     889           0 :     unsigned Spelling = Record.readInt();
     890             :     std::string resolver= Record.readString();
     891           0 :     New = new (Context) IFuncAttr(Range, Context, resolver, Spelling);
     892           0 :     New->setImplicit(isImplicit);
     893             :     break;
     894             :   }
     895             :   case attr::InitPriority: {
     896         216 :     bool isInherited = Record.readInt();
     897         216 :     bool isImplicit = Record.readInt();
     898         216 :     unsigned Spelling = Record.readInt();
     899         216 :     unsigned priority = Record.readInt();
     900         432 :     New = new (Context) InitPriorityAttr(Range, Context, priority, Spelling);
     901         216 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     902         216 :     New->setImplicit(isImplicit);
     903             :     break;
     904             :   }
     905             :   case attr::InitSeg: {
     906           0 :     bool isImplicit = Record.readInt();
     907           0 :     unsigned Spelling = Record.readInt();
     908             :     std::string section= Record.readString();
     909           0 :     New = new (Context) InitSegAttr(Range, Context, section, Spelling);
     910           0 :     New->setImplicit(isImplicit);
     911             :     break;
     912             :   }
     913             :   case attr::IntelOclBicc: {
     914           0 :     bool isInherited = Record.readInt();
     915           0 :     bool isImplicit = Record.readInt();
     916           0 :     unsigned Spelling = Record.readInt();
     917           0 :     New = new (Context) IntelOclBiccAttr(Range, Context, Spelling);
     918           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     919           0 :     New->setImplicit(isImplicit);
     920             :     break;
     921             :   }
     922             :   case attr::InternalLinkage: {
     923           0 :     bool isInherited = Record.readInt();
     924           0 :     bool isImplicit = Record.readInt();
     925           0 :     unsigned Spelling = Record.readInt();
     926           0 :     New = new (Context) InternalLinkageAttr(Range, Context, Spelling);
     927           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     928           0 :     New->setImplicit(isImplicit);
     929             :     break;
     930             :   }
     931             :   case attr::LTOVisibilityPublic: {
     932           0 :     bool isInherited = Record.readInt();
     933           0 :     bool isImplicit = Record.readInt();
     934           0 :     unsigned Spelling = Record.readInt();
     935           0 :     New = new (Context) LTOVisibilityPublicAttr(Range, Context, Spelling);
     936           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     937           0 :     New->setImplicit(isImplicit);
     938             :     break;
     939             :   }
     940             :   case attr::LayoutVersion: {
     941           0 :     bool isInherited = Record.readInt();
     942           0 :     bool isImplicit = Record.readInt();
     943           0 :     unsigned Spelling = Record.readInt();
     944           0 :     unsigned version = Record.readInt();
     945           0 :     New = new (Context) LayoutVersionAttr(Range, Context, version, Spelling);
     946           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     947           0 :     New->setImplicit(isImplicit);
     948             :     break;
     949             :   }
     950             :   case attr::LockReturned: {
     951           0 :     bool isInherited = Record.readInt();
     952           0 :     bool isImplicit = Record.readInt();
     953           0 :     unsigned Spelling = Record.readInt();
     954           0 :     Expr * arg = Record.readExpr();
     955           0 :     New = new (Context) LockReturnedAttr(Range, Context, arg, Spelling);
     956           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     957           0 :     New->setImplicit(isImplicit);
     958             :     break;
     959             :   }
     960             :   case attr::LocksExcluded: {
     961           0 :     bool isInherited = Record.readInt();
     962           0 :     bool isImplicit = Record.readInt();
     963           0 :     unsigned Spelling = Record.readInt();
     964           0 :     unsigned argsSize = Record.readInt();
     965             :     SmallVector<Expr *, 4> args;
     966           0 :     args.reserve(argsSize);
     967           0 :     for (unsigned i = 0; i != argsSize; ++i)
     968           0 :       args.push_back(Record.readExpr());
     969           0 :     New = new (Context) LocksExcludedAttr(Range, Context, args.data(), argsSize, Spelling);
     970           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     971           0 :     New->setImplicit(isImplicit);
     972             :     break;
     973             :   }
     974             :   case attr::LoopHint: {
     975          16 :     bool isImplicit = Record.readInt();
     976          16 :     unsigned Spelling = Record.readInt();
     977          16 :     LoopHintAttr::OptionType option(static_cast<LoopHintAttr::OptionType>(Record.readInt()));
     978          16 :     LoopHintAttr::LoopHintState state(static_cast<LoopHintAttr::LoopHintState>(Record.readInt()));
     979          16 :     Expr * value = Record.readExpr();
     980          32 :     New = new (Context) LoopHintAttr(Range, Context, option, state, value, Spelling);
     981          16 :     New->setImplicit(isImplicit);
     982             :     break;
     983             :   }
     984             :   case attr::MSABI: {
     985           0 :     bool isInherited = Record.readInt();
     986           0 :     bool isImplicit = Record.readInt();
     987           0 :     unsigned Spelling = Record.readInt();
     988           0 :     New = new (Context) MSABIAttr(Range, Context, Spelling);
     989           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
     990           0 :     New->setImplicit(isImplicit);
     991             :     break;
     992             :   }
     993             :   case attr::MSInheritance: {
     994           1 :     bool isInherited = Record.readInt();
     995           1 :     bool isImplicit = Record.readInt();
     996           1 :     unsigned Spelling = Record.readInt();
     997           1 :     bool bestCase = Record.readInt();
     998           2 :     New = new (Context) MSInheritanceAttr(Range, Context, bestCase, Spelling);
     999           1 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1000           1 :     New->setImplicit(isImplicit);
    1001             :     break;
    1002             :   }
    1003             :   case attr::MSNoVTable: {
    1004           0 :     bool isInherited = Record.readInt();
    1005           0 :     bool isImplicit = Record.readInt();
    1006           0 :     unsigned Spelling = Record.readInt();
    1007           0 :     New = new (Context) MSNoVTableAttr(Range, Context, Spelling);
    1008           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1009           0 :     New->setImplicit(isImplicit);
    1010             :     break;
    1011             :   }
    1012             :   case attr::MSP430Interrupt: {
    1013           0 :     bool isInherited = Record.readInt();
    1014           0 :     bool isImplicit = Record.readInt();
    1015           0 :     unsigned Spelling = Record.readInt();
    1016           0 :     unsigned number = Record.readInt();
    1017           0 :     New = new (Context) MSP430InterruptAttr(Range, Context, number, Spelling);
    1018           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1019           0 :     New->setImplicit(isImplicit);
    1020             :     break;
    1021             :   }
    1022             :   case attr::MSStruct: {
    1023           1 :     bool isInherited = Record.readInt();
    1024           1 :     bool isImplicit = Record.readInt();
    1025           1 :     unsigned Spelling = Record.readInt();
    1026           2 :     New = new (Context) MSStructAttr(Range, Context, Spelling);
    1027           1 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1028           1 :     New->setImplicit(isImplicit);
    1029             :     break;
    1030             :   }
    1031             :   case attr::MSVtorDisp: {
    1032           0 :     bool isInherited = Record.readInt();
    1033           0 :     bool isImplicit = Record.readInt();
    1034           0 :     unsigned Spelling = Record.readInt();
    1035           0 :     unsigned vdm = Record.readInt();
    1036           0 :     New = new (Context) MSVtorDispAttr(Range, Context, vdm, Spelling);
    1037           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1038           0 :     New->setImplicit(isImplicit);
    1039             :     break;
    1040             :   }
    1041             :   case attr::MaxFieldAlignment: {
    1042           0 :     bool isInherited = Record.readInt();
    1043           0 :     bool isImplicit = Record.readInt();
    1044           0 :     unsigned Spelling = Record.readInt();
    1045           0 :     unsigned alignment = Record.readInt();
    1046           0 :     New = new (Context) MaxFieldAlignmentAttr(Range, Context, alignment, Spelling);
    1047           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1048           0 :     New->setImplicit(isImplicit);
    1049             :     break;
    1050             :   }
    1051             :   case attr::MayAlias: {
    1052           0 :     bool isInherited = Record.readInt();
    1053           0 :     bool isImplicit = Record.readInt();
    1054           0 :     unsigned Spelling = Record.readInt();
    1055           0 :     New = new (Context) MayAliasAttr(Range, Context, Spelling);
    1056           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1057           0 :     New->setImplicit(isImplicit);
    1058             :     break;
    1059             :   }
    1060             :   case attr::MicroMips: {
    1061           0 :     bool isInherited = Record.readInt();
    1062           0 :     bool isImplicit = Record.readInt();
    1063           0 :     unsigned Spelling = Record.readInt();
    1064           0 :     New = new (Context) MicroMipsAttr(Range, Context, Spelling);
    1065           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1066           0 :     New->setImplicit(isImplicit);
    1067             :     break;
    1068             :   }
    1069             :   case attr::MinSize: {
    1070           0 :     bool isInherited = Record.readInt();
    1071           0 :     bool isImplicit = Record.readInt();
    1072           0 :     unsigned Spelling = Record.readInt();
    1073           0 :     New = new (Context) MinSizeAttr(Range, Context, Spelling);
    1074           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1075           0 :     New->setImplicit(isImplicit);
    1076             :     break;
    1077             :   }
    1078             :   case attr::MinVectorWidth: {
    1079           5 :     bool isInherited = Record.readInt();
    1080           5 :     bool isImplicit = Record.readInt();
    1081           5 :     unsigned Spelling = Record.readInt();
    1082           5 :     unsigned vectorWidth = Record.readInt();
    1083          10 :     New = new (Context) MinVectorWidthAttr(Range, Context, vectorWidth, Spelling);
    1084           5 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1085           5 :     New->setImplicit(isImplicit);
    1086             :     break;
    1087             :   }
    1088             :   case attr::Mips16: {
    1089           0 :     bool isInherited = Record.readInt();
    1090           0 :     bool isImplicit = Record.readInt();
    1091           0 :     unsigned Spelling = Record.readInt();
    1092           0 :     New = new (Context) Mips16Attr(Range, Context, Spelling);
    1093           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1094           0 :     New->setImplicit(isImplicit);
    1095             :     break;
    1096             :   }
    1097             :   case attr::MipsInterrupt: {
    1098           0 :     bool isInherited = Record.readInt();
    1099           0 :     bool isImplicit = Record.readInt();
    1100           0 :     unsigned Spelling = Record.readInt();
    1101           0 :     MipsInterruptAttr::InterruptType interrupt(static_cast<MipsInterruptAttr::InterruptType>(Record.readInt()));
    1102           0 :     New = new (Context) MipsInterruptAttr(Range, Context, interrupt, Spelling);
    1103           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1104           0 :     New->setImplicit(isImplicit);
    1105             :     break;
    1106             :   }
    1107             :   case attr::MipsLongCall: {
    1108           0 :     bool isInherited = Record.readInt();
    1109           0 :     bool isImplicit = Record.readInt();
    1110           0 :     unsigned Spelling = Record.readInt();
    1111           0 :     New = new (Context) MipsLongCallAttr(Range, Context, Spelling);
    1112           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1113           0 :     New->setImplicit(isImplicit);
    1114             :     break;
    1115             :   }
    1116             :   case attr::MipsShortCall: {
    1117           0 :     bool isInherited = Record.readInt();
    1118           0 :     bool isImplicit = Record.readInt();
    1119           0 :     unsigned Spelling = Record.readInt();
    1120           0 :     New = new (Context) MipsShortCallAttr(Range, Context, Spelling);
    1121           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1122           0 :     New->setImplicit(isImplicit);
    1123             :     break;
    1124             :   }
    1125             :   case attr::Mode: {
    1126           0 :     bool isImplicit = Record.readInt();
    1127           0 :     unsigned Spelling = Record.readInt();
    1128             :     IdentifierInfo * mode = Record.getIdentifierInfo();
    1129           0 :     New = new (Context) ModeAttr(Range, Context, mode, Spelling);
    1130           0 :     New->setImplicit(isImplicit);
    1131             :     break;
    1132             :   }
    1133             :   case attr::NSConsumed: {
    1134           0 :     bool isInherited = Record.readInt();
    1135           0 :     bool isImplicit = Record.readInt();
    1136           0 :     unsigned Spelling = Record.readInt();
    1137           0 :     New = new (Context) NSConsumedAttr(Range, Context, Spelling);
    1138           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1139           0 :     New->setImplicit(isImplicit);
    1140             :     break;
    1141             :   }
    1142             :   case attr::NSConsumesSelf: {
    1143           0 :     bool isInherited = Record.readInt();
    1144           0 :     bool isImplicit = Record.readInt();
    1145           0 :     unsigned Spelling = Record.readInt();
    1146           0 :     New = new (Context) NSConsumesSelfAttr(Range, Context, Spelling);
    1147           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1148           0 :     New->setImplicit(isImplicit);
    1149             :     break;
    1150             :   }
    1151             :   case attr::NSReturnsAutoreleased: {
    1152           0 :     bool isInherited = Record.readInt();
    1153           0 :     bool isImplicit = Record.readInt();
    1154           0 :     unsigned Spelling = Record.readInt();
    1155           0 :     New = new (Context) NSReturnsAutoreleasedAttr(Range, Context, Spelling);
    1156           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1157           0 :     New->setImplicit(isImplicit);
    1158             :     break;
    1159             :   }
    1160             :   case attr::NSReturnsNotRetained: {
    1161           0 :     bool isInherited = Record.readInt();
    1162           0 :     bool isImplicit = Record.readInt();
    1163           0 :     unsigned Spelling = Record.readInt();
    1164           0 :     New = new (Context) NSReturnsNotRetainedAttr(Range, Context, Spelling);
    1165           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1166           0 :     New->setImplicit(isImplicit);
    1167             :     break;
    1168             :   }
    1169             :   case attr::NSReturnsRetained: {
    1170           0 :     bool isInherited = Record.readInt();
    1171           0 :     bool isImplicit = Record.readInt();
    1172           0 :     unsigned Spelling = Record.readInt();
    1173           0 :     New = new (Context) NSReturnsRetainedAttr(Range, Context, Spelling);
    1174           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1175           0 :     New->setImplicit(isImplicit);
    1176             :     break;
    1177             :   }
    1178             :   case attr::Naked: {
    1179           0 :     bool isInherited = Record.readInt();
    1180           0 :     bool isImplicit = Record.readInt();
    1181           0 :     unsigned Spelling = Record.readInt();
    1182           0 :     New = new (Context) NakedAttr(Range, Context, Spelling);
    1183           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1184           0 :     New->setImplicit(isImplicit);
    1185             :     break;
    1186             :   }
    1187             :   case attr::NoAlias: {
    1188           0 :     bool isInherited = Record.readInt();
    1189           0 :     bool isImplicit = Record.readInt();
    1190           0 :     unsigned Spelling = Record.readInt();
    1191           0 :     New = new (Context) NoAliasAttr(Range, Context, Spelling);
    1192           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1193           0 :     New->setImplicit(isImplicit);
    1194             :     break;
    1195             :   }
    1196             :   case attr::NoCommon: {
    1197           0 :     bool isInherited = Record.readInt();
    1198           0 :     bool isImplicit = Record.readInt();
    1199           0 :     unsigned Spelling = Record.readInt();
    1200           0 :     New = new (Context) NoCommonAttr(Range, Context, Spelling);
    1201           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1202           0 :     New->setImplicit(isImplicit);
    1203             :     break;
    1204             :   }
    1205             :   case attr::NoDebug: {
    1206           5 :     bool isInherited = Record.readInt();
    1207           5 :     bool isImplicit = Record.readInt();
    1208           5 :     unsigned Spelling = Record.readInt();
    1209          10 :     New = new (Context) NoDebugAttr(Range, Context, Spelling);
    1210           5 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1211           5 :     New->setImplicit(isImplicit);
    1212             :     break;
    1213             :   }
    1214             :   case attr::NoDuplicate: {
    1215           0 :     bool isInherited = Record.readInt();
    1216           0 :     bool isImplicit = Record.readInt();
    1217           0 :     unsigned Spelling = Record.readInt();
    1218           0 :     New = new (Context) NoDuplicateAttr(Range, Context, Spelling);
    1219           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1220           0 :     New->setImplicit(isImplicit);
    1221             :     break;
    1222             :   }
    1223             :   case attr::NoEscape: {
    1224           0 :     bool isImplicit = Record.readInt();
    1225           0 :     unsigned Spelling = Record.readInt();
    1226           0 :     New = new (Context) NoEscapeAttr(Range, Context, Spelling);
    1227           0 :     New->setImplicit(isImplicit);
    1228             :     break;
    1229             :   }
    1230             :   case attr::NoInline: {
    1231           0 :     bool isInherited = Record.readInt();
    1232           0 :     bool isImplicit = Record.readInt();
    1233           0 :     unsigned Spelling = Record.readInt();
    1234           0 :     New = new (Context) NoInlineAttr(Range, Context, Spelling);
    1235           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1236           0 :     New->setImplicit(isImplicit);
    1237             :     break;
    1238             :   }
    1239             :   case attr::NoInstrumentFunction: {
    1240           0 :     bool isInherited = Record.readInt();
    1241           0 :     bool isImplicit = Record.readInt();
    1242           0 :     unsigned Spelling = Record.readInt();
    1243           0 :     New = new (Context) NoInstrumentFunctionAttr(Range, Context, Spelling);
    1244           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1245           0 :     New->setImplicit(isImplicit);
    1246             :     break;
    1247             :   }
    1248             :   case attr::NoMicroMips: {
    1249           0 :     bool isInherited = Record.readInt();
    1250           0 :     bool isImplicit = Record.readInt();
    1251           0 :     unsigned Spelling = Record.readInt();
    1252           0 :     New = new (Context) NoMicroMipsAttr(Range, Context, Spelling);
    1253           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1254           0 :     New->setImplicit(isImplicit);
    1255             :     break;
    1256             :   }
    1257             :   case attr::NoMips16: {
    1258           0 :     bool isInherited = Record.readInt();
    1259           0 :     bool isImplicit = Record.readInt();
    1260           0 :     unsigned Spelling = Record.readInt();
    1261           0 :     New = new (Context) NoMips16Attr(Range, Context, Spelling);
    1262           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1263           0 :     New->setImplicit(isImplicit);
    1264             :     break;
    1265             :   }
    1266             :   case attr::NoReturn: {
    1267           0 :     bool isInherited = Record.readInt();
    1268           0 :     bool isImplicit = Record.readInt();
    1269           0 :     unsigned Spelling = Record.readInt();
    1270           0 :     New = new (Context) NoReturnAttr(Range, Context, Spelling);
    1271           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1272           0 :     New->setImplicit(isImplicit);
    1273             :     break;
    1274             :   }
    1275             :   case attr::NoSanitize: {
    1276           1 :     bool isInherited = Record.readInt();
    1277           1 :     bool isImplicit = Record.readInt();
    1278           1 :     unsigned Spelling = Record.readInt();
    1279           1 :     unsigned sanitizersSize = Record.readInt();
    1280             :     SmallVector<StringRef, 4> sanitizers;
    1281           1 :     sanitizers.reserve(sanitizersSize);
    1282           1 :     SmallVector<std::string, 4> sanitizersStorage;
    1283           1 :     sanitizersStorage.reserve(sanitizersSize);
    1284           5 :     for (unsigned i = 0; i != sanitizersSize; ++i)
    1285           4 :       sanitizersStorage.push_back(Record.readString());
    1286           5 :     for (unsigned i = 0; i != sanitizersSize; ++i)
    1287           6 :       sanitizers.push_back(sanitizersStorage[i]);
    1288           2 :     New = new (Context) NoSanitizeAttr(Range, Context, sanitizers.data(), sanitizersSize, Spelling);
    1289           1 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1290           1 :     New->setImplicit(isImplicit);
    1291             :     break;
    1292             :   }
    1293             :   case attr::NoSplitStack: {
    1294           0 :     bool isInherited = Record.readInt();
    1295           0 :     bool isImplicit = Record.readInt();
    1296           0 :     unsigned Spelling = Record.readInt();
    1297           0 :     New = new (Context) NoSplitStackAttr(Range, Context, Spelling);
    1298           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1299           0 :     New->setImplicit(isImplicit);
    1300             :     break;
    1301             :   }
    1302             :   case attr::NoStackProtector: {
    1303           0 :     bool isInherited = Record.readInt();
    1304           0 :     bool isImplicit = Record.readInt();
    1305           0 :     unsigned Spelling = Record.readInt();
    1306           0 :     New = new (Context) NoStackProtectorAttr(Range, Context, Spelling);
    1307           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1308           0 :     New->setImplicit(isImplicit);
    1309             :     break;
    1310             :   }
    1311             :   case attr::NoThreadSafetyAnalysis: {
    1312           0 :     bool isInherited = Record.readInt();
    1313           0 :     bool isImplicit = Record.readInt();
    1314           0 :     unsigned Spelling = Record.readInt();
    1315           0 :     New = new (Context) NoThreadSafetyAnalysisAttr(Range, Context, Spelling);
    1316           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1317           0 :     New->setImplicit(isImplicit);
    1318             :     break;
    1319             :   }
    1320             :   case attr::NoThrow: {
    1321          33 :     bool isInherited = Record.readInt();
    1322          33 :     bool isImplicit = Record.readInt();
    1323          33 :     unsigned Spelling = Record.readInt();
    1324          66 :     New = new (Context) NoThrowAttr(Range, Context, Spelling);
    1325          33 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1326          33 :     New->setImplicit(isImplicit);
    1327             :     break;
    1328             :   }
    1329             :   case attr::NonNull: {
    1330           2 :     bool isInherited = Record.readInt();
    1331           2 :     bool isImplicit = Record.readInt();
    1332           2 :     unsigned Spelling = Record.readInt();
    1333           2 :     unsigned argsSize = Record.readInt();
    1334             :     SmallVector<ParamIdx, 4> args;
    1335           2 :     args.reserve(argsSize);
    1336          10 :     for (unsigned i = 0; i != argsSize; ++i)
    1337           8 :       args.push_back(ParamIdx::deserialize(Record.readInt()));
    1338           4 :     New = new (Context) NonNullAttr(Range, Context, args.data(), argsSize, Spelling);
    1339           2 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1340           2 :     New->setImplicit(isImplicit);
    1341             :     break;
    1342             :   }
    1343             :   case attr::NotTailCalled: {
    1344           1 :     bool isInherited = Record.readInt();
    1345           1 :     bool isImplicit = Record.readInt();
    1346           1 :     unsigned Spelling = Record.readInt();
    1347           2 :     New = new (Context) NotTailCalledAttr(Range, Context, Spelling);
    1348           1 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1349           1 :     New->setImplicit(isImplicit);
    1350             :     break;
    1351             :   }
    1352             :   case attr::OMPCaptureKind: {
    1353        4610 :     bool isImplicit = Record.readInt();
    1354        4610 :     unsigned Spelling = Record.readInt();
    1355        4610 :     unsigned captureKind = Record.readInt();
    1356        9220 :     New = new (Context) OMPCaptureKindAttr(Range, Context, captureKind, Spelling);
    1357        4610 :     New->setImplicit(isImplicit);
    1358             :     break;
    1359             :   }
    1360             :   case attr::OMPCaptureNoInit: {
    1361          18 :     bool isInherited = Record.readInt();
    1362          18 :     bool isImplicit = Record.readInt();
    1363          18 :     unsigned Spelling = Record.readInt();
    1364          36 :     New = new (Context) OMPCaptureNoInitAttr(Range, Context, Spelling);
    1365          18 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1366          18 :     New->setImplicit(isImplicit);
    1367             :     break;
    1368             :   }
    1369             :   case attr::OMPDeclareSimdDecl: {
    1370         124 :     bool isImplicit = Record.readInt();
    1371         124 :     unsigned Spelling = Record.readInt();
    1372         124 :     OMPDeclareSimdDeclAttr::BranchStateTy branchState(static_cast<OMPDeclareSimdDeclAttr::BranchStateTy>(Record.readInt()));
    1373         124 :     Expr * simdlen = Record.readExpr();
    1374         124 :     unsigned uniformsSize = Record.readInt();
    1375             :     SmallVector<Expr *, 4> uniforms;
    1376         124 :     uniforms.reserve(uniformsSize);
    1377         196 :     for (unsigned i = 0; i != uniformsSize; ++i)
    1378          72 :       uniforms.push_back(Record.readExpr());
    1379         124 :     unsigned alignedsSize = Record.readInt();
    1380             :     SmallVector<Expr *, 4> aligneds;
    1381         124 :     aligneds.reserve(alignedsSize);
    1382         288 :     for (unsigned i = 0; i != alignedsSize; ++i)
    1383         164 :       aligneds.push_back(Record.readExpr());
    1384         124 :     unsigned alignmentsSize = Record.readInt();
    1385             :     SmallVector<Expr *, 4> alignments;
    1386         124 :     alignments.reserve(alignmentsSize);
    1387         288 :     for (unsigned i = 0; i != alignmentsSize; ++i)
    1388         164 :       alignments.push_back(Record.readExpr());
    1389         124 :     unsigned linearsSize = Record.readInt();
    1390             :     SmallVector<Expr *, 4> linears;
    1391         124 :     linears.reserve(linearsSize);
    1392         232 :     for (unsigned i = 0; i != linearsSize; ++i)
    1393         108 :       linears.push_back(Record.readExpr());
    1394         124 :     unsigned modifiersSize = Record.readInt();
    1395             :     SmallVector<unsigned, 4> modifiers;
    1396         124 :     modifiers.reserve(modifiersSize);
    1397         232 :     for (unsigned i = 0; i != modifiersSize; ++i)
    1398          54 :       modifiers.push_back(Record.readInt());
    1399         124 :     unsigned stepsSize = Record.readInt();
    1400             :     SmallVector<Expr *, 4> steps;
    1401         124 :     steps.reserve(stepsSize);
    1402         232 :     for (unsigned i = 0; i != stepsSize; ++i)
    1403         108 :       steps.push_back(Record.readExpr());
    1404         248 :     New = new (Context) OMPDeclareSimdDeclAttr(Range, Context, branchState, simdlen, uniforms.data(), uniformsSize, aligneds.data(), alignedsSize, alignments.data(), alignmentsSize, linears.data(), linearsSize, modifiers.data(), modifiersSize, steps.data(), stepsSize, Spelling);
    1405         124 :     New->setImplicit(isImplicit);
    1406             :     break;
    1407             :   }
    1408             :   case attr::OMPDeclareTargetDecl: {
    1409          74 :     bool isImplicit = Record.readInt();
    1410          74 :     unsigned Spelling = Record.readInt();
    1411          74 :     OMPDeclareTargetDeclAttr::MapTypeTy mapType(static_cast<OMPDeclareTargetDeclAttr::MapTypeTy>(Record.readInt()));
    1412         148 :     New = new (Context) OMPDeclareTargetDeclAttr(Range, Context, mapType, Spelling);
    1413          74 :     New->setImplicit(isImplicit);
    1414             :     break;
    1415             :   }
    1416             :   case attr::OMPReferencedVar: {
    1417        8094 :     bool isImplicit = Record.readInt();
    1418        8094 :     unsigned Spelling = Record.readInt();
    1419        8094 :     Expr * ref = Record.readExpr();
    1420       16188 :     New = new (Context) OMPReferencedVarAttr(Range, Context, ref, Spelling);
    1421        8094 :     New->setImplicit(isImplicit);
    1422             :     break;
    1423             :   }
    1424             :   case attr::OMPThreadPrivateDecl: {
    1425         162 :     bool isInherited = Record.readInt();
    1426         162 :     bool isImplicit = Record.readInt();
    1427         162 :     unsigned Spelling = Record.readInt();
    1428         324 :     New = new (Context) OMPThreadPrivateDeclAttr(Range, Context, Spelling);
    1429         162 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1430         162 :     New->setImplicit(isImplicit);
    1431             :     break;
    1432             :   }
    1433             :   case attr::ObjCBoxable: {
    1434           2 :     bool isImplicit = Record.readInt();
    1435           2 :     unsigned Spelling = Record.readInt();
    1436           4 :     New = new (Context) ObjCBoxableAttr(Range, Context, Spelling);
    1437           2 :     New->setImplicit(isImplicit);
    1438             :     break;
    1439             :   }
    1440             :   case attr::ObjCBridge: {
    1441           0 :     bool isInherited = Record.readInt();
    1442           0 :     bool isImplicit = Record.readInt();
    1443           0 :     unsigned Spelling = Record.readInt();
    1444             :     IdentifierInfo * bridgedType = Record.getIdentifierInfo();
    1445           0 :     New = new (Context) ObjCBridgeAttr(Range, Context, bridgedType, Spelling);
    1446           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1447           0 :     New->setImplicit(isImplicit);
    1448             :     break;
    1449             :   }
    1450             :   case attr::ObjCBridgeMutable: {
    1451           0 :     bool isInherited = Record.readInt();
    1452           0 :     bool isImplicit = Record.readInt();
    1453           0 :     unsigned Spelling = Record.readInt();
    1454             :     IdentifierInfo * bridgedType = Record.getIdentifierInfo();
    1455           0 :     New = new (Context) ObjCBridgeMutableAttr(Range, Context, bridgedType, Spelling);
    1456           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1457           0 :     New->setImplicit(isImplicit);
    1458             :     break;
    1459             :   }
    1460             :   case attr::ObjCBridgeRelated: {
    1461           0 :     bool isInherited = Record.readInt();
    1462           0 :     bool isImplicit = Record.readInt();
    1463           0 :     unsigned Spelling = Record.readInt();
    1464             :     IdentifierInfo * relatedClass = Record.getIdentifierInfo();
    1465             :     IdentifierInfo * classMethod = Record.getIdentifierInfo();
    1466             :     IdentifierInfo * instanceMethod = Record.getIdentifierInfo();
    1467           0 :     New = new (Context) ObjCBridgeRelatedAttr(Range, Context, relatedClass, classMethod, instanceMethod, Spelling);
    1468           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1469           0 :     New->setImplicit(isImplicit);
    1470             :     break;
    1471             :   }
    1472             :   case attr::ObjCDesignatedInitializer: {
    1473           1 :     bool isImplicit = Record.readInt();
    1474           1 :     unsigned Spelling = Record.readInt();
    1475           2 :     New = new (Context) ObjCDesignatedInitializerAttr(Range, Context, Spelling);
    1476           1 :     New->setImplicit(isImplicit);
    1477             :     break;
    1478             :   }
    1479             :   case attr::ObjCException: {
    1480           0 :     bool isInherited = Record.readInt();
    1481           0 :     bool isImplicit = Record.readInt();
    1482           0 :     unsigned Spelling = Record.readInt();
    1483           0 :     New = new (Context) ObjCExceptionAttr(Range, Context, Spelling);
    1484           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1485           0 :     New->setImplicit(isImplicit);
    1486             :     break;
    1487             :   }
    1488             :   case attr::ObjCExplicitProtocolImpl: {
    1489           0 :     bool isInherited = Record.readInt();
    1490           0 :     bool isImplicit = Record.readInt();
    1491           0 :     unsigned Spelling = Record.readInt();
    1492           0 :     New = new (Context) ObjCExplicitProtocolImplAttr(Range, Context, Spelling);
    1493           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1494           0 :     New->setImplicit(isImplicit);
    1495             :     break;
    1496             :   }
    1497             :   case attr::ObjCIndependentClass: {
    1498           0 :     bool isInherited = Record.readInt();
    1499           0 :     bool isImplicit = Record.readInt();
    1500           0 :     unsigned Spelling = Record.readInt();
    1501           0 :     New = new (Context) ObjCIndependentClassAttr(Range, Context, Spelling);
    1502           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1503           0 :     New->setImplicit(isImplicit);
    1504             :     break;
    1505             :   }
    1506             :   case attr::ObjCMethodFamily: {
    1507           0 :     bool isInherited = Record.readInt();
    1508           0 :     bool isImplicit = Record.readInt();
    1509           0 :     unsigned Spelling = Record.readInt();
    1510           0 :     ObjCMethodFamilyAttr::FamilyKind family(static_cast<ObjCMethodFamilyAttr::FamilyKind>(Record.readInt()));
    1511           0 :     New = new (Context) ObjCMethodFamilyAttr(Range, Context, family, Spelling);
    1512           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1513           0 :     New->setImplicit(isImplicit);
    1514             :     break;
    1515             :   }
    1516             :   case attr::ObjCNSObject: {
    1517           0 :     bool isInherited = Record.readInt();
    1518           0 :     bool isImplicit = Record.readInt();
    1519           0 :     unsigned Spelling = Record.readInt();
    1520           0 :     New = new (Context) ObjCNSObjectAttr(Range, Context, Spelling);
    1521           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1522           0 :     New->setImplicit(isImplicit);
    1523             :     break;
    1524             :   }
    1525             :   case attr::ObjCPreciseLifetime: {
    1526           0 :     bool isInherited = Record.readInt();
    1527           0 :     bool isImplicit = Record.readInt();
    1528           0 :     unsigned Spelling = Record.readInt();
    1529           0 :     New = new (Context) ObjCPreciseLifetimeAttr(Range, Context, Spelling);
    1530           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1531           0 :     New->setImplicit(isImplicit);
    1532             :     break;
    1533             :   }
    1534             :   case attr::ObjCRequiresPropertyDefs: {
    1535           0 :     bool isInherited = Record.readInt();
    1536           0 :     bool isImplicit = Record.readInt();
    1537           0 :     unsigned Spelling = Record.readInt();
    1538           0 :     New = new (Context) ObjCRequiresPropertyDefsAttr(Range, Context, Spelling);
    1539           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1540           0 :     New->setImplicit(isImplicit);
    1541             :     break;
    1542             :   }
    1543             :   case attr::ObjCRequiresSuper: {
    1544           0 :     bool isInherited = Record.readInt();
    1545           0 :     bool isImplicit = Record.readInt();
    1546           0 :     unsigned Spelling = Record.readInt();
    1547           0 :     New = new (Context) ObjCRequiresSuperAttr(Range, Context, Spelling);
    1548           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1549           0 :     New->setImplicit(isImplicit);
    1550             :     break;
    1551             :   }
    1552             :   case attr::ObjCReturnsInnerPointer: {
    1553           0 :     bool isInherited = Record.readInt();
    1554           0 :     bool isImplicit = Record.readInt();
    1555           0 :     unsigned Spelling = Record.readInt();
    1556           0 :     New = new (Context) ObjCReturnsInnerPointerAttr(Range, Context, Spelling);
    1557           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1558           0 :     New->setImplicit(isImplicit);
    1559             :     break;
    1560             :   }
    1561             :   case attr::ObjCRootClass: {
    1562           2 :     bool isInherited = Record.readInt();
    1563           2 :     bool isImplicit = Record.readInt();
    1564           2 :     unsigned Spelling = Record.readInt();
    1565           4 :     New = new (Context) ObjCRootClassAttr(Range, Context, Spelling);
    1566           2 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1567           2 :     New->setImplicit(isImplicit);
    1568             :     break;
    1569             :   }
    1570             :   case attr::ObjCRuntimeName: {
    1571           0 :     bool isImplicit = Record.readInt();
    1572           0 :     unsigned Spelling = Record.readInt();
    1573             :     std::string metadataName= Record.readString();
    1574           0 :     New = new (Context) ObjCRuntimeNameAttr(Range, Context, metadataName, Spelling);
    1575           0 :     New->setImplicit(isImplicit);
    1576             :     break;
    1577             :   }
    1578             :   case attr::ObjCRuntimeVisible: {
    1579           0 :     bool isImplicit = Record.readInt();
    1580           0 :     unsigned Spelling = Record.readInt();
    1581           0 :     New = new (Context) ObjCRuntimeVisibleAttr(Range, Context, Spelling);
    1582           0 :     New->setImplicit(isImplicit);
    1583             :     break;
    1584             :   }
    1585             :   case attr::ObjCSubclassingRestricted: {
    1586           0 :     bool isInherited = Record.readInt();
    1587           0 :     bool isImplicit = Record.readInt();
    1588           0 :     unsigned Spelling = Record.readInt();
    1589           0 :     New = new (Context) ObjCSubclassingRestrictedAttr(Range, Context, Spelling);
    1590           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1591           0 :     New->setImplicit(isImplicit);
    1592             :     break;
    1593             :   }
    1594             :   case attr::OpenCLAccess: {
    1595         120 :     bool isImplicit = Record.readInt();
    1596         120 :     unsigned Spelling = Record.readInt();
    1597         240 :     New = new (Context) OpenCLAccessAttr(Range, Context, Spelling);
    1598         120 :     New->setImplicit(isImplicit);
    1599             :     break;
    1600             :   }
    1601             :   case attr::OpenCLIntelReqdSubGroupSize: {
    1602           0 :     bool isInherited = Record.readInt();
    1603           0 :     bool isImplicit = Record.readInt();
    1604           0 :     unsigned Spelling = Record.readInt();
    1605           0 :     unsigned subGroupSize = Record.readInt();
    1606           0 :     New = new (Context) OpenCLIntelReqdSubGroupSizeAttr(Range, Context, subGroupSize, Spelling);
    1607           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1608           0 :     New->setImplicit(isImplicit);
    1609             :     break;
    1610             :   }
    1611             :   case attr::OpenCLKernel: {
    1612           0 :     bool isInherited = Record.readInt();
    1613           0 :     bool isImplicit = Record.readInt();
    1614           0 :     unsigned Spelling = Record.readInt();
    1615           0 :     New = new (Context) OpenCLKernelAttr(Range, Context, Spelling);
    1616           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1617           0 :     New->setImplicit(isImplicit);
    1618             :     break;
    1619             :   }
    1620             :   case attr::OpenCLUnrollHint: {
    1621           0 :     bool isInherited = Record.readInt();
    1622           0 :     bool isImplicit = Record.readInt();
    1623           0 :     unsigned Spelling = Record.readInt();
    1624           0 :     unsigned unrollHint = Record.readInt();
    1625           0 :     New = new (Context) OpenCLUnrollHintAttr(Range, Context, unrollHint, Spelling);
    1626           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1627           0 :     New->setImplicit(isImplicit);
    1628             :     break;
    1629             :   }
    1630             :   case attr::OptimizeNone: {
    1631           0 :     bool isInherited = Record.readInt();
    1632           0 :     bool isImplicit = Record.readInt();
    1633           0 :     unsigned Spelling = Record.readInt();
    1634           0 :     New = new (Context) OptimizeNoneAttr(Range, Context, Spelling);
    1635           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1636           0 :     New->setImplicit(isImplicit);
    1637             :     break;
    1638             :   }
    1639             :   case attr::Overloadable: {
    1640         359 :     bool isImplicit = Record.readInt();
    1641         359 :     unsigned Spelling = Record.readInt();
    1642         718 :     New = new (Context) OverloadableAttr(Range, Context, Spelling);
    1643         359 :     New->setImplicit(isImplicit);
    1644             :     break;
    1645             :   }
    1646             :   case attr::Override: {
    1647           0 :     bool isInherited = Record.readInt();
    1648           0 :     bool isImplicit = Record.readInt();
    1649           0 :     unsigned Spelling = Record.readInt();
    1650           0 :     New = new (Context) OverrideAttr(Range, Context, Spelling);
    1651           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1652           0 :     New->setImplicit(isImplicit);
    1653             :     break;
    1654             :   }
    1655             :   case attr::Ownership: {
    1656           6 :     bool isInherited = Record.readInt();
    1657           6 :     bool isImplicit = Record.readInt();
    1658           6 :     unsigned Spelling = Record.readInt();
    1659             :     IdentifierInfo * module = Record.getIdentifierInfo();
    1660           6 :     unsigned argsSize = Record.readInt();
    1661             :     SmallVector<ParamIdx, 4> args;
    1662           6 :     args.reserve(argsSize);
    1663          26 :     for (unsigned i = 0; i != argsSize; ++i)
    1664          20 :       args.push_back(ParamIdx::deserialize(Record.readInt()));
    1665          12 :     New = new (Context) OwnershipAttr(Range, Context, module, args.data(), argsSize, Spelling);
    1666           6 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1667           6 :     New->setImplicit(isImplicit);
    1668             :     break;
    1669             :   }
    1670             :   case attr::Packed: {
    1671          41 :     bool isInherited = Record.readInt();
    1672          41 :     bool isImplicit = Record.readInt();
    1673          41 :     unsigned Spelling = Record.readInt();
    1674          82 :     New = new (Context) PackedAttr(Range, Context, Spelling);
    1675          41 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1676          41 :     New->setImplicit(isImplicit);
    1677             :     break;
    1678             :   }
    1679             :   case attr::ParamTypestate: {
    1680           0 :     bool isInherited = Record.readInt();
    1681           0 :     bool isImplicit = Record.readInt();
    1682           0 :     unsigned Spelling = Record.readInt();
    1683           0 :     ParamTypestateAttr::ConsumedState paramState(static_cast<ParamTypestateAttr::ConsumedState>(Record.readInt()));
    1684           0 :     New = new (Context) ParamTypestateAttr(Range, Context, paramState, Spelling);
    1685           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1686           0 :     New->setImplicit(isImplicit);
    1687             :     break;
    1688             :   }
    1689             :   case attr::Pascal: {
    1690           0 :     bool isInherited = Record.readInt();
    1691           0 :     bool isImplicit = Record.readInt();
    1692           0 :     unsigned Spelling = Record.readInt();
    1693           0 :     New = new (Context) PascalAttr(Range, Context, Spelling);
    1694           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1695           0 :     New->setImplicit(isImplicit);
    1696             :     break;
    1697             :   }
    1698             :   case attr::PassObjectSize: {
    1699           2 :     bool isInherited = Record.readInt();
    1700           2 :     bool isImplicit = Record.readInt();
    1701           2 :     unsigned Spelling = Record.readInt();
    1702           2 :     int type = Record.readInt();
    1703           4 :     New = new (Context) PassObjectSizeAttr(Range, Context, type, Spelling);
    1704           2 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1705           2 :     New->setImplicit(isImplicit);
    1706             :     break;
    1707             :   }
    1708             :   case attr::Pcs: {
    1709           0 :     bool isInherited = Record.readInt();
    1710           0 :     bool isImplicit = Record.readInt();
    1711           0 :     unsigned Spelling = Record.readInt();
    1712           0 :     PcsAttr::PCSType pCS(static_cast<PcsAttr::PCSType>(Record.readInt()));
    1713           0 :     New = new (Context) PcsAttr(Range, Context, pCS, Spelling);
    1714           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1715           0 :     New->setImplicit(isImplicit);
    1716             :     break;
    1717             :   }
    1718             :   case attr::PragmaClangBSSSection: {
    1719           0 :     bool isInherited = Record.readInt();
    1720           0 :     bool isImplicit = Record.readInt();
    1721           0 :     unsigned Spelling = Record.readInt();
    1722             :     std::string name= Record.readString();
    1723           0 :     New = new (Context) PragmaClangBSSSectionAttr(Range, Context, name, Spelling);
    1724           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1725           0 :     New->setImplicit(isImplicit);
    1726             :     break;
    1727             :   }
    1728             :   case attr::PragmaClangDataSection: {
    1729           0 :     bool isInherited = Record.readInt();
    1730           0 :     bool isImplicit = Record.readInt();
    1731           0 :     unsigned Spelling = Record.readInt();
    1732             :     std::string name= Record.readString();
    1733           0 :     New = new (Context) PragmaClangDataSectionAttr(Range, Context, name, Spelling);
    1734           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1735           0 :     New->setImplicit(isImplicit);
    1736             :     break;
    1737             :   }
    1738             :   case attr::PragmaClangRodataSection: {
    1739           0 :     bool isInherited = Record.readInt();
    1740           0 :     bool isImplicit = Record.readInt();
    1741           0 :     unsigned Spelling = Record.readInt();
    1742             :     std::string name= Record.readString();
    1743           0 :     New = new (Context) PragmaClangRodataSectionAttr(Range, Context, name, Spelling);
    1744           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1745           0 :     New->setImplicit(isImplicit);
    1746             :     break;
    1747             :   }
    1748             :   case attr::PragmaClangTextSection: {
    1749           0 :     bool isInherited = Record.readInt();
    1750           0 :     bool isImplicit = Record.readInt();
    1751           0 :     unsigned Spelling = Record.readInt();
    1752             :     std::string name= Record.readString();
    1753           0 :     New = new (Context) PragmaClangTextSectionAttr(Range, Context, name, Spelling);
    1754           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1755           0 :     New->setImplicit(isImplicit);
    1756             :     break;
    1757             :   }
    1758             :   case attr::PreserveAll: {
    1759           0 :     bool isInherited = Record.readInt();
    1760           0 :     bool isImplicit = Record.readInt();
    1761           0 :     unsigned Spelling = Record.readInt();
    1762           0 :     New = new (Context) PreserveAllAttr(Range, Context, Spelling);
    1763           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1764           0 :     New->setImplicit(isImplicit);
    1765             :     break;
    1766             :   }
    1767             :   case attr::PreserveMost: {
    1768           0 :     bool isInherited = Record.readInt();
    1769           0 :     bool isImplicit = Record.readInt();
    1770           0 :     unsigned Spelling = Record.readInt();
    1771           0 :     New = new (Context) PreserveMostAttr(Range, Context, Spelling);
    1772           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1773           0 :     New->setImplicit(isImplicit);
    1774             :     break;
    1775             :   }
    1776             :   case attr::PtGuardedBy: {
    1777           0 :     bool isInherited = Record.readInt();
    1778           0 :     bool isImplicit = Record.readInt();
    1779           0 :     unsigned Spelling = Record.readInt();
    1780           0 :     Expr * arg = Record.readExpr();
    1781           0 :     New = new (Context) PtGuardedByAttr(Range, Context, arg, Spelling);
    1782           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1783           0 :     New->setImplicit(isImplicit);
    1784             :     break;
    1785             :   }
    1786             :   case attr::PtGuardedVar: {
    1787           0 :     bool isInherited = Record.readInt();
    1788           0 :     bool isImplicit = Record.readInt();
    1789           0 :     unsigned Spelling = Record.readInt();
    1790           0 :     New = new (Context) PtGuardedVarAttr(Range, Context, Spelling);
    1791           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1792           0 :     New->setImplicit(isImplicit);
    1793             :     break;
    1794             :   }
    1795             :   case attr::Pure: {
    1796           0 :     bool isInherited = Record.readInt();
    1797           0 :     bool isImplicit = Record.readInt();
    1798           0 :     unsigned Spelling = Record.readInt();
    1799           0 :     New = new (Context) PureAttr(Range, Context, Spelling);
    1800           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1801           0 :     New->setImplicit(isImplicit);
    1802             :     break;
    1803             :   }
    1804             :   case attr::RegCall: {
    1805           0 :     bool isInherited = Record.readInt();
    1806           0 :     bool isImplicit = Record.readInt();
    1807           0 :     unsigned Spelling = Record.readInt();
    1808           0 :     New = new (Context) RegCallAttr(Range, Context, Spelling);
    1809           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1810           0 :     New->setImplicit(isImplicit);
    1811             :     break;
    1812             :   }
    1813             :   case attr::ReleaseCapability: {
    1814           4 :     bool isInherited = Record.readInt();
    1815           4 :     bool isImplicit = Record.readInt();
    1816           4 :     unsigned Spelling = Record.readInt();
    1817           4 :     unsigned argsSize = Record.readInt();
    1818             :     SmallVector<Expr *, 4> args;
    1819           4 :     args.reserve(argsSize);
    1820           6 :     for (unsigned i = 0; i != argsSize; ++i)
    1821           2 :       args.push_back(Record.readExpr());
    1822           8 :     New = new (Context) ReleaseCapabilityAttr(Range, Context, args.data(), argsSize, Spelling);
    1823           4 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1824           4 :     New->setImplicit(isImplicit);
    1825             :     break;
    1826             :   }
    1827             :   case attr::RenderScriptKernel: {
    1828           0 :     bool isImplicit = Record.readInt();
    1829           0 :     unsigned Spelling = Record.readInt();
    1830           0 :     New = new (Context) RenderScriptKernelAttr(Range, Context, Spelling);
    1831           0 :     New->setImplicit(isImplicit);
    1832             :     break;
    1833             :   }
    1834             :   case attr::ReqdWorkGroupSize: {
    1835           0 :     bool isInherited = Record.readInt();
    1836           0 :     bool isImplicit = Record.readInt();
    1837           0 :     unsigned Spelling = Record.readInt();
    1838           0 :     unsigned xDim = Record.readInt();
    1839           0 :     unsigned yDim = Record.readInt();
    1840           0 :     unsigned zDim = Record.readInt();
    1841           0 :     New = new (Context) ReqdWorkGroupSizeAttr(Range, Context, xDim, yDim, zDim, Spelling);
    1842           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1843           0 :     New->setImplicit(isImplicit);
    1844             :     break;
    1845             :   }
    1846             :   case attr::RequireConstantInit: {
    1847           0 :     bool isInherited = Record.readInt();
    1848           0 :     bool isImplicit = Record.readInt();
    1849           0 :     unsigned Spelling = Record.readInt();
    1850           0 :     New = new (Context) RequireConstantInitAttr(Range, Context, Spelling);
    1851           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1852           0 :     New->setImplicit(isImplicit);
    1853             :     break;
    1854             :   }
    1855             :   case attr::RequiresCapability: {
    1856           0 :     bool isInherited = Record.readInt();
    1857           0 :     bool isImplicit = Record.readInt();
    1858           0 :     unsigned Spelling = Record.readInt();
    1859           0 :     unsigned argsSize = Record.readInt();
    1860             :     SmallVector<Expr *, 4> args;
    1861           0 :     args.reserve(argsSize);
    1862           0 :     for (unsigned i = 0; i != argsSize; ++i)
    1863           0 :       args.push_back(Record.readExpr());
    1864           0 :     New = new (Context) RequiresCapabilityAttr(Range, Context, args.data(), argsSize, Spelling);
    1865           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1866           0 :     New->setImplicit(isImplicit);
    1867             :     break;
    1868             :   }
    1869             :   case attr::Restrict: {
    1870           0 :     bool isInherited = Record.readInt();
    1871           0 :     bool isImplicit = Record.readInt();
    1872           0 :     unsigned Spelling = Record.readInt();
    1873           0 :     New = new (Context) RestrictAttr(Range, Context, Spelling);
    1874           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1875           0 :     New->setImplicit(isImplicit);
    1876             :     break;
    1877             :   }
    1878             :   case attr::ReturnTypestate: {
    1879           0 :     bool isInherited = Record.readInt();
    1880           0 :     bool isImplicit = Record.readInt();
    1881           0 :     unsigned Spelling = Record.readInt();
    1882           0 :     ReturnTypestateAttr::ConsumedState state(static_cast<ReturnTypestateAttr::ConsumedState>(Record.readInt()));
    1883           0 :     New = new (Context) ReturnTypestateAttr(Range, Context, state, Spelling);
    1884           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1885           0 :     New->setImplicit(isImplicit);
    1886             :     break;
    1887             :   }
    1888             :   case attr::ReturnsNonNull: {
    1889           0 :     bool isInherited = Record.readInt();
    1890           0 :     bool isImplicit = Record.readInt();
    1891           0 :     unsigned Spelling = Record.readInt();
    1892           0 :     New = new (Context) ReturnsNonNullAttr(Range, Context, Spelling);
    1893           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1894           0 :     New->setImplicit(isImplicit);
    1895             :     break;
    1896             :   }
    1897             :   case attr::ReturnsTwice: {
    1898           0 :     bool isInherited = Record.readInt();
    1899           0 :     bool isImplicit = Record.readInt();
    1900           0 :     unsigned Spelling = Record.readInt();
    1901           0 :     New = new (Context) ReturnsTwiceAttr(Range, Context, Spelling);
    1902           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1903           0 :     New->setImplicit(isImplicit);
    1904             :     break;
    1905             :   }
    1906             :   case attr::ScopedLockable: {
    1907           0 :     bool isInherited = Record.readInt();
    1908           0 :     bool isImplicit = Record.readInt();
    1909           0 :     unsigned Spelling = Record.readInt();
    1910           0 :     New = new (Context) ScopedLockableAttr(Range, Context, Spelling);
    1911           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1912           0 :     New->setImplicit(isImplicit);
    1913             :     break;
    1914             :   }
    1915             :   case attr::Section: {
    1916           0 :     bool isInherited = Record.readInt();
    1917           0 :     bool isImplicit = Record.readInt();
    1918           0 :     unsigned Spelling = Record.readInt();
    1919             :     std::string name= Record.readString();
    1920           0 :     New = new (Context) SectionAttr(Range, Context, name, Spelling);
    1921           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1922           0 :     New->setImplicit(isImplicit);
    1923             :     break;
    1924             :   }
    1925             :   case attr::SelectAny: {
    1926           0 :     bool isInherited = Record.readInt();
    1927           0 :     bool isImplicit = Record.readInt();
    1928           0 :     unsigned Spelling = Record.readInt();
    1929           0 :     New = new (Context) SelectAnyAttr(Range, Context, Spelling);
    1930           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1931           0 :     New->setImplicit(isImplicit);
    1932             :     break;
    1933             :   }
    1934             :   case attr::Sentinel: {
    1935           0 :     bool isInherited = Record.readInt();
    1936           0 :     bool isImplicit = Record.readInt();
    1937           0 :     unsigned Spelling = Record.readInt();
    1938           0 :     int sentinel = Record.readInt();
    1939           0 :     int nullPos = Record.readInt();
    1940           0 :     New = new (Context) SentinelAttr(Range, Context, sentinel, nullPos, Spelling);
    1941           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1942           0 :     New->setImplicit(isImplicit);
    1943             :     break;
    1944             :   }
    1945             :   case attr::SetTypestate: {
    1946           0 :     bool isInherited = Record.readInt();
    1947           0 :     bool isImplicit = Record.readInt();
    1948           0 :     unsigned Spelling = Record.readInt();
    1949           0 :     SetTypestateAttr::ConsumedState newState(static_cast<SetTypestateAttr::ConsumedState>(Record.readInt()));
    1950           0 :     New = new (Context) SetTypestateAttr(Range, Context, newState, Spelling);
    1951           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1952           0 :     New->setImplicit(isImplicit);
    1953             :     break;
    1954             :   }
    1955             :   case attr::SharedTrylockFunction: {
    1956           0 :     bool isInherited = Record.readInt();
    1957           0 :     bool isImplicit = Record.readInt();
    1958           0 :     unsigned Spelling = Record.readInt();
    1959           0 :     Expr * successValue = Record.readExpr();
    1960           0 :     unsigned argsSize = Record.readInt();
    1961             :     SmallVector<Expr *, 4> args;
    1962           0 :     args.reserve(argsSize);
    1963           0 :     for (unsigned i = 0; i != argsSize; ++i)
    1964           0 :       args.push_back(Record.readExpr());
    1965           0 :     New = new (Context) SharedTrylockFunctionAttr(Range, Context, successValue, args.data(), argsSize, Spelling);
    1966           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1967           0 :     New->setImplicit(isImplicit);
    1968             :     break;
    1969             :   }
    1970             :   case attr::StdCall: {
    1971           0 :     bool isInherited = Record.readInt();
    1972           0 :     bool isImplicit = Record.readInt();
    1973           0 :     unsigned Spelling = Record.readInt();
    1974           0 :     New = new (Context) StdCallAttr(Range, Context, Spelling);
    1975           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    1976           0 :     New->setImplicit(isImplicit);
    1977             :     break;
    1978             :   }
    1979             :   case attr::Suppress: {
    1980           0 :     bool isImplicit = Record.readInt();
    1981           0 :     unsigned Spelling = Record.readInt();
    1982           0 :     unsigned diagnosticIdentifiersSize = Record.readInt();
    1983             :     SmallVector<StringRef, 4> diagnosticIdentifiers;
    1984           0 :     diagnosticIdentifiers.reserve(diagnosticIdentifiersSize);
    1985           0 :     SmallVector<std::string, 4> diagnosticIdentifiersStorage;
    1986           0 :     diagnosticIdentifiersStorage.reserve(diagnosticIdentifiersSize);
    1987           0 :     for (unsigned i = 0; i != diagnosticIdentifiersSize; ++i)
    1988           0 :       diagnosticIdentifiersStorage.push_back(Record.readString());
    1989           0 :     for (unsigned i = 0; i != diagnosticIdentifiersSize; ++i)
    1990           0 :       diagnosticIdentifiers.push_back(diagnosticIdentifiersStorage[i]);
    1991           0 :     New = new (Context) SuppressAttr(Range, Context, diagnosticIdentifiers.data(), diagnosticIdentifiersSize, Spelling);
    1992           0 :     New->setImplicit(isImplicit);
    1993             :     break;
    1994             :   }
    1995             :   case attr::SwiftCall: {
    1996           0 :     bool isInherited = Record.readInt();
    1997           0 :     bool isImplicit = Record.readInt();
    1998           0 :     unsigned Spelling = Record.readInt();
    1999           0 :     New = new (Context) SwiftCallAttr(Range, Context, Spelling);
    2000           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    2001           0 :     New->setImplicit(isImplicit);
    2002             :     break;
    2003             :   }
    2004             :   case attr::SwiftContext: {
    2005           0 :     bool isInherited = Record.readInt();
    2006           0 :     bool isImplicit = Record.readInt();
    2007           0 :     unsigned Spelling = Record.readInt();
    2008           0 :     New = new (Context) SwiftContextAttr(Range, Context, Spelling);
    2009           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    2010           0 :     New->setImplicit(isImplicit);
    2011             :     break;
    2012             :   }
    2013             :   case attr::SwiftErrorResult: {
    2014           0 :     bool isInherited = Record.readInt();
    2015           0 :     bool isImplicit = Record.readInt();
    2016           0 :     unsigned Spelling = Record.readInt();
    2017           0 :     New = new (Context) SwiftErrorResultAttr(Range, Context, Spelling);
    2018           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    2019           0 :     New->setImplicit(isImplicit);
    2020             :     break;
    2021             :   }
    2022             :   case attr::SwiftIndirectResult: {
    2023           0 :     bool isInherited = Record.readInt();
    2024           0 :     bool isImplicit = Record.readInt();
    2025           0 :     unsigned Spelling = Record.readInt();
    2026           0 :     New = new (Context) SwiftIndirectResultAttr(Range, Context, Spelling);
    2027           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    2028           0 :     New->setImplicit(isImplicit);
    2029             :     break;
    2030             :   }
    2031             :   case attr::SysVABI: {
    2032           0 :     bool isInherited = Record.readInt();
    2033           0 :     bool isImplicit = Record.readInt();
    2034           0 :     unsigned Spelling = Record.readInt();
    2035           0 :     New = new (Context) SysVABIAttr(Range, Context, Spelling);
    2036           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    2037           0 :     New->setImplicit(isImplicit);
    2038             :     break;
    2039             :   }
    2040             :   case attr::TLSModel: {
    2041           0 :     bool isInherited = Record.readInt();
    2042           0 :     bool isImplicit = Record.readInt();
    2043           0 :     unsigned Spelling = Record.readInt();
    2044             :     std::string model= Record.readString();
    2045           0 :     New = new (Context) TLSModelAttr(Range, Context, model, Spelling);
    2046           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    2047           0 :     New->setImplicit(isImplicit);
    2048             :     break;
    2049             :   }
    2050             :   case attr::Target: {
    2051           9 :     bool isInherited = Record.readInt();
    2052           9 :     bool isImplicit = Record.readInt();
    2053           9 :     unsigned Spelling = Record.readInt();
    2054             :     std::string featuresStr= Record.readString();
    2055          18 :     New = new (Context) TargetAttr(Range, Context, featuresStr, Spelling);
    2056           9 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    2057           9 :     New->setImplicit(isImplicit);
    2058             :     break;
    2059             :   }
    2060             :   case attr::TestTypestate: {
    2061           0 :     bool isInherited = Record.readInt();
    2062           0 :     bool isImplicit = Record.readInt();
    2063           0 :     unsigned Spelling = Record.readInt();
    2064           0 :     TestTypestateAttr::ConsumedState testState(static_cast<TestTypestateAttr::ConsumedState>(Record.readInt()));
    2065           0 :     New = new (Context) TestTypestateAttr(Range, Context, testState, Spelling);
    2066           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    2067           0 :     New->setImplicit(isImplicit);
    2068             :     break;
    2069             :   }
    2070             :   case attr::ThisCall: {
    2071           0 :     bool isInherited = Record.readInt();
    2072           0 :     bool isImplicit = Record.readInt();
    2073           0 :     unsigned Spelling = Record.readInt();
    2074           0 :     New = new (Context) ThisCallAttr(Range, Context, Spelling);
    2075           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    2076           0 :     New->setImplicit(isImplicit);
    2077             :     break;
    2078             :   }
    2079             :   case attr::Thread: {
    2080           0 :     bool isImplicit = Record.readInt();
    2081           0 :     unsigned Spelling = Record.readInt();
    2082           0 :     New = new (Context) ThreadAttr(Range, Context, Spelling);
    2083           0 :     New->setImplicit(isImplicit);
    2084             :     break;
    2085             :   }
    2086             :   case attr::TransparentUnion: {
    2087           0 :     bool isInherited = Record.readInt();
    2088           0 :     bool isImplicit = Record.readInt();
    2089           0 :     unsigned Spelling = Record.readInt();
    2090           0 :     New = new (Context) TransparentUnionAttr(Range, Context, Spelling);
    2091           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    2092           0 :     New->setImplicit(isImplicit);
    2093             :     break;
    2094             :   }
    2095             :   case attr::TrivialABI: {
    2096           0 :     bool isInherited = Record.readInt();
    2097           0 :     bool isImplicit = Record.readInt();
    2098           0 :     unsigned Spelling = Record.readInt();
    2099           0 :     New = new (Context) TrivialABIAttr(Range, Context, Spelling);
    2100           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    2101           0 :     New->setImplicit(isImplicit);
    2102             :     break;
    2103             :   }
    2104             :   case attr::TryAcquireCapability: {
    2105           0 :     bool isInherited = Record.readInt();
    2106           0 :     bool isImplicit = Record.readInt();
    2107           0 :     unsigned Spelling = Record.readInt();
    2108           0 :     Expr * successValue = Record.readExpr();
    2109           0 :     unsigned argsSize = Record.readInt();
    2110             :     SmallVector<Expr *, 4> args;
    2111           0 :     args.reserve(argsSize);
    2112           0 :     for (unsigned i = 0; i != argsSize; ++i)
    2113           0 :       args.push_back(Record.readExpr());
    2114           0 :     New = new (Context) TryAcquireCapabilityAttr(Range, Context, successValue, args.data(), argsSize, Spelling);
    2115           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    2116           0 :     New->setImplicit(isImplicit);
    2117             :     break;
    2118             :   }
    2119             :   case attr::TypeTagForDatatype: {
    2120           0 :     bool isInherited = Record.readInt();
    2121           0 :     bool isImplicit = Record.readInt();
    2122           0 :     unsigned Spelling = Record.readInt();
    2123             :     IdentifierInfo * argumentKind = Record.getIdentifierInfo();
    2124             :     TypeSourceInfo * matchingCType = Record.getTypeSourceInfo();
    2125           0 :     bool layoutCompatible = Record.readInt();
    2126           0 :     bool mustBeNull = Record.readInt();
    2127           0 :     New = new (Context) TypeTagForDatatypeAttr(Range, Context, argumentKind, matchingCType, layoutCompatible, mustBeNull, Spelling);
    2128           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    2129           0 :     New->setImplicit(isImplicit);
    2130             :     break;
    2131             :   }
    2132             :   case attr::TypeVisibility: {
    2133           9 :     bool isInherited = Record.readInt();
    2134           9 :     bool isImplicit = Record.readInt();
    2135           9 :     unsigned Spelling = Record.readInt();
    2136           9 :     TypeVisibilityAttr::VisibilityType visibility(static_cast<TypeVisibilityAttr::VisibilityType>(Record.readInt()));
    2137          18 :     New = new (Context) TypeVisibilityAttr(Range, Context, visibility, Spelling);
    2138           9 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    2139           9 :     New->setImplicit(isImplicit);
    2140             :     break;
    2141             :   }
    2142             :   case attr::Unavailable: {
    2143           8 :     bool isInherited = Record.readInt();
    2144           8 :     bool isImplicit = Record.readInt();
    2145           8 :     unsigned Spelling = Record.readInt();
    2146             :     std::string message= Record.readString();
    2147           8 :     UnavailableAttr::ImplicitReason implicitReason(static_cast<UnavailableAttr::ImplicitReason>(Record.readInt()));
    2148          16 :     New = new (Context) UnavailableAttr(Range, Context, message, implicitReason, Spelling);
    2149           8 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    2150           8 :     New->setImplicit(isImplicit);
    2151             :     break;
    2152             :   }
    2153             :   case attr::Unused: {
    2154           0 :     bool isInherited = Record.readInt();
    2155           0 :     bool isImplicit = Record.readInt();
    2156           0 :     unsigned Spelling = Record.readInt();
    2157           0 :     New = new (Context) UnusedAttr(Range, Context, Spelling);
    2158           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    2159           0 :     New->setImplicit(isImplicit);
    2160             :     break;
    2161             :   }
    2162             :   case attr::Used: {
    2163           0 :     bool isInherited = Record.readInt();
    2164           0 :     bool isImplicit = Record.readInt();
    2165           0 :     unsigned Spelling = Record.readInt();
    2166           0 :     New = new (Context) UsedAttr(Range, Context, Spelling);
    2167           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    2168           0 :     New->setImplicit(isImplicit);
    2169             :     break;
    2170             :   }
    2171             :   case attr::Uuid: {
    2172           0 :     bool isInherited = Record.readInt();
    2173           0 :     bool isImplicit = Record.readInt();
    2174           0 :     unsigned Spelling = Record.readInt();
    2175             :     std::string guid= Record.readString();
    2176           0 :     New = new (Context) UuidAttr(Range, Context, guid, Spelling);
    2177           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    2178           0 :     New->setImplicit(isImplicit);
    2179             :     break;
    2180             :   }
    2181             :   case attr::VecReturn: {
    2182           0 :     bool isInherited = Record.readInt();
    2183           0 :     bool isImplicit = Record.readInt();
    2184           0 :     unsigned Spelling = Record.readInt();
    2185           0 :     New = new (Context) VecReturnAttr(Range, Context, Spelling);
    2186           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    2187           0 :     New->setImplicit(isImplicit);
    2188             :     break;
    2189             :   }
    2190             :   case attr::VecTypeHint: {
    2191           0 :     bool isInherited = Record.readInt();
    2192           0 :     bool isImplicit = Record.readInt();
    2193           0 :     unsigned Spelling = Record.readInt();
    2194             :     TypeSourceInfo * typeHint = Record.getTypeSourceInfo();
    2195           0 :     New = new (Context) VecTypeHintAttr(Range, Context, typeHint, Spelling);
    2196           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    2197           0 :     New->setImplicit(isImplicit);
    2198             :     break;
    2199             :   }
    2200             :   case attr::VectorCall: {
    2201           0 :     bool isInherited = Record.readInt();
    2202           0 :     bool isImplicit = Record.readInt();
    2203           0 :     unsigned Spelling = Record.readInt();
    2204           0 :     New = new (Context) VectorCallAttr(Range, Context, Spelling);
    2205           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    2206           0 :     New->setImplicit(isImplicit);
    2207             :     break;
    2208             :   }
    2209             :   case attr::Visibility: {
    2210          62 :     bool isInherited = Record.readInt();
    2211          62 :     bool isImplicit = Record.readInt();
    2212          62 :     unsigned Spelling = Record.readInt();
    2213          62 :     VisibilityAttr::VisibilityType visibility(static_cast<VisibilityAttr::VisibilityType>(Record.readInt()));
    2214         124 :     New = new (Context) VisibilityAttr(Range, Context, visibility, Spelling);
    2215          62 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    2216          62 :     New->setImplicit(isImplicit);
    2217             :     break;
    2218             :   }
    2219             :   case attr::WarnUnused: {
    2220           0 :     bool isInherited = Record.readInt();
    2221           0 :     bool isImplicit = Record.readInt();
    2222           0 :     unsigned Spelling = Record.readInt();
    2223           0 :     New = new (Context) WarnUnusedAttr(Range, Context, Spelling);
    2224           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    2225           0 :     New->setImplicit(isImplicit);
    2226             :     break;
    2227             :   }
    2228             :   case attr::WarnUnusedResult: {
    2229           0 :     bool isInherited = Record.readInt();
    2230           0 :     bool isImplicit = Record.readInt();
    2231           0 :     unsigned Spelling = Record.readInt();
    2232           0 :     New = new (Context) WarnUnusedResultAttr(Range, Context, Spelling);
    2233           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    2234           0 :     New->setImplicit(isImplicit);
    2235             :     break;
    2236             :   }
    2237             :   case attr::Weak: {
    2238         140 :     bool isInherited = Record.readInt();
    2239         140 :     bool isImplicit = Record.readInt();
    2240         140 :     unsigned Spelling = Record.readInt();
    2241         280 :     New = new (Context) WeakAttr(Range, Context, Spelling);
    2242         140 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    2243         140 :     New->setImplicit(isImplicit);
    2244             :     break;
    2245             :   }
    2246             :   case attr::WeakImport: {
    2247           0 :     bool isInherited = Record.readInt();
    2248           0 :     bool isImplicit = Record.readInt();
    2249           0 :     unsigned Spelling = Record.readInt();
    2250           0 :     New = new (Context) WeakImportAttr(Range, Context, Spelling);
    2251           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    2252           0 :     New->setImplicit(isImplicit);
    2253             :     break;
    2254             :   }
    2255             :   case attr::WeakRef: {
    2256           0 :     bool isInherited = Record.readInt();
    2257           0 :     bool isImplicit = Record.readInt();
    2258           0 :     unsigned Spelling = Record.readInt();
    2259             :     std::string aliasee= Record.readString();
    2260           0 :     New = new (Context) WeakRefAttr(Range, Context, aliasee, Spelling);
    2261           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    2262           0 :     New->setImplicit(isImplicit);
    2263             :     break;
    2264             :   }
    2265             :   case attr::WorkGroupSizeHint: {
    2266           0 :     bool isInherited = Record.readInt();
    2267           0 :     bool isImplicit = Record.readInt();
    2268           0 :     unsigned Spelling = Record.readInt();
    2269           0 :     unsigned xDim = Record.readInt();
    2270           0 :     unsigned yDim = Record.readInt();
    2271           0 :     unsigned zDim = Record.readInt();
    2272           0 :     New = new (Context) WorkGroupSizeHintAttr(Range, Context, xDim, yDim, zDim, Spelling);
    2273           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    2274           0 :     New->setImplicit(isImplicit);
    2275             :     break;
    2276             :   }
    2277             :   case attr::X86ForceAlignArgPointer: {
    2278           0 :     bool isInherited = Record.readInt();
    2279           0 :     bool isImplicit = Record.readInt();
    2280           0 :     unsigned Spelling = Record.readInt();
    2281           0 :     New = new (Context) X86ForceAlignArgPointerAttr(Range, Context, Spelling);
    2282           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    2283           0 :     New->setImplicit(isImplicit);
    2284             :     break;
    2285             :   }
    2286             :   case attr::XRayInstrument: {
    2287           0 :     bool isInherited = Record.readInt();
    2288           0 :     bool isImplicit = Record.readInt();
    2289           0 :     unsigned Spelling = Record.readInt();
    2290           0 :     New = new (Context) XRayInstrumentAttr(Range, Context, Spelling);
    2291           0 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    2292           0 :     New->setImplicit(isImplicit);
    2293             :     break;
    2294             :   }
    2295             :   case attr::XRayLogArgs: {
    2296           2 :     bool isInherited = Record.readInt();
    2297           2 :     bool isImplicit = Record.readInt();
    2298           2 :     unsigned Spelling = Record.readInt();
    2299           2 :     unsigned argumentCount = Record.readInt();
    2300           4 :     New = new (Context) XRayLogArgsAttr(Range, Context, argumentCount, Spelling);
    2301           2 :     cast<InheritableAttr>(New)->setInherited(isInherited);
    2302           2 :     New->setImplicit(isImplicit);
    2303             :     break;
    2304             :   }
    2305             :   }

Generated by: LCOV version 1.13