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

Generated by: LCOV version 1.13