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