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

Generated by: LCOV version 1.13