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

Generated by: LCOV version 1.13