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