1 //===- ASTReaderStmt.cpp - Stmt/Expr Deserialization ----------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // Statement/expression deserialization.  This implements the
10 // ASTReader::ReadStmt method.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "clang/AST/ASTConcept.h"
15 #include "clang/AST/ASTContext.h"
16 #include "clang/AST/AttrIterator.h"
17 #include "clang/AST/Decl.h"
18 #include "clang/AST/DeclAccessPair.h"
19 #include "clang/AST/DeclCXX.h"
20 #include "clang/AST/DeclGroup.h"
21 #include "clang/AST/DeclObjC.h"
22 #include "clang/AST/DeclTemplate.h"
23 #include "clang/AST/DeclarationName.h"
24 #include "clang/AST/DependenceFlags.h"
25 #include "clang/AST/Expr.h"
26 #include "clang/AST/ExprCXX.h"
27 #include "clang/AST/ExprObjC.h"
28 #include "clang/AST/ExprOpenMP.h"
29 #include "clang/AST/NestedNameSpecifier.h"
30 #include "clang/AST/OpenMPClause.h"
31 #include "clang/AST/OperationKinds.h"
32 #include "clang/AST/Stmt.h"
33 #include "clang/AST/StmtCXX.h"
34 #include "clang/AST/StmtObjC.h"
35 #include "clang/AST/StmtOpenMP.h"
36 #include "clang/AST/StmtVisitor.h"
37 #include "clang/AST/TemplateBase.h"
38 #include "clang/AST/Type.h"
39 #include "clang/AST/UnresolvedSet.h"
40 #include "clang/Basic/CapturedStmt.h"
41 #include "clang/Basic/ExpressionTraits.h"
42 #include "clang/Basic/LLVM.h"
43 #include "clang/Basic/Lambda.h"
44 #include "clang/Basic/LangOptions.h"
45 #include "clang/Basic/OpenMPKinds.h"
46 #include "clang/Basic/OperatorKinds.h"
47 #include "clang/Basic/SourceLocation.h"
48 #include "clang/Basic/Specifiers.h"
49 #include "clang/Basic/TypeTraits.h"
50 #include "clang/Lex/Token.h"
51 #include "clang/Serialization/ASTBitCodes.h"
52 #include "clang/Serialization/ASTRecordReader.h"
53 #include "llvm/ADT/DenseMap.h"
54 #include "llvm/ADT/SmallString.h"
55 #include "llvm/ADT/SmallVector.h"
56 #include "llvm/ADT/StringRef.h"
57 #include "llvm/Bitstream/BitstreamReader.h"
58 #include "llvm/Support/Casting.h"
59 #include "llvm/Support/ErrorHandling.h"
60 #include <algorithm>
61 #include <cassert>
62 #include <cstdint>
63 #include <string>
64 
65 using namespace clang;
66 using namespace serialization;
67 
68 namespace clang {
69 
70   class ASTStmtReader : public StmtVisitor<ASTStmtReader> {
71     ASTRecordReader &Record;
72     llvm::BitstreamCursor &DeclsCursor;
73 
74     SourceLocation readSourceLocation() {
75       return Record.readSourceLocation();
76     }
77 
78     SourceRange readSourceRange() {
79       return Record.readSourceRange();
80     }
81 
82     std::string readString() {
83       return Record.readString();
84     }
85 
86     TypeSourceInfo *readTypeSourceInfo() {
87       return Record.readTypeSourceInfo();
88     }
89 
90     Decl *readDecl() {
91       return Record.readDecl();
92     }
93 
94     template<typename T>
95     T *readDeclAs() {
96       return Record.readDeclAs<T>();
97     }
98 
99   public:
100     ASTStmtReader(ASTRecordReader &Record, llvm::BitstreamCursor &Cursor)
101         : Record(Record), DeclsCursor(Cursor) {}
102 
103     /// The number of record fields required for the Stmt class
104     /// itself.
105     static const unsigned NumStmtFields = 0;
106 
107     /// The number of record fields required for the Expr class
108     /// itself.
109     static const unsigned NumExprFields =
110         NumStmtFields + ExprDependenceBits + 3;
111 
112     /// Read and initialize a ExplicitTemplateArgumentList structure.
113     void ReadTemplateKWAndArgsInfo(ASTTemplateKWAndArgsInfo &Args,
114                                    TemplateArgumentLoc *ArgsLocArray,
115                                    unsigned NumTemplateArgs);
116 
117     /// Read and initialize a ExplicitTemplateArgumentList structure.
118     void ReadExplicitTemplateArgumentList(ASTTemplateArgumentListInfo &ArgList,
119                                           unsigned NumTemplateArgs);
120 
121     void VisitStmt(Stmt *S);
122 #define STMT(Type, Base) \
123     void Visit##Type(Type *);
124 #include "clang/AST/StmtNodes.inc"
125   };
126 
127 } // namespace clang
128 
129 void ASTStmtReader::ReadTemplateKWAndArgsInfo(ASTTemplateKWAndArgsInfo &Args,
130                                               TemplateArgumentLoc *ArgsLocArray,
131                                               unsigned NumTemplateArgs) {
132   SourceLocation TemplateKWLoc = readSourceLocation();
133   TemplateArgumentListInfo ArgInfo;
134   ArgInfo.setLAngleLoc(readSourceLocation());
135   ArgInfo.setRAngleLoc(readSourceLocation());
136   for (unsigned i = 0; i != NumTemplateArgs; ++i)
137     ArgInfo.addArgument(Record.readTemplateArgumentLoc());
138   Args.initializeFrom(TemplateKWLoc, ArgInfo, ArgsLocArray);
139 }
140 
141 void ASTStmtReader::VisitStmt(Stmt *S) {
142   assert(Record.getIdx() == NumStmtFields && "Incorrect statement field count");
143 }
144 
145 void ASTStmtReader::VisitNullStmt(NullStmt *S) {
146   VisitStmt(S);
147   S->setSemiLoc(readSourceLocation());
148   S->NullStmtBits.HasLeadingEmptyMacro = Record.readInt();
149 }
150 
151 void ASTStmtReader::VisitCompoundStmt(CompoundStmt *S) {
152   VisitStmt(S);
153   SmallVector<Stmt *, 16> Stmts;
154   unsigned NumStmts = Record.readInt();
155   while (NumStmts--)
156     Stmts.push_back(Record.readSubStmt());
157   S->setStmts(Stmts);
158   S->CompoundStmtBits.LBraceLoc = readSourceLocation();
159   S->RBraceLoc = readSourceLocation();
160 }
161 
162 void ASTStmtReader::VisitSwitchCase(SwitchCase *S) {
163   VisitStmt(S);
164   Record.recordSwitchCaseID(S, Record.readInt());
165   S->setKeywordLoc(readSourceLocation());
166   S->setColonLoc(readSourceLocation());
167 }
168 
169 void ASTStmtReader::VisitCaseStmt(CaseStmt *S) {
170   VisitSwitchCase(S);
171   bool CaseStmtIsGNURange = Record.readInt();
172   S->setLHS(Record.readSubExpr());
173   S->setSubStmt(Record.readSubStmt());
174   if (CaseStmtIsGNURange) {
175     S->setRHS(Record.readSubExpr());
176     S->setEllipsisLoc(readSourceLocation());
177   }
178 }
179 
180 void ASTStmtReader::VisitDefaultStmt(DefaultStmt *S) {
181   VisitSwitchCase(S);
182   S->setSubStmt(Record.readSubStmt());
183 }
184 
185 void ASTStmtReader::VisitLabelStmt(LabelStmt *S) {
186   VisitStmt(S);
187   auto *LD = readDeclAs<LabelDecl>();
188   LD->setStmt(S);
189   S->setDecl(LD);
190   S->setSubStmt(Record.readSubStmt());
191   S->setIdentLoc(readSourceLocation());
192 }
193 
194 void ASTStmtReader::VisitAttributedStmt(AttributedStmt *S) {
195   VisitStmt(S);
196   // NumAttrs in AttributedStmt is set when creating an empty
197   // AttributedStmt in AttributedStmt::CreateEmpty, since it is needed
198   // to allocate the right amount of space for the trailing Attr *.
199   uint64_t NumAttrs = Record.readInt();
200   AttrVec Attrs;
201   Record.readAttributes(Attrs);
202   (void)NumAttrs;
203   assert(NumAttrs == S->AttributedStmtBits.NumAttrs);
204   assert(NumAttrs == Attrs.size());
205   std::copy(Attrs.begin(), Attrs.end(), S->getAttrArrayPtr());
206   S->SubStmt = Record.readSubStmt();
207   S->AttributedStmtBits.AttrLoc = readSourceLocation();
208 }
209 
210 void ASTStmtReader::VisitIfStmt(IfStmt *S) {
211   VisitStmt(S);
212 
213   S->setConstexpr(Record.readInt());
214   bool HasElse = Record.readInt();
215   bool HasVar = Record.readInt();
216   bool HasInit = Record.readInt();
217 
218   S->setCond(Record.readSubExpr());
219   S->setThen(Record.readSubStmt());
220   if (HasElse)
221     S->setElse(Record.readSubStmt());
222   if (HasVar)
223     S->setConditionVariable(Record.getContext(), readDeclAs<VarDecl>());
224   if (HasInit)
225     S->setInit(Record.readSubStmt());
226 
227   S->setIfLoc(readSourceLocation());
228   if (HasElse)
229     S->setElseLoc(readSourceLocation());
230 }
231 
232 void ASTStmtReader::VisitSwitchStmt(SwitchStmt *S) {
233   VisitStmt(S);
234 
235   bool HasInit = Record.readInt();
236   bool HasVar = Record.readInt();
237   bool AllEnumCasesCovered = Record.readInt();
238   if (AllEnumCasesCovered)
239     S->setAllEnumCasesCovered();
240 
241   S->setCond(Record.readSubExpr());
242   S->setBody(Record.readSubStmt());
243   if (HasInit)
244     S->setInit(Record.readSubStmt());
245   if (HasVar)
246     S->setConditionVariable(Record.getContext(), readDeclAs<VarDecl>());
247 
248   S->setSwitchLoc(readSourceLocation());
249 
250   SwitchCase *PrevSC = nullptr;
251   for (auto E = Record.size(); Record.getIdx() != E; ) {
252     SwitchCase *SC = Record.getSwitchCaseWithID(Record.readInt());
253     if (PrevSC)
254       PrevSC->setNextSwitchCase(SC);
255     else
256       S->setSwitchCaseList(SC);
257 
258     PrevSC = SC;
259   }
260 }
261 
262 void ASTStmtReader::VisitWhileStmt(WhileStmt *S) {
263   VisitStmt(S);
264 
265   bool HasVar = Record.readInt();
266 
267   S->setCond(Record.readSubExpr());
268   S->setBody(Record.readSubStmt());
269   if (HasVar)
270     S->setConditionVariable(Record.getContext(), readDeclAs<VarDecl>());
271 
272   S->setWhileLoc(readSourceLocation());
273 }
274 
275 void ASTStmtReader::VisitDoStmt(DoStmt *S) {
276   VisitStmt(S);
277   S->setCond(Record.readSubExpr());
278   S->setBody(Record.readSubStmt());
279   S->setDoLoc(readSourceLocation());
280   S->setWhileLoc(readSourceLocation());
281   S->setRParenLoc(readSourceLocation());
282 }
283 
284 void ASTStmtReader::VisitForStmt(ForStmt *S) {
285   VisitStmt(S);
286   S->setInit(Record.readSubStmt());
287   S->setCond(Record.readSubExpr());
288   S->setConditionVariable(Record.getContext(), readDeclAs<VarDecl>());
289   S->setInc(Record.readSubExpr());
290   S->setBody(Record.readSubStmt());
291   S->setForLoc(readSourceLocation());
292   S->setLParenLoc(readSourceLocation());
293   S->setRParenLoc(readSourceLocation());
294 }
295 
296 void ASTStmtReader::VisitGotoStmt(GotoStmt *S) {
297   VisitStmt(S);
298   S->setLabel(readDeclAs<LabelDecl>());
299   S->setGotoLoc(readSourceLocation());
300   S->setLabelLoc(readSourceLocation());
301 }
302 
303 void ASTStmtReader::VisitIndirectGotoStmt(IndirectGotoStmt *S) {
304   VisitStmt(S);
305   S->setGotoLoc(readSourceLocation());
306   S->setStarLoc(readSourceLocation());
307   S->setTarget(Record.readSubExpr());
308 }
309 
310 void ASTStmtReader::VisitContinueStmt(ContinueStmt *S) {
311   VisitStmt(S);
312   S->setContinueLoc(readSourceLocation());
313 }
314 
315 void ASTStmtReader::VisitBreakStmt(BreakStmt *S) {
316   VisitStmt(S);
317   S->setBreakLoc(readSourceLocation());
318 }
319 
320 void ASTStmtReader::VisitReturnStmt(ReturnStmt *S) {
321   VisitStmt(S);
322 
323   bool HasNRVOCandidate = Record.readInt();
324 
325   S->setRetValue(Record.readSubExpr());
326   if (HasNRVOCandidate)
327     S->setNRVOCandidate(readDeclAs<VarDecl>());
328 
329   S->setReturnLoc(readSourceLocation());
330 }
331 
332 void ASTStmtReader::VisitDeclStmt(DeclStmt *S) {
333   VisitStmt(S);
334   S->setStartLoc(readSourceLocation());
335   S->setEndLoc(readSourceLocation());
336 
337   if (Record.size() - Record.getIdx() == 1) {
338     // Single declaration
339     S->setDeclGroup(DeclGroupRef(readDecl()));
340   } else {
341     SmallVector<Decl *, 16> Decls;
342     int N = Record.size() - Record.getIdx();
343     Decls.reserve(N);
344     for (int I = 0; I < N; ++I)
345       Decls.push_back(readDecl());
346     S->setDeclGroup(DeclGroupRef(DeclGroup::Create(Record.getContext(),
347                                                    Decls.data(),
348                                                    Decls.size())));
349   }
350 }
351 
352 void ASTStmtReader::VisitAsmStmt(AsmStmt *S) {
353   VisitStmt(S);
354   S->NumOutputs = Record.readInt();
355   S->NumInputs = Record.readInt();
356   S->NumClobbers = Record.readInt();
357   S->setAsmLoc(readSourceLocation());
358   S->setVolatile(Record.readInt());
359   S->setSimple(Record.readInt());
360 }
361 
362 void ASTStmtReader::VisitGCCAsmStmt(GCCAsmStmt *S) {
363   VisitAsmStmt(S);
364   S->NumLabels = Record.readInt();
365   S->setRParenLoc(readSourceLocation());
366   S->setAsmString(cast_or_null<StringLiteral>(Record.readSubStmt()));
367 
368   unsigned NumOutputs = S->getNumOutputs();
369   unsigned NumInputs = S->getNumInputs();
370   unsigned NumClobbers = S->getNumClobbers();
371   unsigned NumLabels = S->getNumLabels();
372 
373   // Outputs and inputs
374   SmallVector<IdentifierInfo *, 16> Names;
375   SmallVector<StringLiteral*, 16> Constraints;
376   SmallVector<Stmt*, 16> Exprs;
377   for (unsigned I = 0, N = NumOutputs + NumInputs; I != N; ++I) {
378     Names.push_back(Record.readIdentifier());
379     Constraints.push_back(cast_or_null<StringLiteral>(Record.readSubStmt()));
380     Exprs.push_back(Record.readSubStmt());
381   }
382 
383   // Constraints
384   SmallVector<StringLiteral*, 16> Clobbers;
385   for (unsigned I = 0; I != NumClobbers; ++I)
386     Clobbers.push_back(cast_or_null<StringLiteral>(Record.readSubStmt()));
387 
388   // Labels
389   for (unsigned I = 0, N = NumLabels; I != N; ++I)
390     Exprs.push_back(Record.readSubStmt());
391 
392   S->setOutputsAndInputsAndClobbers(Record.getContext(),
393                                     Names.data(), Constraints.data(),
394                                     Exprs.data(), NumOutputs, NumInputs,
395                                     NumLabels,
396                                     Clobbers.data(), NumClobbers);
397 }
398 
399 void ASTStmtReader::VisitMSAsmStmt(MSAsmStmt *S) {
400   VisitAsmStmt(S);
401   S->LBraceLoc = readSourceLocation();
402   S->EndLoc = readSourceLocation();
403   S->NumAsmToks = Record.readInt();
404   std::string AsmStr = readString();
405 
406   // Read the tokens.
407   SmallVector<Token, 16> AsmToks;
408   AsmToks.reserve(S->NumAsmToks);
409   for (unsigned i = 0, e = S->NumAsmToks; i != e; ++i) {
410     AsmToks.push_back(Record.readToken());
411   }
412 
413   // The calls to reserve() for the FooData vectors are mandatory to
414   // prevent dead StringRefs in the Foo vectors.
415 
416   // Read the clobbers.
417   SmallVector<std::string, 16> ClobbersData;
418   SmallVector<StringRef, 16> Clobbers;
419   ClobbersData.reserve(S->NumClobbers);
420   Clobbers.reserve(S->NumClobbers);
421   for (unsigned i = 0, e = S->NumClobbers; i != e; ++i) {
422     ClobbersData.push_back(readString());
423     Clobbers.push_back(ClobbersData.back());
424   }
425 
426   // Read the operands.
427   unsigned NumOperands = S->NumOutputs + S->NumInputs;
428   SmallVector<Expr*, 16> Exprs;
429   SmallVector<std::string, 16> ConstraintsData;
430   SmallVector<StringRef, 16> Constraints;
431   Exprs.reserve(NumOperands);
432   ConstraintsData.reserve(NumOperands);
433   Constraints.reserve(NumOperands);
434   for (unsigned i = 0; i != NumOperands; ++i) {
435     Exprs.push_back(cast<Expr>(Record.readSubStmt()));
436     ConstraintsData.push_back(readString());
437     Constraints.push_back(ConstraintsData.back());
438   }
439 
440   S->initialize(Record.getContext(), AsmStr, AsmToks,
441                 Constraints, Exprs, Clobbers);
442 }
443 
444 void ASTStmtReader::VisitCoroutineBodyStmt(CoroutineBodyStmt *S) {
445   VisitStmt(S);
446   assert(Record.peekInt() == S->NumParams);
447   Record.skipInts(1);
448   auto *StoredStmts = S->getStoredStmts();
449   for (unsigned i = 0;
450        i < CoroutineBodyStmt::SubStmt::FirstParamMove + S->NumParams; ++i)
451     StoredStmts[i] = Record.readSubStmt();
452 }
453 
454 void ASTStmtReader::VisitCoreturnStmt(CoreturnStmt *S) {
455   VisitStmt(S);
456   S->CoreturnLoc = Record.readSourceLocation();
457   for (auto &SubStmt: S->SubStmts)
458     SubStmt = Record.readSubStmt();
459   S->IsImplicit = Record.readInt() != 0;
460 }
461 
462 void ASTStmtReader::VisitCoawaitExpr(CoawaitExpr *E) {
463   VisitExpr(E);
464   E->KeywordLoc = readSourceLocation();
465   for (auto &SubExpr: E->SubExprs)
466     SubExpr = Record.readSubStmt();
467   E->OpaqueValue = cast_or_null<OpaqueValueExpr>(Record.readSubStmt());
468   E->setIsImplicit(Record.readInt() != 0);
469 }
470 
471 void ASTStmtReader::VisitCoyieldExpr(CoyieldExpr *E) {
472   VisitExpr(E);
473   E->KeywordLoc = readSourceLocation();
474   for (auto &SubExpr: E->SubExprs)
475     SubExpr = Record.readSubStmt();
476   E->OpaqueValue = cast_or_null<OpaqueValueExpr>(Record.readSubStmt());
477 }
478 
479 void ASTStmtReader::VisitDependentCoawaitExpr(DependentCoawaitExpr *E) {
480   VisitExpr(E);
481   E->KeywordLoc = readSourceLocation();
482   for (auto &SubExpr: E->SubExprs)
483     SubExpr = Record.readSubStmt();
484 }
485 
486 void ASTStmtReader::VisitCapturedStmt(CapturedStmt *S) {
487   VisitStmt(S);
488   Record.skipInts(1);
489   S->setCapturedDecl(readDeclAs<CapturedDecl>());
490   S->setCapturedRegionKind(static_cast<CapturedRegionKind>(Record.readInt()));
491   S->setCapturedRecordDecl(readDeclAs<RecordDecl>());
492 
493   // Capture inits
494   for (CapturedStmt::capture_init_iterator I = S->capture_init_begin(),
495                                            E = S->capture_init_end();
496        I != E; ++I)
497     *I = Record.readSubExpr();
498 
499   // Body
500   S->setCapturedStmt(Record.readSubStmt());
501   S->getCapturedDecl()->setBody(S->getCapturedStmt());
502 
503   // Captures
504   for (auto &I : S->captures()) {
505     I.VarAndKind.setPointer(readDeclAs<VarDecl>());
506     I.VarAndKind.setInt(
507         static_cast<CapturedStmt::VariableCaptureKind>(Record.readInt()));
508     I.Loc = readSourceLocation();
509   }
510 }
511 
512 void ASTStmtReader::VisitExpr(Expr *E) {
513   VisitStmt(E);
514   E->setType(Record.readType());
515 
516   // FIXME: write and read all DependentFlags with a single call.
517   bool TypeDependent = Record.readInt();
518   bool ValueDependent = Record.readInt();
519   bool InstantiationDependent = Record.readInt();
520   bool ContainsUnexpandedTemplateParameters = Record.readInt();
521   bool ContainsErrors = Record.readInt();
522   auto Deps = ExprDependence::None;
523   if (TypeDependent)
524     Deps |= ExprDependence::Type;
525   if (ValueDependent)
526     Deps |= ExprDependence::Value;
527   if (InstantiationDependent)
528     Deps |= ExprDependence::Instantiation;
529   if (ContainsUnexpandedTemplateParameters)
530     Deps |= ExprDependence::UnexpandedPack;
531   if (ContainsErrors)
532     Deps |= ExprDependence::Error;
533   E->setDependence(Deps);
534 
535   E->setValueKind(static_cast<ExprValueKind>(Record.readInt()));
536   E->setObjectKind(static_cast<ExprObjectKind>(Record.readInt()));
537   assert(Record.getIdx() == NumExprFields &&
538          "Incorrect expression field count");
539 }
540 
541 void ASTStmtReader::VisitConstantExpr(ConstantExpr *E) {
542   VisitExpr(E);
543   E->ConstantExprBits.ResultKind = Record.readInt();
544   switch (E->ConstantExprBits.ResultKind) {
545   case ConstantExpr::RSK_Int64: {
546     E->Int64Result() = Record.readInt();
547     uint64_t tmp = Record.readInt();
548     E->ConstantExprBits.IsUnsigned = tmp & 0x1;
549     E->ConstantExprBits.BitWidth = tmp >> 1;
550     break;
551   }
552   case ConstantExpr::RSK_APValue:
553     E->APValueResult() = Record.readAPValue();
554   }
555   E->setSubExpr(Record.readSubExpr());
556 }
557 
558 void ASTStmtReader::VisitPredefinedExpr(PredefinedExpr *E) {
559   VisitExpr(E);
560   bool HasFunctionName = Record.readInt();
561   E->PredefinedExprBits.HasFunctionName = HasFunctionName;
562   E->PredefinedExprBits.Kind = Record.readInt();
563   E->setLocation(readSourceLocation());
564   if (HasFunctionName)
565     E->setFunctionName(cast<StringLiteral>(Record.readSubExpr()));
566 }
567 
568 void ASTStmtReader::VisitDeclRefExpr(DeclRefExpr *E) {
569   VisitExpr(E);
570 
571   E->DeclRefExprBits.HasQualifier = Record.readInt();
572   E->DeclRefExprBits.HasFoundDecl = Record.readInt();
573   E->DeclRefExprBits.HasTemplateKWAndArgsInfo = Record.readInt();
574   E->DeclRefExprBits.HadMultipleCandidates = Record.readInt();
575   E->DeclRefExprBits.RefersToEnclosingVariableOrCapture = Record.readInt();
576   E->DeclRefExprBits.NonOdrUseReason = Record.readInt();
577   unsigned NumTemplateArgs = 0;
578   if (E->hasTemplateKWAndArgsInfo())
579     NumTemplateArgs = Record.readInt();
580 
581   if (E->hasQualifier())
582     new (E->getTrailingObjects<NestedNameSpecifierLoc>())
583         NestedNameSpecifierLoc(Record.readNestedNameSpecifierLoc());
584 
585   if (E->hasFoundDecl())
586     *E->getTrailingObjects<NamedDecl *>() = readDeclAs<NamedDecl>();
587 
588   if (E->hasTemplateKWAndArgsInfo())
589     ReadTemplateKWAndArgsInfo(
590         *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(),
591         E->getTrailingObjects<TemplateArgumentLoc>(), NumTemplateArgs);
592 
593   E->setDecl(readDeclAs<ValueDecl>());
594   E->setLocation(readSourceLocation());
595   E->DNLoc = Record.readDeclarationNameLoc(E->getDecl()->getDeclName());
596 }
597 
598 void ASTStmtReader::VisitIntegerLiteral(IntegerLiteral *E) {
599   VisitExpr(E);
600   E->setLocation(readSourceLocation());
601   E->setValue(Record.getContext(), Record.readAPInt());
602 }
603 
604 void ASTStmtReader::VisitFixedPointLiteral(FixedPointLiteral *E) {
605   VisitExpr(E);
606   E->setLocation(readSourceLocation());
607   E->setValue(Record.getContext(), Record.readAPInt());
608 }
609 
610 void ASTStmtReader::VisitFloatingLiteral(FloatingLiteral *E) {
611   VisitExpr(E);
612   E->setRawSemantics(
613       static_cast<llvm::APFloatBase::Semantics>(Record.readInt()));
614   E->setExact(Record.readInt());
615   E->setValue(Record.getContext(), Record.readAPFloat(E->getSemantics()));
616   E->setLocation(readSourceLocation());
617 }
618 
619 void ASTStmtReader::VisitImaginaryLiteral(ImaginaryLiteral *E) {
620   VisitExpr(E);
621   E->setSubExpr(Record.readSubExpr());
622 }
623 
624 void ASTStmtReader::VisitStringLiteral(StringLiteral *E) {
625   VisitExpr(E);
626 
627   // NumConcatenated, Length and CharByteWidth are set by the empty
628   // ctor since they are needed to allocate storage for the trailing objects.
629   unsigned NumConcatenated = Record.readInt();
630   unsigned Length = Record.readInt();
631   unsigned CharByteWidth = Record.readInt();
632   assert((NumConcatenated == E->getNumConcatenated()) &&
633          "Wrong number of concatenated tokens!");
634   assert((Length == E->getLength()) && "Wrong Length!");
635   assert((CharByteWidth == E->getCharByteWidth()) && "Wrong character width!");
636   E->StringLiteralBits.Kind = Record.readInt();
637   E->StringLiteralBits.IsPascal = Record.readInt();
638 
639   // The character width is originally computed via mapCharByteWidth.
640   // Check that the deserialized character width is consistant with the result
641   // of calling mapCharByteWidth.
642   assert((CharByteWidth ==
643           StringLiteral::mapCharByteWidth(Record.getContext().getTargetInfo(),
644                                           E->getKind())) &&
645          "Wrong character width!");
646 
647   // Deserialize the trailing array of SourceLocation.
648   for (unsigned I = 0; I < NumConcatenated; ++I)
649     E->setStrTokenLoc(I, readSourceLocation());
650 
651   // Deserialize the trailing array of char holding the string data.
652   char *StrData = E->getStrDataAsChar();
653   for (unsigned I = 0; I < Length * CharByteWidth; ++I)
654     StrData[I] = Record.readInt();
655 }
656 
657 void ASTStmtReader::VisitCharacterLiteral(CharacterLiteral *E) {
658   VisitExpr(E);
659   E->setValue(Record.readInt());
660   E->setLocation(readSourceLocation());
661   E->setKind(static_cast<CharacterLiteral::CharacterKind>(Record.readInt()));
662 }
663 
664 void ASTStmtReader::VisitParenExpr(ParenExpr *E) {
665   VisitExpr(E);
666   E->setLParen(readSourceLocation());
667   E->setRParen(readSourceLocation());
668   E->setSubExpr(Record.readSubExpr());
669 }
670 
671 void ASTStmtReader::VisitParenListExpr(ParenListExpr *E) {
672   VisitExpr(E);
673   unsigned NumExprs = Record.readInt();
674   assert((NumExprs == E->getNumExprs()) && "Wrong NumExprs!");
675   for (unsigned I = 0; I != NumExprs; ++I)
676     E->getTrailingObjects<Stmt *>()[I] = Record.readSubStmt();
677   E->LParenLoc = readSourceLocation();
678   E->RParenLoc = readSourceLocation();
679 }
680 
681 void ASTStmtReader::VisitUnaryOperator(UnaryOperator *E) {
682   VisitExpr(E);
683   E->setSubExpr(Record.readSubExpr());
684   E->setOpcode((UnaryOperator::Opcode)Record.readInt());
685   E->setOperatorLoc(readSourceLocation());
686   E->setCanOverflow(Record.readInt());
687 }
688 
689 void ASTStmtReader::VisitOffsetOfExpr(OffsetOfExpr *E) {
690   VisitExpr(E);
691   assert(E->getNumComponents() == Record.peekInt());
692   Record.skipInts(1);
693   assert(E->getNumExpressions() == Record.peekInt());
694   Record.skipInts(1);
695   E->setOperatorLoc(readSourceLocation());
696   E->setRParenLoc(readSourceLocation());
697   E->setTypeSourceInfo(readTypeSourceInfo());
698   for (unsigned I = 0, N = E->getNumComponents(); I != N; ++I) {
699     auto Kind = static_cast<OffsetOfNode::Kind>(Record.readInt());
700     SourceLocation Start = readSourceLocation();
701     SourceLocation End = readSourceLocation();
702     switch (Kind) {
703     case OffsetOfNode::Array:
704       E->setComponent(I, OffsetOfNode(Start, Record.readInt(), End));
705       break;
706 
707     case OffsetOfNode::Field:
708       E->setComponent(
709           I, OffsetOfNode(Start, readDeclAs<FieldDecl>(), End));
710       break;
711 
712     case OffsetOfNode::Identifier:
713       E->setComponent(
714           I,
715           OffsetOfNode(Start, Record.readIdentifier(), End));
716       break;
717 
718     case OffsetOfNode::Base: {
719       auto *Base = new (Record.getContext()) CXXBaseSpecifier();
720       *Base = Record.readCXXBaseSpecifier();
721       E->setComponent(I, OffsetOfNode(Base));
722       break;
723     }
724     }
725   }
726 
727   for (unsigned I = 0, N = E->getNumExpressions(); I != N; ++I)
728     E->setIndexExpr(I, Record.readSubExpr());
729 }
730 
731 void ASTStmtReader::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E) {
732   VisitExpr(E);
733   E->setKind(static_cast<UnaryExprOrTypeTrait>(Record.readInt()));
734   if (Record.peekInt() == 0) {
735     E->setArgument(Record.readSubExpr());
736     Record.skipInts(1);
737   } else {
738     E->setArgument(readTypeSourceInfo());
739   }
740   E->setOperatorLoc(readSourceLocation());
741   E->setRParenLoc(readSourceLocation());
742 }
743 
744 static ConstraintSatisfaction
745 readConstraintSatisfaction(ASTRecordReader &Record) {
746   ConstraintSatisfaction Satisfaction;
747   Satisfaction.IsSatisfied = Record.readInt();
748   if (!Satisfaction.IsSatisfied) {
749     unsigned NumDetailRecords = Record.readInt();
750     for (unsigned i = 0; i != NumDetailRecords; ++i) {
751       Expr *ConstraintExpr = Record.readExpr();
752       if (/* IsDiagnostic */Record.readInt()) {
753         SourceLocation DiagLocation = Record.readSourceLocation();
754         std::string DiagMessage = Record.readString();
755         Satisfaction.Details.emplace_back(
756             ConstraintExpr, new (Record.getContext())
757                                 ConstraintSatisfaction::SubstitutionDiagnostic{
758                                     DiagLocation, DiagMessage});
759       } else
760         Satisfaction.Details.emplace_back(ConstraintExpr, Record.readExpr());
761     }
762   }
763   return Satisfaction;
764 }
765 
766 void ASTStmtReader::VisitConceptSpecializationExpr(
767         ConceptSpecializationExpr *E) {
768   VisitExpr(E);
769   unsigned NumTemplateArgs = Record.readInt();
770   E->NestedNameSpec = Record.readNestedNameSpecifierLoc();
771   E->TemplateKWLoc = Record.readSourceLocation();
772   E->ConceptName = Record.readDeclarationNameInfo();
773   E->NamedConcept = readDeclAs<ConceptDecl>();
774   E->FoundDecl = Record.readDeclAs<NamedDecl>();
775   E->ArgsAsWritten = Record.readASTTemplateArgumentListInfo();
776   llvm::SmallVector<TemplateArgument, 4> Args;
777   for (unsigned I = 0; I < NumTemplateArgs; ++I)
778     Args.push_back(Record.readTemplateArgument());
779   E->setTemplateArguments(Args);
780   E->Satisfaction = E->isValueDependent() ? nullptr :
781       ASTConstraintSatisfaction::Create(Record.getContext(),
782                                         readConstraintSatisfaction(Record));
783 }
784 
785 static concepts::Requirement::SubstitutionDiagnostic *
786 readSubstitutionDiagnostic(ASTRecordReader &Record) {
787   std::string SubstitutedEntity = Record.readString();
788   SourceLocation DiagLoc = Record.readSourceLocation();
789   std::string DiagMessage = Record.readString();
790   return new (Record.getContext())
791       concepts::Requirement::SubstitutionDiagnostic{SubstitutedEntity, DiagLoc,
792                                                     DiagMessage};
793 }
794 
795 void ASTStmtReader::VisitRequiresExpr(RequiresExpr *E) {
796   VisitExpr(E);
797   unsigned NumLocalParameters = Record.readInt();
798   unsigned NumRequirements = Record.readInt();
799   E->RequiresExprBits.RequiresKWLoc = Record.readSourceLocation();
800   E->RequiresExprBits.IsSatisfied = Record.readInt();
801   E->Body = Record.readDeclAs<RequiresExprBodyDecl>();
802   llvm::SmallVector<ParmVarDecl *, 4> LocalParameters;
803   for (unsigned i = 0; i < NumLocalParameters; ++i)
804     LocalParameters.push_back(cast<ParmVarDecl>(Record.readDecl()));
805   std::copy(LocalParameters.begin(), LocalParameters.end(),
806             E->getTrailingObjects<ParmVarDecl *>());
807   llvm::SmallVector<concepts::Requirement *, 4> Requirements;
808   for (unsigned i = 0; i < NumRequirements; ++i) {
809     auto RK =
810         static_cast<concepts::Requirement::RequirementKind>(Record.readInt());
811     concepts::Requirement *R = nullptr;
812     switch (RK) {
813       case concepts::Requirement::RK_Type: {
814         auto Status =
815             static_cast<concepts::TypeRequirement::SatisfactionStatus>(
816                 Record.readInt());
817         if (Status == concepts::TypeRequirement::SS_SubstitutionFailure)
818           R = new (Record.getContext())
819               concepts::TypeRequirement(readSubstitutionDiagnostic(Record));
820         else
821           R = new (Record.getContext())
822               concepts::TypeRequirement(Record.readTypeSourceInfo());
823       } break;
824       case concepts::Requirement::RK_Simple:
825       case concepts::Requirement::RK_Compound: {
826         auto Status =
827             static_cast<concepts::ExprRequirement::SatisfactionStatus>(
828                 Record.readInt());
829         llvm::PointerUnion<concepts::Requirement::SubstitutionDiagnostic *,
830                            Expr *> E;
831         if (Status == concepts::ExprRequirement::SS_ExprSubstitutionFailure) {
832           E = readSubstitutionDiagnostic(Record);
833         } else
834           E = Record.readExpr();
835 
836         llvm::Optional<concepts::ExprRequirement::ReturnTypeRequirement> Req;
837         ConceptSpecializationExpr *SubstitutedConstraintExpr = nullptr;
838         SourceLocation NoexceptLoc;
839         if (RK == concepts::Requirement::RK_Simple) {
840           Req.emplace();
841         } else {
842           NoexceptLoc = Record.readSourceLocation();
843           switch (/* returnTypeRequirementKind */Record.readInt()) {
844             case 0:
845               // No return type requirement.
846               Req.emplace();
847               break;
848             case 1: {
849               // type-constraint
850               TemplateParameterList *TPL = Record.readTemplateParameterList();
851               if (Status >=
852                   concepts::ExprRequirement::SS_ConstraintsNotSatisfied)
853                 SubstitutedConstraintExpr =
854                     cast<ConceptSpecializationExpr>(Record.readExpr());
855               Req.emplace(TPL);
856             } break;
857             case 2:
858               // Substitution failure
859               Req.emplace(readSubstitutionDiagnostic(Record));
860               break;
861           }
862         }
863         if (Expr *Ex = E.dyn_cast<Expr *>())
864           R = new (Record.getContext()) concepts::ExprRequirement(
865                   Ex, RK == concepts::Requirement::RK_Simple, NoexceptLoc,
866                   std::move(*Req), Status, SubstitutedConstraintExpr);
867         else
868           R = new (Record.getContext()) concepts::ExprRequirement(
869                   E.get<concepts::Requirement::SubstitutionDiagnostic *>(),
870                   RK == concepts::Requirement::RK_Simple, NoexceptLoc,
871                   std::move(*Req));
872       } break;
873       case concepts::Requirement::RK_Nested: {
874         if (/* IsSubstitutionDiagnostic */Record.readInt()) {
875           R = new (Record.getContext()) concepts::NestedRequirement(
876               readSubstitutionDiagnostic(Record));
877           break;
878         }
879         Expr *E = Record.readExpr();
880         if (E->isInstantiationDependent())
881           R = new (Record.getContext()) concepts::NestedRequirement(E);
882         else
883           R = new (Record.getContext())
884               concepts::NestedRequirement(Record.getContext(), E,
885                                           readConstraintSatisfaction(Record));
886       } break;
887     }
888     if (!R)
889       continue;
890     Requirements.push_back(R);
891   }
892   std::copy(Requirements.begin(), Requirements.end(),
893             E->getTrailingObjects<concepts::Requirement *>());
894   E->RBraceLoc = Record.readSourceLocation();
895 }
896 
897 void ASTStmtReader::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
898   VisitExpr(E);
899   E->setLHS(Record.readSubExpr());
900   E->setRHS(Record.readSubExpr());
901   E->setRBracketLoc(readSourceLocation());
902 }
903 
904 void ASTStmtReader::VisitOMPArraySectionExpr(OMPArraySectionExpr *E) {
905   VisitExpr(E);
906   E->setBase(Record.readSubExpr());
907   E->setLowerBound(Record.readSubExpr());
908   E->setLength(Record.readSubExpr());
909   E->setColonLoc(readSourceLocation());
910   E->setRBracketLoc(readSourceLocation());
911 }
912 
913 void ASTStmtReader::VisitCallExpr(CallExpr *E) {
914   VisitExpr(E);
915   unsigned NumArgs = Record.readInt();
916   assert((NumArgs == E->getNumArgs()) && "Wrong NumArgs!");
917   E->setRParenLoc(readSourceLocation());
918   E->setCallee(Record.readSubExpr());
919   for (unsigned I = 0; I != NumArgs; ++I)
920     E->setArg(I, Record.readSubExpr());
921   E->setADLCallKind(static_cast<CallExpr::ADLCallKind>(Record.readInt()));
922 }
923 
924 void ASTStmtReader::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
925   VisitCallExpr(E);
926 }
927 
928 void ASTStmtReader::VisitMemberExpr(MemberExpr *E) {
929   VisitExpr(E);
930 
931   bool HasQualifier = Record.readInt();
932   bool HasFoundDecl = Record.readInt();
933   bool HasTemplateInfo = Record.readInt();
934   unsigned NumTemplateArgs = Record.readInt();
935 
936   E->Base = Record.readSubExpr();
937   E->MemberDecl = Record.readDeclAs<ValueDecl>();
938   E->MemberDNLoc = Record.readDeclarationNameLoc(E->MemberDecl->getDeclName());
939   E->MemberLoc = Record.readSourceLocation();
940   E->MemberExprBits.IsArrow = Record.readInt();
941   E->MemberExprBits.HasQualifierOrFoundDecl = HasQualifier || HasFoundDecl;
942   E->MemberExprBits.HasTemplateKWAndArgsInfo = HasTemplateInfo;
943   E->MemberExprBits.HadMultipleCandidates = Record.readInt();
944   E->MemberExprBits.NonOdrUseReason = Record.readInt();
945   E->MemberExprBits.OperatorLoc = Record.readSourceLocation();
946 
947   if (HasQualifier || HasFoundDecl) {
948     DeclAccessPair FoundDecl;
949     if (HasFoundDecl) {
950       auto *FoundD = Record.readDeclAs<NamedDecl>();
951       auto AS = (AccessSpecifier)Record.readInt();
952       FoundDecl = DeclAccessPair::make(FoundD, AS);
953     } else {
954       FoundDecl = DeclAccessPair::make(E->MemberDecl,
955                                        E->MemberDecl->getAccess());
956     }
957     E->getTrailingObjects<MemberExprNameQualifier>()->FoundDecl = FoundDecl;
958 
959     NestedNameSpecifierLoc QualifierLoc;
960     if (HasQualifier)
961       QualifierLoc = Record.readNestedNameSpecifierLoc();
962     E->getTrailingObjects<MemberExprNameQualifier>()->QualifierLoc =
963         QualifierLoc;
964   }
965 
966   if (HasTemplateInfo)
967     ReadTemplateKWAndArgsInfo(
968         *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(),
969         E->getTrailingObjects<TemplateArgumentLoc>(), NumTemplateArgs);
970 }
971 
972 void ASTStmtReader::VisitObjCIsaExpr(ObjCIsaExpr *E) {
973   VisitExpr(E);
974   E->setBase(Record.readSubExpr());
975   E->setIsaMemberLoc(readSourceLocation());
976   E->setOpLoc(readSourceLocation());
977   E->setArrow(Record.readInt());
978 }
979 
980 void ASTStmtReader::
981 VisitObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *E) {
982   VisitExpr(E);
983   E->Operand = Record.readSubExpr();
984   E->setShouldCopy(Record.readInt());
985 }
986 
987 void ASTStmtReader::VisitObjCBridgedCastExpr(ObjCBridgedCastExpr *E) {
988   VisitExplicitCastExpr(E);
989   E->LParenLoc = readSourceLocation();
990   E->BridgeKeywordLoc = readSourceLocation();
991   E->Kind = Record.readInt();
992 }
993 
994 void ASTStmtReader::VisitCastExpr(CastExpr *E) {
995   VisitExpr(E);
996   unsigned NumBaseSpecs = Record.readInt();
997   assert(NumBaseSpecs == E->path_size());
998   E->setSubExpr(Record.readSubExpr());
999   E->setCastKind((CastKind)Record.readInt());
1000   CastExpr::path_iterator BaseI = E->path_begin();
1001   while (NumBaseSpecs--) {
1002     auto *BaseSpec = new (Record.getContext()) CXXBaseSpecifier;
1003     *BaseSpec = Record.readCXXBaseSpecifier();
1004     *BaseI++ = BaseSpec;
1005   }
1006 }
1007 
1008 void ASTStmtReader::VisitBinaryOperator(BinaryOperator *E) {
1009   VisitExpr(E);
1010   E->setLHS(Record.readSubExpr());
1011   E->setRHS(Record.readSubExpr());
1012   E->setOpcode((BinaryOperator::Opcode)Record.readInt());
1013   E->setOperatorLoc(readSourceLocation());
1014   E->setFPFeatures(FPOptions(Record.readInt()));
1015 }
1016 
1017 void ASTStmtReader::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
1018   VisitBinaryOperator(E);
1019   E->setComputationLHSType(Record.readType());
1020   E->setComputationResultType(Record.readType());
1021 }
1022 
1023 void ASTStmtReader::VisitConditionalOperator(ConditionalOperator *E) {
1024   VisitExpr(E);
1025   E->SubExprs[ConditionalOperator::COND] = Record.readSubExpr();
1026   E->SubExprs[ConditionalOperator::LHS] = Record.readSubExpr();
1027   E->SubExprs[ConditionalOperator::RHS] = Record.readSubExpr();
1028   E->QuestionLoc = readSourceLocation();
1029   E->ColonLoc = readSourceLocation();
1030 }
1031 
1032 void
1033 ASTStmtReader::VisitBinaryConditionalOperator(BinaryConditionalOperator *E) {
1034   VisitExpr(E);
1035   E->OpaqueValue = cast<OpaqueValueExpr>(Record.readSubExpr());
1036   E->SubExprs[BinaryConditionalOperator::COMMON] = Record.readSubExpr();
1037   E->SubExprs[BinaryConditionalOperator::COND] = Record.readSubExpr();
1038   E->SubExprs[BinaryConditionalOperator::LHS] = Record.readSubExpr();
1039   E->SubExprs[BinaryConditionalOperator::RHS] = Record.readSubExpr();
1040   E->QuestionLoc = readSourceLocation();
1041   E->ColonLoc = readSourceLocation();
1042 }
1043 
1044 void ASTStmtReader::VisitImplicitCastExpr(ImplicitCastExpr *E) {
1045   VisitCastExpr(E);
1046   E->setIsPartOfExplicitCast(Record.readInt());
1047 }
1048 
1049 void ASTStmtReader::VisitExplicitCastExpr(ExplicitCastExpr *E) {
1050   VisitCastExpr(E);
1051   E->setTypeInfoAsWritten(readTypeSourceInfo());
1052 }
1053 
1054 void ASTStmtReader::VisitCStyleCastExpr(CStyleCastExpr *E) {
1055   VisitExplicitCastExpr(E);
1056   E->setLParenLoc(readSourceLocation());
1057   E->setRParenLoc(readSourceLocation());
1058 }
1059 
1060 void ASTStmtReader::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
1061   VisitExpr(E);
1062   E->setLParenLoc(readSourceLocation());
1063   E->setTypeSourceInfo(readTypeSourceInfo());
1064   E->setInitializer(Record.readSubExpr());
1065   E->setFileScope(Record.readInt());
1066 }
1067 
1068 void ASTStmtReader::VisitExtVectorElementExpr(ExtVectorElementExpr *E) {
1069   VisitExpr(E);
1070   E->setBase(Record.readSubExpr());
1071   E->setAccessor(Record.readIdentifier());
1072   E->setAccessorLoc(readSourceLocation());
1073 }
1074 
1075 void ASTStmtReader::VisitInitListExpr(InitListExpr *E) {
1076   VisitExpr(E);
1077   if (auto *SyntForm = cast_or_null<InitListExpr>(Record.readSubStmt()))
1078     E->setSyntacticForm(SyntForm);
1079   E->setLBraceLoc(readSourceLocation());
1080   E->setRBraceLoc(readSourceLocation());
1081   bool isArrayFiller = Record.readInt();
1082   Expr *filler = nullptr;
1083   if (isArrayFiller) {
1084     filler = Record.readSubExpr();
1085     E->ArrayFillerOrUnionFieldInit = filler;
1086   } else
1087     E->ArrayFillerOrUnionFieldInit = readDeclAs<FieldDecl>();
1088   E->sawArrayRangeDesignator(Record.readInt());
1089   unsigned NumInits = Record.readInt();
1090   E->reserveInits(Record.getContext(), NumInits);
1091   if (isArrayFiller) {
1092     for (unsigned I = 0; I != NumInits; ++I) {
1093       Expr *init = Record.readSubExpr();
1094       E->updateInit(Record.getContext(), I, init ? init : filler);
1095     }
1096   } else {
1097     for (unsigned I = 0; I != NumInits; ++I)
1098       E->updateInit(Record.getContext(), I, Record.readSubExpr());
1099   }
1100 }
1101 
1102 void ASTStmtReader::VisitDesignatedInitExpr(DesignatedInitExpr *E) {
1103   using Designator = DesignatedInitExpr::Designator;
1104 
1105   VisitExpr(E);
1106   unsigned NumSubExprs = Record.readInt();
1107   assert(NumSubExprs == E->getNumSubExprs() && "Wrong number of subexprs");
1108   for (unsigned I = 0; I != NumSubExprs; ++I)
1109     E->setSubExpr(I, Record.readSubExpr());
1110   E->setEqualOrColonLoc(readSourceLocation());
1111   E->setGNUSyntax(Record.readInt());
1112 
1113   SmallVector<Designator, 4> Designators;
1114   while (Record.getIdx() < Record.size()) {
1115     switch ((DesignatorTypes)Record.readInt()) {
1116     case DESIG_FIELD_DECL: {
1117       auto *Field = readDeclAs<FieldDecl>();
1118       SourceLocation DotLoc = readSourceLocation();
1119       SourceLocation FieldLoc = readSourceLocation();
1120       Designators.push_back(Designator(Field->getIdentifier(), DotLoc,
1121                                        FieldLoc));
1122       Designators.back().setField(Field);
1123       break;
1124     }
1125 
1126     case DESIG_FIELD_NAME: {
1127       const IdentifierInfo *Name = Record.readIdentifier();
1128       SourceLocation DotLoc = readSourceLocation();
1129       SourceLocation FieldLoc = readSourceLocation();
1130       Designators.push_back(Designator(Name, DotLoc, FieldLoc));
1131       break;
1132     }
1133 
1134     case DESIG_ARRAY: {
1135       unsigned Index = Record.readInt();
1136       SourceLocation LBracketLoc = readSourceLocation();
1137       SourceLocation RBracketLoc = readSourceLocation();
1138       Designators.push_back(Designator(Index, LBracketLoc, RBracketLoc));
1139       break;
1140     }
1141 
1142     case DESIG_ARRAY_RANGE: {
1143       unsigned Index = Record.readInt();
1144       SourceLocation LBracketLoc = readSourceLocation();
1145       SourceLocation EllipsisLoc = readSourceLocation();
1146       SourceLocation RBracketLoc = readSourceLocation();
1147       Designators.push_back(Designator(Index, LBracketLoc, EllipsisLoc,
1148                                        RBracketLoc));
1149       break;
1150     }
1151     }
1152   }
1153   E->setDesignators(Record.getContext(),
1154                     Designators.data(), Designators.size());
1155 }
1156 
1157 void ASTStmtReader::VisitDesignatedInitUpdateExpr(DesignatedInitUpdateExpr *E) {
1158   VisitExpr(E);
1159   E->setBase(Record.readSubExpr());
1160   E->setUpdater(Record.readSubExpr());
1161 }
1162 
1163 void ASTStmtReader::VisitNoInitExpr(NoInitExpr *E) {
1164   VisitExpr(E);
1165 }
1166 
1167 void ASTStmtReader::VisitArrayInitLoopExpr(ArrayInitLoopExpr *E) {
1168   VisitExpr(E);
1169   E->SubExprs[0] = Record.readSubExpr();
1170   E->SubExprs[1] = Record.readSubExpr();
1171 }
1172 
1173 void ASTStmtReader::VisitArrayInitIndexExpr(ArrayInitIndexExpr *E) {
1174   VisitExpr(E);
1175 }
1176 
1177 void ASTStmtReader::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
1178   VisitExpr(E);
1179 }
1180 
1181 void ASTStmtReader::VisitVAArgExpr(VAArgExpr *E) {
1182   VisitExpr(E);
1183   E->setSubExpr(Record.readSubExpr());
1184   E->setWrittenTypeInfo(readTypeSourceInfo());
1185   E->setBuiltinLoc(readSourceLocation());
1186   E->setRParenLoc(readSourceLocation());
1187   E->setIsMicrosoftABI(Record.readInt());
1188 }
1189 
1190 void ASTStmtReader::VisitSourceLocExpr(SourceLocExpr *E) {
1191   VisitExpr(E);
1192   E->ParentContext = readDeclAs<DeclContext>();
1193   E->BuiltinLoc = readSourceLocation();
1194   E->RParenLoc = readSourceLocation();
1195   E->SourceLocExprBits.Kind =
1196       static_cast<SourceLocExpr::IdentKind>(Record.readInt());
1197 }
1198 
1199 void ASTStmtReader::VisitAddrLabelExpr(AddrLabelExpr *E) {
1200   VisitExpr(E);
1201   E->setAmpAmpLoc(readSourceLocation());
1202   E->setLabelLoc(readSourceLocation());
1203   E->setLabel(readDeclAs<LabelDecl>());
1204 }
1205 
1206 void ASTStmtReader::VisitStmtExpr(StmtExpr *E) {
1207   VisitExpr(E);
1208   E->setLParenLoc(readSourceLocation());
1209   E->setRParenLoc(readSourceLocation());
1210   E->setSubStmt(cast_or_null<CompoundStmt>(Record.readSubStmt()));
1211   E->StmtExprBits.TemplateDepth = Record.readInt();
1212 }
1213 
1214 void ASTStmtReader::VisitChooseExpr(ChooseExpr *E) {
1215   VisitExpr(E);
1216   E->setCond(Record.readSubExpr());
1217   E->setLHS(Record.readSubExpr());
1218   E->setRHS(Record.readSubExpr());
1219   E->setBuiltinLoc(readSourceLocation());
1220   E->setRParenLoc(readSourceLocation());
1221   E->setIsConditionTrue(Record.readInt());
1222 }
1223 
1224 void ASTStmtReader::VisitGNUNullExpr(GNUNullExpr *E) {
1225   VisitExpr(E);
1226   E->setTokenLocation(readSourceLocation());
1227 }
1228 
1229 void ASTStmtReader::VisitShuffleVectorExpr(ShuffleVectorExpr *E) {
1230   VisitExpr(E);
1231   SmallVector<Expr *, 16> Exprs;
1232   unsigned NumExprs = Record.readInt();
1233   while (NumExprs--)
1234     Exprs.push_back(Record.readSubExpr());
1235   E->setExprs(Record.getContext(), Exprs);
1236   E->setBuiltinLoc(readSourceLocation());
1237   E->setRParenLoc(readSourceLocation());
1238 }
1239 
1240 void ASTStmtReader::VisitConvertVectorExpr(ConvertVectorExpr *E) {
1241   VisitExpr(E);
1242   E->BuiltinLoc = readSourceLocation();
1243   E->RParenLoc = readSourceLocation();
1244   E->TInfo = readTypeSourceInfo();
1245   E->SrcExpr = Record.readSubExpr();
1246 }
1247 
1248 void ASTStmtReader::VisitBlockExpr(BlockExpr *E) {
1249   VisitExpr(E);
1250   E->setBlockDecl(readDeclAs<BlockDecl>());
1251 }
1252 
1253 void ASTStmtReader::VisitGenericSelectionExpr(GenericSelectionExpr *E) {
1254   VisitExpr(E);
1255 
1256   unsigned NumAssocs = Record.readInt();
1257   assert(NumAssocs == E->getNumAssocs() && "Wrong NumAssocs!");
1258   E->ResultIndex = Record.readInt();
1259   E->GenericSelectionExprBits.GenericLoc = readSourceLocation();
1260   E->DefaultLoc = readSourceLocation();
1261   E->RParenLoc = readSourceLocation();
1262 
1263   Stmt **Stmts = E->getTrailingObjects<Stmt *>();
1264   // Add 1 to account for the controlling expression which is the first
1265   // expression in the trailing array of Stmt *. This is not needed for
1266   // the trailing array of TypeSourceInfo *.
1267   for (unsigned I = 0, N = NumAssocs + 1; I < N; ++I)
1268     Stmts[I] = Record.readSubExpr();
1269 
1270   TypeSourceInfo **TSIs = E->getTrailingObjects<TypeSourceInfo *>();
1271   for (unsigned I = 0, N = NumAssocs; I < N; ++I)
1272     TSIs[I] = readTypeSourceInfo();
1273 }
1274 
1275 void ASTStmtReader::VisitPseudoObjectExpr(PseudoObjectExpr *E) {
1276   VisitExpr(E);
1277   unsigned numSemanticExprs = Record.readInt();
1278   assert(numSemanticExprs + 1 == E->PseudoObjectExprBits.NumSubExprs);
1279   E->PseudoObjectExprBits.ResultIndex = Record.readInt();
1280 
1281   // Read the syntactic expression.
1282   E->getSubExprsBuffer()[0] = Record.readSubExpr();
1283 
1284   // Read all the semantic expressions.
1285   for (unsigned i = 0; i != numSemanticExprs; ++i) {
1286     Expr *subExpr = Record.readSubExpr();
1287     E->getSubExprsBuffer()[i+1] = subExpr;
1288   }
1289 }
1290 
1291 void ASTStmtReader::VisitAtomicExpr(AtomicExpr *E) {
1292   VisitExpr(E);
1293   E->Op = AtomicExpr::AtomicOp(Record.readInt());
1294   E->NumSubExprs = AtomicExpr::getNumSubExprs(E->Op);
1295   for (unsigned I = 0; I != E->NumSubExprs; ++I)
1296     E->SubExprs[I] = Record.readSubExpr();
1297   E->BuiltinLoc = readSourceLocation();
1298   E->RParenLoc = readSourceLocation();
1299 }
1300 
1301 //===----------------------------------------------------------------------===//
1302 // Objective-C Expressions and Statements
1303 
1304 void ASTStmtReader::VisitObjCStringLiteral(ObjCStringLiteral *E) {
1305   VisitExpr(E);
1306   E->setString(cast<StringLiteral>(Record.readSubStmt()));
1307   E->setAtLoc(readSourceLocation());
1308 }
1309 
1310 void ASTStmtReader::VisitObjCBoxedExpr(ObjCBoxedExpr *E) {
1311   VisitExpr(E);
1312   // could be one of several IntegerLiteral, FloatLiteral, etc.
1313   E->SubExpr = Record.readSubStmt();
1314   E->BoxingMethod = readDeclAs<ObjCMethodDecl>();
1315   E->Range = readSourceRange();
1316 }
1317 
1318 void ASTStmtReader::VisitObjCArrayLiteral(ObjCArrayLiteral *E) {
1319   VisitExpr(E);
1320   unsigned NumElements = Record.readInt();
1321   assert(NumElements == E->getNumElements() && "Wrong number of elements");
1322   Expr **Elements = E->getElements();
1323   for (unsigned I = 0, N = NumElements; I != N; ++I)
1324     Elements[I] = Record.readSubExpr();
1325   E->ArrayWithObjectsMethod = readDeclAs<ObjCMethodDecl>();
1326   E->Range = readSourceRange();
1327 }
1328 
1329 void ASTStmtReader::VisitObjCDictionaryLiteral(ObjCDictionaryLiteral *E) {
1330   VisitExpr(E);
1331   unsigned NumElements = Record.readInt();
1332   assert(NumElements == E->getNumElements() && "Wrong number of elements");
1333   bool HasPackExpansions = Record.readInt();
1334   assert(HasPackExpansions == E->HasPackExpansions &&"Pack expansion mismatch");
1335   auto *KeyValues =
1336       E->getTrailingObjects<ObjCDictionaryLiteral::KeyValuePair>();
1337   auto *Expansions =
1338       E->getTrailingObjects<ObjCDictionaryLiteral::ExpansionData>();
1339   for (unsigned I = 0; I != NumElements; ++I) {
1340     KeyValues[I].Key = Record.readSubExpr();
1341     KeyValues[I].Value = Record.readSubExpr();
1342     if (HasPackExpansions) {
1343       Expansions[I].EllipsisLoc = readSourceLocation();
1344       Expansions[I].NumExpansionsPlusOne = Record.readInt();
1345     }
1346   }
1347   E->DictWithObjectsMethod = readDeclAs<ObjCMethodDecl>();
1348   E->Range = readSourceRange();
1349 }
1350 
1351 void ASTStmtReader::VisitObjCEncodeExpr(ObjCEncodeExpr *E) {
1352   VisitExpr(E);
1353   E->setEncodedTypeSourceInfo(readTypeSourceInfo());
1354   E->setAtLoc(readSourceLocation());
1355   E->setRParenLoc(readSourceLocation());
1356 }
1357 
1358 void ASTStmtReader::VisitObjCSelectorExpr(ObjCSelectorExpr *E) {
1359   VisitExpr(E);
1360   E->setSelector(Record.readSelector());
1361   E->setAtLoc(readSourceLocation());
1362   E->setRParenLoc(readSourceLocation());
1363 }
1364 
1365 void ASTStmtReader::VisitObjCProtocolExpr(ObjCProtocolExpr *E) {
1366   VisitExpr(E);
1367   E->setProtocol(readDeclAs<ObjCProtocolDecl>());
1368   E->setAtLoc(readSourceLocation());
1369   E->ProtoLoc = readSourceLocation();
1370   E->setRParenLoc(readSourceLocation());
1371 }
1372 
1373 void ASTStmtReader::VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
1374   VisitExpr(E);
1375   E->setDecl(readDeclAs<ObjCIvarDecl>());
1376   E->setLocation(readSourceLocation());
1377   E->setOpLoc(readSourceLocation());
1378   E->setBase(Record.readSubExpr());
1379   E->setIsArrow(Record.readInt());
1380   E->setIsFreeIvar(Record.readInt());
1381 }
1382 
1383 void ASTStmtReader::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
1384   VisitExpr(E);
1385   unsigned MethodRefFlags = Record.readInt();
1386   bool Implicit = Record.readInt() != 0;
1387   if (Implicit) {
1388     auto *Getter = readDeclAs<ObjCMethodDecl>();
1389     auto *Setter = readDeclAs<ObjCMethodDecl>();
1390     E->setImplicitProperty(Getter, Setter, MethodRefFlags);
1391   } else {
1392     E->setExplicitProperty(readDeclAs<ObjCPropertyDecl>(), MethodRefFlags);
1393   }
1394   E->setLocation(readSourceLocation());
1395   E->setReceiverLocation(readSourceLocation());
1396   switch (Record.readInt()) {
1397   case 0:
1398     E->setBase(Record.readSubExpr());
1399     break;
1400   case 1:
1401     E->setSuperReceiver(Record.readType());
1402     break;
1403   case 2:
1404     E->setClassReceiver(readDeclAs<ObjCInterfaceDecl>());
1405     break;
1406   }
1407 }
1408 
1409 void ASTStmtReader::VisitObjCSubscriptRefExpr(ObjCSubscriptRefExpr *E) {
1410   VisitExpr(E);
1411   E->setRBracket(readSourceLocation());
1412   E->setBaseExpr(Record.readSubExpr());
1413   E->setKeyExpr(Record.readSubExpr());
1414   E->GetAtIndexMethodDecl = readDeclAs<ObjCMethodDecl>();
1415   E->SetAtIndexMethodDecl = readDeclAs<ObjCMethodDecl>();
1416 }
1417 
1418 void ASTStmtReader::VisitObjCMessageExpr(ObjCMessageExpr *E) {
1419   VisitExpr(E);
1420   assert(Record.peekInt() == E->getNumArgs());
1421   Record.skipInts(1);
1422   unsigned NumStoredSelLocs = Record.readInt();
1423   E->SelLocsKind = Record.readInt();
1424   E->setDelegateInitCall(Record.readInt());
1425   E->IsImplicit = Record.readInt();
1426   auto Kind = static_cast<ObjCMessageExpr::ReceiverKind>(Record.readInt());
1427   switch (Kind) {
1428   case ObjCMessageExpr::Instance:
1429     E->setInstanceReceiver(Record.readSubExpr());
1430     break;
1431 
1432   case ObjCMessageExpr::Class:
1433     E->setClassReceiver(readTypeSourceInfo());
1434     break;
1435 
1436   case ObjCMessageExpr::SuperClass:
1437   case ObjCMessageExpr::SuperInstance: {
1438     QualType T = Record.readType();
1439     SourceLocation SuperLoc = readSourceLocation();
1440     E->setSuper(SuperLoc, T, Kind == ObjCMessageExpr::SuperInstance);
1441     break;
1442   }
1443   }
1444 
1445   assert(Kind == E->getReceiverKind());
1446 
1447   if (Record.readInt())
1448     E->setMethodDecl(readDeclAs<ObjCMethodDecl>());
1449   else
1450     E->setSelector(Record.readSelector());
1451 
1452   E->LBracLoc = readSourceLocation();
1453   E->RBracLoc = readSourceLocation();
1454 
1455   for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
1456     E->setArg(I, Record.readSubExpr());
1457 
1458   SourceLocation *Locs = E->getStoredSelLocs();
1459   for (unsigned I = 0; I != NumStoredSelLocs; ++I)
1460     Locs[I] = readSourceLocation();
1461 }
1462 
1463 void ASTStmtReader::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) {
1464   VisitStmt(S);
1465   S->setElement(Record.readSubStmt());
1466   S->setCollection(Record.readSubExpr());
1467   S->setBody(Record.readSubStmt());
1468   S->setForLoc(readSourceLocation());
1469   S->setRParenLoc(readSourceLocation());
1470 }
1471 
1472 void ASTStmtReader::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) {
1473   VisitStmt(S);
1474   S->setCatchBody(Record.readSubStmt());
1475   S->setCatchParamDecl(readDeclAs<VarDecl>());
1476   S->setAtCatchLoc(readSourceLocation());
1477   S->setRParenLoc(readSourceLocation());
1478 }
1479 
1480 void ASTStmtReader::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
1481   VisitStmt(S);
1482   S->setFinallyBody(Record.readSubStmt());
1483   S->setAtFinallyLoc(readSourceLocation());
1484 }
1485 
1486 void ASTStmtReader::VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S) {
1487   VisitStmt(S); // FIXME: no test coverage.
1488   S->setSubStmt(Record.readSubStmt());
1489   S->setAtLoc(readSourceLocation());
1490 }
1491 
1492 void ASTStmtReader::VisitObjCAtTryStmt(ObjCAtTryStmt *S) {
1493   VisitStmt(S);
1494   assert(Record.peekInt() == S->getNumCatchStmts());
1495   Record.skipInts(1);
1496   bool HasFinally = Record.readInt();
1497   S->setTryBody(Record.readSubStmt());
1498   for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I)
1499     S->setCatchStmt(I, cast_or_null<ObjCAtCatchStmt>(Record.readSubStmt()));
1500 
1501   if (HasFinally)
1502     S->setFinallyStmt(Record.readSubStmt());
1503   S->setAtTryLoc(readSourceLocation());
1504 }
1505 
1506 void ASTStmtReader::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S) {
1507   VisitStmt(S); // FIXME: no test coverage.
1508   S->setSynchExpr(Record.readSubStmt());
1509   S->setSynchBody(Record.readSubStmt());
1510   S->setAtSynchronizedLoc(readSourceLocation());
1511 }
1512 
1513 void ASTStmtReader::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) {
1514   VisitStmt(S); // FIXME: no test coverage.
1515   S->setThrowExpr(Record.readSubStmt());
1516   S->setThrowLoc(readSourceLocation());
1517 }
1518 
1519 void ASTStmtReader::VisitObjCBoolLiteralExpr(ObjCBoolLiteralExpr *E) {
1520   VisitExpr(E);
1521   E->setValue(Record.readInt());
1522   E->setLocation(readSourceLocation());
1523 }
1524 
1525 void ASTStmtReader::VisitObjCAvailabilityCheckExpr(ObjCAvailabilityCheckExpr *E) {
1526   VisitExpr(E);
1527   SourceRange R = Record.readSourceRange();
1528   E->AtLoc = R.getBegin();
1529   E->RParen = R.getEnd();
1530   E->VersionToCheck = Record.readVersionTuple();
1531 }
1532 
1533 //===----------------------------------------------------------------------===//
1534 // C++ Expressions and Statements
1535 //===----------------------------------------------------------------------===//
1536 
1537 void ASTStmtReader::VisitCXXCatchStmt(CXXCatchStmt *S) {
1538   VisitStmt(S);
1539   S->CatchLoc = readSourceLocation();
1540   S->ExceptionDecl = readDeclAs<VarDecl>();
1541   S->HandlerBlock = Record.readSubStmt();
1542 }
1543 
1544 void ASTStmtReader::VisitCXXTryStmt(CXXTryStmt *S) {
1545   VisitStmt(S);
1546   assert(Record.peekInt() == S->getNumHandlers() && "NumStmtFields is wrong ?");
1547   Record.skipInts(1);
1548   S->TryLoc = readSourceLocation();
1549   S->getStmts()[0] = Record.readSubStmt();
1550   for (unsigned i = 0, e = S->getNumHandlers(); i != e; ++i)
1551     S->getStmts()[i + 1] = Record.readSubStmt();
1552 }
1553 
1554 void ASTStmtReader::VisitCXXForRangeStmt(CXXForRangeStmt *S) {
1555   VisitStmt(S);
1556   S->ForLoc = readSourceLocation();
1557   S->CoawaitLoc = readSourceLocation();
1558   S->ColonLoc = readSourceLocation();
1559   S->RParenLoc = readSourceLocation();
1560   S->setInit(Record.readSubStmt());
1561   S->setRangeStmt(Record.readSubStmt());
1562   S->setBeginStmt(Record.readSubStmt());
1563   S->setEndStmt(Record.readSubStmt());
1564   S->setCond(Record.readSubExpr());
1565   S->setInc(Record.readSubExpr());
1566   S->setLoopVarStmt(Record.readSubStmt());
1567   S->setBody(Record.readSubStmt());
1568 }
1569 
1570 void ASTStmtReader::VisitMSDependentExistsStmt(MSDependentExistsStmt *S) {
1571   VisitStmt(S);
1572   S->KeywordLoc = readSourceLocation();
1573   S->IsIfExists = Record.readInt();
1574   S->QualifierLoc = Record.readNestedNameSpecifierLoc();
1575   S->NameInfo = Record.readDeclarationNameInfo();
1576   S->SubStmt = Record.readSubStmt();
1577 }
1578 
1579 void ASTStmtReader::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
1580   VisitCallExpr(E);
1581   E->CXXOperatorCallExprBits.OperatorKind = Record.readInt();
1582   E->CXXOperatorCallExprBits.FPFeatures = Record.readInt();
1583   E->Range = Record.readSourceRange();
1584 }
1585 
1586 void ASTStmtReader::VisitCXXRewrittenBinaryOperator(
1587     CXXRewrittenBinaryOperator *E) {
1588   VisitExpr(E);
1589   E->CXXRewrittenBinaryOperatorBits.IsReversed = Record.readInt();
1590   E->SemanticForm = Record.readSubExpr();
1591 }
1592 
1593 void ASTStmtReader::VisitCXXConstructExpr(CXXConstructExpr *E) {
1594   VisitExpr(E);
1595 
1596   unsigned NumArgs = Record.readInt();
1597   assert((NumArgs == E->getNumArgs()) && "Wrong NumArgs!");
1598 
1599   E->CXXConstructExprBits.Elidable = Record.readInt();
1600   E->CXXConstructExprBits.HadMultipleCandidates = Record.readInt();
1601   E->CXXConstructExprBits.ListInitialization = Record.readInt();
1602   E->CXXConstructExprBits.StdInitListInitialization = Record.readInt();
1603   E->CXXConstructExprBits.ZeroInitialization = Record.readInt();
1604   E->CXXConstructExprBits.ConstructionKind = Record.readInt();
1605   E->CXXConstructExprBits.Loc = readSourceLocation();
1606   E->Constructor = readDeclAs<CXXConstructorDecl>();
1607   E->ParenOrBraceRange = readSourceRange();
1608 
1609   for (unsigned I = 0; I != NumArgs; ++I)
1610     E->setArg(I, Record.readSubExpr());
1611 }
1612 
1613 void ASTStmtReader::VisitCXXInheritedCtorInitExpr(CXXInheritedCtorInitExpr *E) {
1614   VisitExpr(E);
1615   E->Constructor = readDeclAs<CXXConstructorDecl>();
1616   E->Loc = readSourceLocation();
1617   E->ConstructsVirtualBase = Record.readInt();
1618   E->InheritedFromVirtualBase = Record.readInt();
1619 }
1620 
1621 void ASTStmtReader::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E) {
1622   VisitCXXConstructExpr(E);
1623   E->TSI = readTypeSourceInfo();
1624 }
1625 
1626 void ASTStmtReader::VisitLambdaExpr(LambdaExpr *E) {
1627   VisitExpr(E);
1628   unsigned NumCaptures = Record.readInt();
1629   assert(NumCaptures == E->NumCaptures);(void)NumCaptures;
1630   E->IntroducerRange = readSourceRange();
1631   E->CaptureDefault = static_cast<LambdaCaptureDefault>(Record.readInt());
1632   E->CaptureDefaultLoc = readSourceLocation();
1633   E->ExplicitParams = Record.readInt();
1634   E->ExplicitResultType = Record.readInt();
1635   E->ClosingBrace = readSourceLocation();
1636 
1637   // Read capture initializers.
1638   for (LambdaExpr::capture_init_iterator C = E->capture_init_begin(),
1639                                       CEnd = E->capture_init_end();
1640        C != CEnd; ++C)
1641     *C = Record.readSubExpr();
1642 }
1643 
1644 void
1645 ASTStmtReader::VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E) {
1646   VisitExpr(E);
1647   E->SubExpr = Record.readSubExpr();
1648 }
1649 
1650 void ASTStmtReader::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) {
1651   VisitExplicitCastExpr(E);
1652   SourceRange R = readSourceRange();
1653   E->Loc = R.getBegin();
1654   E->RParenLoc = R.getEnd();
1655   R = readSourceRange();
1656   E->AngleBrackets = R;
1657 }
1658 
1659 void ASTStmtReader::VisitCXXStaticCastExpr(CXXStaticCastExpr *E) {
1660   return VisitCXXNamedCastExpr(E);
1661 }
1662 
1663 void ASTStmtReader::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *E) {
1664   return VisitCXXNamedCastExpr(E);
1665 }
1666 
1667 void ASTStmtReader::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *E) {
1668   return VisitCXXNamedCastExpr(E);
1669 }
1670 
1671 void ASTStmtReader::VisitCXXConstCastExpr(CXXConstCastExpr *E) {
1672   return VisitCXXNamedCastExpr(E);
1673 }
1674 
1675 void ASTStmtReader::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E) {
1676   VisitExplicitCastExpr(E);
1677   E->setLParenLoc(readSourceLocation());
1678   E->setRParenLoc(readSourceLocation());
1679 }
1680 
1681 void ASTStmtReader::VisitBuiltinBitCastExpr(BuiltinBitCastExpr *E) {
1682   VisitExplicitCastExpr(E);
1683   E->KWLoc = readSourceLocation();
1684   E->RParenLoc = readSourceLocation();
1685 }
1686 
1687 void ASTStmtReader::VisitUserDefinedLiteral(UserDefinedLiteral *E) {
1688   VisitCallExpr(E);
1689   E->UDSuffixLoc = readSourceLocation();
1690 }
1691 
1692 void ASTStmtReader::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
1693   VisitExpr(E);
1694   E->setValue(Record.readInt());
1695   E->setLocation(readSourceLocation());
1696 }
1697 
1698 void ASTStmtReader::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) {
1699   VisitExpr(E);
1700   E->setLocation(readSourceLocation());
1701 }
1702 
1703 void ASTStmtReader::VisitCXXTypeidExpr(CXXTypeidExpr *E) {
1704   VisitExpr(E);
1705   E->setSourceRange(readSourceRange());
1706   if (E->isTypeOperand()) { // typeid(int)
1707     E->setTypeOperandSourceInfo(
1708         readTypeSourceInfo());
1709     return;
1710   }
1711 
1712   // typeid(42+2)
1713   E->setExprOperand(Record.readSubExpr());
1714 }
1715 
1716 void ASTStmtReader::VisitCXXThisExpr(CXXThisExpr *E) {
1717   VisitExpr(E);
1718   E->setLocation(readSourceLocation());
1719   E->setImplicit(Record.readInt());
1720 }
1721 
1722 void ASTStmtReader::VisitCXXThrowExpr(CXXThrowExpr *E) {
1723   VisitExpr(E);
1724   E->CXXThrowExprBits.ThrowLoc = readSourceLocation();
1725   E->Operand = Record.readSubExpr();
1726   E->CXXThrowExprBits.IsThrownVariableInScope = Record.readInt();
1727 }
1728 
1729 void ASTStmtReader::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
1730   VisitExpr(E);
1731   E->Param = readDeclAs<ParmVarDecl>();
1732   E->UsedContext = readDeclAs<DeclContext>();
1733   E->CXXDefaultArgExprBits.Loc = readSourceLocation();
1734 }
1735 
1736 void ASTStmtReader::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E) {
1737   VisitExpr(E);
1738   E->Field = readDeclAs<FieldDecl>();
1739   E->UsedContext = readDeclAs<DeclContext>();
1740   E->CXXDefaultInitExprBits.Loc = readSourceLocation();
1741 }
1742 
1743 void ASTStmtReader::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
1744   VisitExpr(E);
1745   E->setTemporary(Record.readCXXTemporary());
1746   E->setSubExpr(Record.readSubExpr());
1747 }
1748 
1749 void ASTStmtReader::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
1750   VisitExpr(E);
1751   E->TypeInfo = readTypeSourceInfo();
1752   E->CXXScalarValueInitExprBits.RParenLoc = readSourceLocation();
1753 }
1754 
1755 void ASTStmtReader::VisitCXXNewExpr(CXXNewExpr *E) {
1756   VisitExpr(E);
1757 
1758   bool IsArray = Record.readInt();
1759   bool HasInit = Record.readInt();
1760   unsigned NumPlacementArgs = Record.readInt();
1761   bool IsParenTypeId = Record.readInt();
1762 
1763   E->CXXNewExprBits.IsGlobalNew = Record.readInt();
1764   E->CXXNewExprBits.ShouldPassAlignment = Record.readInt();
1765   E->CXXNewExprBits.UsualArrayDeleteWantsSize = Record.readInt();
1766   E->CXXNewExprBits.StoredInitializationStyle = Record.readInt();
1767 
1768   assert((IsArray == E->isArray()) && "Wrong IsArray!");
1769   assert((HasInit == E->hasInitializer()) && "Wrong HasInit!");
1770   assert((NumPlacementArgs == E->getNumPlacementArgs()) &&
1771          "Wrong NumPlacementArgs!");
1772   assert((IsParenTypeId == E->isParenTypeId()) && "Wrong IsParenTypeId!");
1773   (void)IsArray;
1774   (void)HasInit;
1775   (void)NumPlacementArgs;
1776 
1777   E->setOperatorNew(readDeclAs<FunctionDecl>());
1778   E->setOperatorDelete(readDeclAs<FunctionDecl>());
1779   E->AllocatedTypeInfo = readTypeSourceInfo();
1780   if (IsParenTypeId)
1781     E->getTrailingObjects<SourceRange>()[0] = readSourceRange();
1782   E->Range = readSourceRange();
1783   E->DirectInitRange = readSourceRange();
1784 
1785   // Install all the subexpressions.
1786   for (CXXNewExpr::raw_arg_iterator I = E->raw_arg_begin(),
1787                                     N = E->raw_arg_end();
1788        I != N; ++I)
1789     *I = Record.readSubStmt();
1790 }
1791 
1792 void ASTStmtReader::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
1793   VisitExpr(E);
1794   E->CXXDeleteExprBits.GlobalDelete = Record.readInt();
1795   E->CXXDeleteExprBits.ArrayForm = Record.readInt();
1796   E->CXXDeleteExprBits.ArrayFormAsWritten = Record.readInt();
1797   E->CXXDeleteExprBits.UsualArrayDeleteWantsSize = Record.readInt();
1798   E->OperatorDelete = readDeclAs<FunctionDecl>();
1799   E->Argument = Record.readSubExpr();
1800   E->CXXDeleteExprBits.Loc = readSourceLocation();
1801 }
1802 
1803 void ASTStmtReader::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) {
1804   VisitExpr(E);
1805 
1806   E->Base = Record.readSubExpr();
1807   E->IsArrow = Record.readInt();
1808   E->OperatorLoc = readSourceLocation();
1809   E->QualifierLoc = Record.readNestedNameSpecifierLoc();
1810   E->ScopeType = readTypeSourceInfo();
1811   E->ColonColonLoc = readSourceLocation();
1812   E->TildeLoc = readSourceLocation();
1813 
1814   IdentifierInfo *II = Record.readIdentifier();
1815   if (II)
1816     E->setDestroyedType(II, readSourceLocation());
1817   else
1818     E->setDestroyedType(readTypeSourceInfo());
1819 }
1820 
1821 void ASTStmtReader::VisitExprWithCleanups(ExprWithCleanups *E) {
1822   VisitExpr(E);
1823 
1824   unsigned NumObjects = Record.readInt();
1825   assert(NumObjects == E->getNumObjects());
1826   for (unsigned i = 0; i != NumObjects; ++i) {
1827     unsigned CleanupKind = Record.readInt();
1828     ExprWithCleanups::CleanupObject Obj;
1829     if (CleanupKind == COK_Block)
1830       Obj = readDeclAs<BlockDecl>();
1831     else if (CleanupKind == COK_CompoundLiteral)
1832       Obj = cast<CompoundLiteralExpr>(Record.readSubExpr());
1833     else
1834       llvm_unreachable("unexpected cleanup object type");
1835     E->getTrailingObjects<ExprWithCleanups::CleanupObject>()[i] = Obj;
1836   }
1837 
1838   E->ExprWithCleanupsBits.CleanupsHaveSideEffects = Record.readInt();
1839   E->SubExpr = Record.readSubExpr();
1840 }
1841 
1842 void ASTStmtReader::VisitCXXDependentScopeMemberExpr(
1843     CXXDependentScopeMemberExpr *E) {
1844   VisitExpr(E);
1845 
1846   bool HasTemplateKWAndArgsInfo = Record.readInt();
1847   unsigned NumTemplateArgs = Record.readInt();
1848   bool HasFirstQualifierFoundInScope = Record.readInt();
1849 
1850   assert((HasTemplateKWAndArgsInfo == E->hasTemplateKWAndArgsInfo()) &&
1851          "Wrong HasTemplateKWAndArgsInfo!");
1852   assert(
1853       (HasFirstQualifierFoundInScope == E->hasFirstQualifierFoundInScope()) &&
1854       "Wrong HasFirstQualifierFoundInScope!");
1855 
1856   if (HasTemplateKWAndArgsInfo)
1857     ReadTemplateKWAndArgsInfo(
1858         *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(),
1859         E->getTrailingObjects<TemplateArgumentLoc>(), NumTemplateArgs);
1860 
1861   assert((NumTemplateArgs == E->getNumTemplateArgs()) &&
1862          "Wrong NumTemplateArgs!");
1863 
1864   E->CXXDependentScopeMemberExprBits.IsArrow = Record.readInt();
1865   E->CXXDependentScopeMemberExprBits.OperatorLoc = readSourceLocation();
1866   E->BaseType = Record.readType();
1867   E->QualifierLoc = Record.readNestedNameSpecifierLoc();
1868   E->Base = Record.readSubExpr();
1869 
1870   if (HasFirstQualifierFoundInScope)
1871     *E->getTrailingObjects<NamedDecl *>() = readDeclAs<NamedDecl>();
1872 
1873   E->MemberNameInfo = Record.readDeclarationNameInfo();
1874 }
1875 
1876 void
1877 ASTStmtReader::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) {
1878   VisitExpr(E);
1879 
1880   if (Record.readInt()) // HasTemplateKWAndArgsInfo
1881     ReadTemplateKWAndArgsInfo(
1882         *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(),
1883         E->getTrailingObjects<TemplateArgumentLoc>(),
1884         /*NumTemplateArgs=*/Record.readInt());
1885 
1886   E->QualifierLoc = Record.readNestedNameSpecifierLoc();
1887   E->NameInfo = Record.readDeclarationNameInfo();
1888 }
1889 
1890 void
1891 ASTStmtReader::VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E) {
1892   VisitExpr(E);
1893   assert(Record.peekInt() == E->arg_size() &&
1894          "Read wrong record during creation ?");
1895   Record.skipInts(1);
1896   for (unsigned I = 0, N = E->arg_size(); I != N; ++I)
1897     E->setArg(I, Record.readSubExpr());
1898   E->TSI = readTypeSourceInfo();
1899   E->setLParenLoc(readSourceLocation());
1900   E->setRParenLoc(readSourceLocation());
1901 }
1902 
1903 void ASTStmtReader::VisitOverloadExpr(OverloadExpr *E) {
1904   VisitExpr(E);
1905 
1906   unsigned NumResults = Record.readInt();
1907   bool HasTemplateKWAndArgsInfo = Record.readInt();
1908   assert((E->getNumDecls() == NumResults) && "Wrong NumResults!");
1909   assert((E->hasTemplateKWAndArgsInfo() == HasTemplateKWAndArgsInfo) &&
1910          "Wrong HasTemplateKWAndArgsInfo!");
1911 
1912   if (HasTemplateKWAndArgsInfo) {
1913     unsigned NumTemplateArgs = Record.readInt();
1914     ReadTemplateKWAndArgsInfo(*E->getTrailingASTTemplateKWAndArgsInfo(),
1915                               E->getTrailingTemplateArgumentLoc(),
1916                               NumTemplateArgs);
1917     assert((E->getNumTemplateArgs() == NumTemplateArgs) &&
1918            "Wrong NumTemplateArgs!");
1919   }
1920 
1921   UnresolvedSet<8> Decls;
1922   for (unsigned I = 0; I != NumResults; ++I) {
1923     auto *D = readDeclAs<NamedDecl>();
1924     auto AS = (AccessSpecifier)Record.readInt();
1925     Decls.addDecl(D, AS);
1926   }
1927 
1928   DeclAccessPair *Results = E->getTrailingResults();
1929   UnresolvedSetIterator Iter = Decls.begin();
1930   for (unsigned I = 0; I != NumResults; ++I) {
1931     Results[I] = (Iter + I).getPair();
1932   }
1933 
1934   E->NameInfo = Record.readDeclarationNameInfo();
1935   E->QualifierLoc = Record.readNestedNameSpecifierLoc();
1936 }
1937 
1938 void ASTStmtReader::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) {
1939   VisitOverloadExpr(E);
1940   E->UnresolvedMemberExprBits.IsArrow = Record.readInt();
1941   E->UnresolvedMemberExprBits.HasUnresolvedUsing = Record.readInt();
1942   E->Base = Record.readSubExpr();
1943   E->BaseType = Record.readType();
1944   E->OperatorLoc = readSourceLocation();
1945 }
1946 
1947 void ASTStmtReader::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) {
1948   VisitOverloadExpr(E);
1949   E->UnresolvedLookupExprBits.RequiresADL = Record.readInt();
1950   E->UnresolvedLookupExprBits.Overloaded = Record.readInt();
1951   E->NamingClass = readDeclAs<CXXRecordDecl>();
1952 }
1953 
1954 void ASTStmtReader::VisitTypeTraitExpr(TypeTraitExpr *E) {
1955   VisitExpr(E);
1956   E->TypeTraitExprBits.NumArgs = Record.readInt();
1957   E->TypeTraitExprBits.Kind = Record.readInt();
1958   E->TypeTraitExprBits.Value = Record.readInt();
1959   SourceRange Range = readSourceRange();
1960   E->Loc = Range.getBegin();
1961   E->RParenLoc = Range.getEnd();
1962 
1963   auto **Args = E->getTrailingObjects<TypeSourceInfo *>();
1964   for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
1965     Args[I] = readTypeSourceInfo();
1966 }
1967 
1968 void ASTStmtReader::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
1969   VisitExpr(E);
1970   E->ATT = (ArrayTypeTrait)Record.readInt();
1971   E->Value = (unsigned int)Record.readInt();
1972   SourceRange Range = readSourceRange();
1973   E->Loc = Range.getBegin();
1974   E->RParen = Range.getEnd();
1975   E->QueriedType = readTypeSourceInfo();
1976   E->Dimension = Record.readSubExpr();
1977 }
1978 
1979 void ASTStmtReader::VisitExpressionTraitExpr(ExpressionTraitExpr *E) {
1980   VisitExpr(E);
1981   E->ET = (ExpressionTrait)Record.readInt();
1982   E->Value = (bool)Record.readInt();
1983   SourceRange Range = readSourceRange();
1984   E->QueriedExpression = Record.readSubExpr();
1985   E->Loc = Range.getBegin();
1986   E->RParen = Range.getEnd();
1987 }
1988 
1989 void ASTStmtReader::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) {
1990   VisitExpr(E);
1991   E->CXXNoexceptExprBits.Value = Record.readInt();
1992   E->Range = readSourceRange();
1993   E->Operand = Record.readSubExpr();
1994 }
1995 
1996 void ASTStmtReader::VisitPackExpansionExpr(PackExpansionExpr *E) {
1997   VisitExpr(E);
1998   E->EllipsisLoc = readSourceLocation();
1999   E->NumExpansions = Record.readInt();
2000   E->Pattern = Record.readSubExpr();
2001 }
2002 
2003 void ASTStmtReader::VisitSizeOfPackExpr(SizeOfPackExpr *E) {
2004   VisitExpr(E);
2005   unsigned NumPartialArgs = Record.readInt();
2006   E->OperatorLoc = readSourceLocation();
2007   E->PackLoc = readSourceLocation();
2008   E->RParenLoc = readSourceLocation();
2009   E->Pack = Record.readDeclAs<NamedDecl>();
2010   if (E->isPartiallySubstituted()) {
2011     assert(E->Length == NumPartialArgs);
2012     for (auto *I = E->getTrailingObjects<TemplateArgument>(),
2013               *E = I + NumPartialArgs;
2014          I != E; ++I)
2015       new (I) TemplateArgument(Record.readTemplateArgument());
2016   } else if (!E->isValueDependent()) {
2017     E->Length = Record.readInt();
2018   }
2019 }
2020 
2021 void ASTStmtReader::VisitSubstNonTypeTemplateParmExpr(
2022                                               SubstNonTypeTemplateParmExpr *E) {
2023   VisitExpr(E);
2024   E->Param = readDeclAs<NonTypeTemplateParmDecl>();
2025   E->SubstNonTypeTemplateParmExprBits.NameLoc = readSourceLocation();
2026   E->Replacement = Record.readSubExpr();
2027 }
2028 
2029 void ASTStmtReader::VisitSubstNonTypeTemplateParmPackExpr(
2030                                           SubstNonTypeTemplateParmPackExpr *E) {
2031   VisitExpr(E);
2032   E->Param = readDeclAs<NonTypeTemplateParmDecl>();
2033   TemplateArgument ArgPack = Record.readTemplateArgument();
2034   if (ArgPack.getKind() != TemplateArgument::Pack)
2035     return;
2036 
2037   E->Arguments = ArgPack.pack_begin();
2038   E->NumArguments = ArgPack.pack_size();
2039   E->NameLoc = readSourceLocation();
2040 }
2041 
2042 void ASTStmtReader::VisitFunctionParmPackExpr(FunctionParmPackExpr *E) {
2043   VisitExpr(E);
2044   E->NumParameters = Record.readInt();
2045   E->ParamPack = readDeclAs<ParmVarDecl>();
2046   E->NameLoc = readSourceLocation();
2047   auto **Parms = E->getTrailingObjects<VarDecl *>();
2048   for (unsigned i = 0, n = E->NumParameters; i != n; ++i)
2049     Parms[i] = readDeclAs<VarDecl>();
2050 }
2051 
2052 void ASTStmtReader::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) {
2053   VisitExpr(E);
2054   bool HasMaterialzedDecl = Record.readInt();
2055   if (HasMaterialzedDecl)
2056     E->State = cast<LifetimeExtendedTemporaryDecl>(Record.readDecl());
2057   else
2058     E->State = Record.readSubExpr();
2059 }
2060 
2061 void ASTStmtReader::VisitCXXFoldExpr(CXXFoldExpr *E) {
2062   VisitExpr(E);
2063   E->LParenLoc = readSourceLocation();
2064   E->EllipsisLoc = readSourceLocation();
2065   E->RParenLoc = readSourceLocation();
2066   E->NumExpansions = Record.readInt();
2067   E->SubExprs[0] = Record.readSubExpr();
2068   E->SubExprs[1] = Record.readSubExpr();
2069   E->Opcode = (BinaryOperatorKind)Record.readInt();
2070 }
2071 
2072 void ASTStmtReader::VisitOpaqueValueExpr(OpaqueValueExpr *E) {
2073   VisitExpr(E);
2074   E->SourceExpr = Record.readSubExpr();
2075   E->OpaqueValueExprBits.Loc = readSourceLocation();
2076   E->setIsUnique(Record.readInt());
2077 }
2078 
2079 void ASTStmtReader::VisitTypoExpr(TypoExpr *E) {
2080   llvm_unreachable("Cannot read TypoExpr nodes");
2081 }
2082 
2083 //===----------------------------------------------------------------------===//
2084 // Microsoft Expressions and Statements
2085 //===----------------------------------------------------------------------===//
2086 void ASTStmtReader::VisitMSPropertyRefExpr(MSPropertyRefExpr *E) {
2087   VisitExpr(E);
2088   E->IsArrow = (Record.readInt() != 0);
2089   E->BaseExpr = Record.readSubExpr();
2090   E->QualifierLoc = Record.readNestedNameSpecifierLoc();
2091   E->MemberLoc = readSourceLocation();
2092   E->TheDecl = readDeclAs<MSPropertyDecl>();
2093 }
2094 
2095 void ASTStmtReader::VisitMSPropertySubscriptExpr(MSPropertySubscriptExpr *E) {
2096   VisitExpr(E);
2097   E->setBase(Record.readSubExpr());
2098   E->setIdx(Record.readSubExpr());
2099   E->setRBracketLoc(readSourceLocation());
2100 }
2101 
2102 void ASTStmtReader::VisitCXXUuidofExpr(CXXUuidofExpr *E) {
2103   VisitExpr(E);
2104   E->setSourceRange(readSourceRange());
2105   std::string UuidStr = readString();
2106   E->setUuidStr(StringRef(UuidStr).copy(Record.getContext()));
2107   if (E->isTypeOperand()) { // __uuidof(ComType)
2108     E->setTypeOperandSourceInfo(
2109         readTypeSourceInfo());
2110     return;
2111   }
2112 
2113   // __uuidof(expr)
2114   E->setExprOperand(Record.readSubExpr());
2115 }
2116 
2117 void ASTStmtReader::VisitSEHLeaveStmt(SEHLeaveStmt *S) {
2118   VisitStmt(S);
2119   S->setLeaveLoc(readSourceLocation());
2120 }
2121 
2122 void ASTStmtReader::VisitSEHExceptStmt(SEHExceptStmt *S) {
2123   VisitStmt(S);
2124   S->Loc = readSourceLocation();
2125   S->Children[SEHExceptStmt::FILTER_EXPR] = Record.readSubStmt();
2126   S->Children[SEHExceptStmt::BLOCK] = Record.readSubStmt();
2127 }
2128 
2129 void ASTStmtReader::VisitSEHFinallyStmt(SEHFinallyStmt *S) {
2130   VisitStmt(S);
2131   S->Loc = readSourceLocation();
2132   S->Block = Record.readSubStmt();
2133 }
2134 
2135 void ASTStmtReader::VisitSEHTryStmt(SEHTryStmt *S) {
2136   VisitStmt(S);
2137   S->IsCXXTry = Record.readInt();
2138   S->TryLoc = readSourceLocation();
2139   S->Children[SEHTryStmt::TRY] = Record.readSubStmt();
2140   S->Children[SEHTryStmt::HANDLER] = Record.readSubStmt();
2141 }
2142 
2143 //===----------------------------------------------------------------------===//
2144 // CUDA Expressions and Statements
2145 //===----------------------------------------------------------------------===//
2146 
2147 void ASTStmtReader::VisitCUDAKernelCallExpr(CUDAKernelCallExpr *E) {
2148   VisitCallExpr(E);
2149   E->setPreArg(CUDAKernelCallExpr::CONFIG, Record.readSubExpr());
2150 }
2151 
2152 //===----------------------------------------------------------------------===//
2153 // OpenCL Expressions and Statements.
2154 //===----------------------------------------------------------------------===//
2155 void ASTStmtReader::VisitAsTypeExpr(AsTypeExpr *E) {
2156   VisitExpr(E);
2157   E->BuiltinLoc = readSourceLocation();
2158   E->RParenLoc = readSourceLocation();
2159   E->SrcExpr = Record.readSubExpr();
2160 }
2161 
2162 //===----------------------------------------------------------------------===//
2163 // OpenMP Directives.
2164 //===----------------------------------------------------------------------===//
2165 
2166 void ASTStmtReader::VisitOMPExecutableDirective(OMPExecutableDirective *E) {
2167   E->setLocStart(readSourceLocation());
2168   E->setLocEnd(readSourceLocation());
2169   SmallVector<OMPClause *, 5> Clauses;
2170   for (unsigned i = 0; i < E->getNumClauses(); ++i)
2171     Clauses.push_back(Record.readOMPClause());
2172   E->setClauses(Clauses);
2173   if (E->hasAssociatedStmt())
2174     E->setAssociatedStmt(Record.readSubStmt());
2175 }
2176 
2177 void ASTStmtReader::VisitOMPLoopDirective(OMPLoopDirective *D) {
2178   VisitStmt(D);
2179   // Two fields (NumClauses and CollapsedNum) were read in ReadStmtFromStream.
2180   Record.skipInts(2);
2181   VisitOMPExecutableDirective(D);
2182   D->setIterationVariable(Record.readSubExpr());
2183   D->setLastIteration(Record.readSubExpr());
2184   D->setCalcLastIteration(Record.readSubExpr());
2185   D->setPreCond(Record.readSubExpr());
2186   D->setCond(Record.readSubExpr());
2187   D->setInit(Record.readSubExpr());
2188   D->setInc(Record.readSubExpr());
2189   D->setPreInits(Record.readSubStmt());
2190   if (isOpenMPWorksharingDirective(D->getDirectiveKind()) ||
2191       isOpenMPTaskLoopDirective(D->getDirectiveKind()) ||
2192       isOpenMPDistributeDirective(D->getDirectiveKind())) {
2193     D->setIsLastIterVariable(Record.readSubExpr());
2194     D->setLowerBoundVariable(Record.readSubExpr());
2195     D->setUpperBoundVariable(Record.readSubExpr());
2196     D->setStrideVariable(Record.readSubExpr());
2197     D->setEnsureUpperBound(Record.readSubExpr());
2198     D->setNextLowerBound(Record.readSubExpr());
2199     D->setNextUpperBound(Record.readSubExpr());
2200     D->setNumIterations(Record.readSubExpr());
2201   }
2202   if (isOpenMPLoopBoundSharingDirective(D->getDirectiveKind())) {
2203     D->setPrevLowerBoundVariable(Record.readSubExpr());
2204     D->setPrevUpperBoundVariable(Record.readSubExpr());
2205     D->setDistInc(Record.readSubExpr());
2206     D->setPrevEnsureUpperBound(Record.readSubExpr());
2207     D->setCombinedLowerBoundVariable(Record.readSubExpr());
2208     D->setCombinedUpperBoundVariable(Record.readSubExpr());
2209     D->setCombinedEnsureUpperBound(Record.readSubExpr());
2210     D->setCombinedInit(Record.readSubExpr());
2211     D->setCombinedCond(Record.readSubExpr());
2212     D->setCombinedNextLowerBound(Record.readSubExpr());
2213     D->setCombinedNextUpperBound(Record.readSubExpr());
2214     D->setCombinedDistCond(Record.readSubExpr());
2215     D->setCombinedParForInDistCond(Record.readSubExpr());
2216   }
2217   SmallVector<Expr *, 4> Sub;
2218   unsigned CollapsedNum = D->getCollapsedNumber();
2219   Sub.reserve(CollapsedNum);
2220   for (unsigned i = 0; i < CollapsedNum; ++i)
2221     Sub.push_back(Record.readSubExpr());
2222   D->setCounters(Sub);
2223   Sub.clear();
2224   for (unsigned i = 0; i < CollapsedNum; ++i)
2225     Sub.push_back(Record.readSubExpr());
2226   D->setPrivateCounters(Sub);
2227   Sub.clear();
2228   for (unsigned i = 0; i < CollapsedNum; ++i)
2229     Sub.push_back(Record.readSubExpr());
2230   D->setInits(Sub);
2231   Sub.clear();
2232   for (unsigned i = 0; i < CollapsedNum; ++i)
2233     Sub.push_back(Record.readSubExpr());
2234   D->setUpdates(Sub);
2235   Sub.clear();
2236   for (unsigned i = 0; i < CollapsedNum; ++i)
2237     Sub.push_back(Record.readSubExpr());
2238   D->setFinals(Sub);
2239   Sub.clear();
2240   for (unsigned i = 0; i < CollapsedNum; ++i)
2241     Sub.push_back(Record.readSubExpr());
2242   D->setDependentCounters(Sub);
2243   Sub.clear();
2244   for (unsigned i = 0; i < CollapsedNum; ++i)
2245     Sub.push_back(Record.readSubExpr());
2246   D->setDependentInits(Sub);
2247   Sub.clear();
2248   for (unsigned i = 0; i < CollapsedNum; ++i)
2249     Sub.push_back(Record.readSubExpr());
2250   D->setFinalsConditions(Sub);
2251 }
2252 
2253 void ASTStmtReader::VisitOMPParallelDirective(OMPParallelDirective *D) {
2254   VisitStmt(D);
2255   // The NumClauses field was read in ReadStmtFromStream.
2256   Record.skipInts(1);
2257   VisitOMPExecutableDirective(D);
2258   D->setHasCancel(Record.readInt());
2259 }
2260 
2261 void ASTStmtReader::VisitOMPSimdDirective(OMPSimdDirective *D) {
2262   VisitOMPLoopDirective(D);
2263 }
2264 
2265 void ASTStmtReader::VisitOMPForDirective(OMPForDirective *D) {
2266   VisitOMPLoopDirective(D);
2267   D->setHasCancel(Record.readInt());
2268 }
2269 
2270 void ASTStmtReader::VisitOMPForSimdDirective(OMPForSimdDirective *D) {
2271   VisitOMPLoopDirective(D);
2272 }
2273 
2274 void ASTStmtReader::VisitOMPSectionsDirective(OMPSectionsDirective *D) {
2275   VisitStmt(D);
2276   // The NumClauses field was read in ReadStmtFromStream.
2277   Record.skipInts(1);
2278   VisitOMPExecutableDirective(D);
2279   D->setHasCancel(Record.readInt());
2280 }
2281 
2282 void ASTStmtReader::VisitOMPSectionDirective(OMPSectionDirective *D) {
2283   VisitStmt(D);
2284   VisitOMPExecutableDirective(D);
2285   D->setHasCancel(Record.readInt());
2286 }
2287 
2288 void ASTStmtReader::VisitOMPSingleDirective(OMPSingleDirective *D) {
2289   VisitStmt(D);
2290   // The NumClauses field was read in ReadStmtFromStream.
2291   Record.skipInts(1);
2292   VisitOMPExecutableDirective(D);
2293 }
2294 
2295 void ASTStmtReader::VisitOMPMasterDirective(OMPMasterDirective *D) {
2296   VisitStmt(D);
2297   VisitOMPExecutableDirective(D);
2298 }
2299 
2300 void ASTStmtReader::VisitOMPCriticalDirective(OMPCriticalDirective *D) {
2301   VisitStmt(D);
2302   // The NumClauses field was read in ReadStmtFromStream.
2303   Record.skipInts(1);
2304   VisitOMPExecutableDirective(D);
2305   D->DirName = Record.readDeclarationNameInfo();
2306 }
2307 
2308 void ASTStmtReader::VisitOMPParallelForDirective(OMPParallelForDirective *D) {
2309   VisitOMPLoopDirective(D);
2310   D->setHasCancel(Record.readInt());
2311 }
2312 
2313 void ASTStmtReader::VisitOMPParallelForSimdDirective(
2314     OMPParallelForSimdDirective *D) {
2315   VisitOMPLoopDirective(D);
2316 }
2317 
2318 void ASTStmtReader::VisitOMPParallelMasterDirective(
2319     OMPParallelMasterDirective *D) {
2320   VisitStmt(D);
2321   // The NumClauses field was read in ReadStmtFromStream.
2322   Record.skipInts(1);
2323   VisitOMPExecutableDirective(D);
2324 }
2325 
2326 void ASTStmtReader::VisitOMPParallelSectionsDirective(
2327     OMPParallelSectionsDirective *D) {
2328   VisitStmt(D);
2329   // The NumClauses field was read in ReadStmtFromStream.
2330   Record.skipInts(1);
2331   VisitOMPExecutableDirective(D);
2332   D->setHasCancel(Record.readInt());
2333 }
2334 
2335 void ASTStmtReader::VisitOMPTaskDirective(OMPTaskDirective *D) {
2336   VisitStmt(D);
2337   // The NumClauses field was read in ReadStmtFromStream.
2338   Record.skipInts(1);
2339   VisitOMPExecutableDirective(D);
2340   D->setHasCancel(Record.readInt());
2341 }
2342 
2343 void ASTStmtReader::VisitOMPTaskyieldDirective(OMPTaskyieldDirective *D) {
2344   VisitStmt(D);
2345   VisitOMPExecutableDirective(D);
2346 }
2347 
2348 void ASTStmtReader::VisitOMPBarrierDirective(OMPBarrierDirective *D) {
2349   VisitStmt(D);
2350   VisitOMPExecutableDirective(D);
2351 }
2352 
2353 void ASTStmtReader::VisitOMPTaskwaitDirective(OMPTaskwaitDirective *D) {
2354   VisitStmt(D);
2355   VisitOMPExecutableDirective(D);
2356 }
2357 
2358 void ASTStmtReader::VisitOMPTaskgroupDirective(OMPTaskgroupDirective *D) {
2359   VisitStmt(D);
2360   // The NumClauses field was read in ReadStmtFromStream.
2361   Record.skipInts(1);
2362   VisitOMPExecutableDirective(D);
2363   D->setReductionRef(Record.readSubExpr());
2364 }
2365 
2366 void ASTStmtReader::VisitOMPFlushDirective(OMPFlushDirective *D) {
2367   VisitStmt(D);
2368   // The NumClauses field was read in ReadStmtFromStream.
2369   Record.skipInts(1);
2370   VisitOMPExecutableDirective(D);
2371 }
2372 
2373 void ASTStmtReader::VisitOMPDepobjDirective(OMPDepobjDirective *D) {
2374   VisitStmt(D);
2375   // The NumClauses field was read in ReadStmtFromStream.
2376   Record.skipInts(1);
2377   VisitOMPExecutableDirective(D);
2378 }
2379 
2380 void ASTStmtReader::VisitOMPScanDirective(OMPScanDirective *D) {
2381   VisitStmt(D);
2382   // The NumClauses field was read in ReadStmtFromStream.
2383   Record.skipInts(1);
2384   VisitOMPExecutableDirective(D);
2385 }
2386 
2387 void ASTStmtReader::VisitOMPOrderedDirective(OMPOrderedDirective *D) {
2388   VisitStmt(D);
2389   // The NumClauses field was read in ReadStmtFromStream.
2390   Record.skipInts(1);
2391   VisitOMPExecutableDirective(D);
2392 }
2393 
2394 void ASTStmtReader::VisitOMPAtomicDirective(OMPAtomicDirective *D) {
2395   VisitStmt(D);
2396   // The NumClauses field was read in ReadStmtFromStream.
2397   Record.skipInts(1);
2398   VisitOMPExecutableDirective(D);
2399   D->setX(Record.readSubExpr());
2400   D->setV(Record.readSubExpr());
2401   D->setExpr(Record.readSubExpr());
2402   D->setUpdateExpr(Record.readSubExpr());
2403   D->IsXLHSInRHSPart = Record.readInt() != 0;
2404   D->IsPostfixUpdate = Record.readInt() != 0;
2405 }
2406 
2407 void ASTStmtReader::VisitOMPTargetDirective(OMPTargetDirective *D) {
2408   VisitStmt(D);
2409   // The NumClauses field was read in ReadStmtFromStream.
2410   Record.skipInts(1);
2411   VisitOMPExecutableDirective(D);
2412 }
2413 
2414 void ASTStmtReader::VisitOMPTargetDataDirective(OMPTargetDataDirective *D) {
2415   VisitStmt(D);
2416   Record.skipInts(1);
2417   VisitOMPExecutableDirective(D);
2418 }
2419 
2420 void ASTStmtReader::VisitOMPTargetEnterDataDirective(
2421     OMPTargetEnterDataDirective *D) {
2422   VisitStmt(D);
2423   Record.skipInts(1);
2424   VisitOMPExecutableDirective(D);
2425 }
2426 
2427 void ASTStmtReader::VisitOMPTargetExitDataDirective(
2428     OMPTargetExitDataDirective *D) {
2429   VisitStmt(D);
2430   Record.skipInts(1);
2431   VisitOMPExecutableDirective(D);
2432 }
2433 
2434 void ASTStmtReader::VisitOMPTargetParallelDirective(
2435     OMPTargetParallelDirective *D) {
2436   VisitStmt(D);
2437   Record.skipInts(1);
2438   VisitOMPExecutableDirective(D);
2439 }
2440 
2441 void ASTStmtReader::VisitOMPTargetParallelForDirective(
2442     OMPTargetParallelForDirective *D) {
2443   VisitOMPLoopDirective(D);
2444   D->setHasCancel(Record.readInt());
2445 }
2446 
2447 void ASTStmtReader::VisitOMPTeamsDirective(OMPTeamsDirective *D) {
2448   VisitStmt(D);
2449   // The NumClauses field was read in ReadStmtFromStream.
2450   Record.skipInts(1);
2451   VisitOMPExecutableDirective(D);
2452 }
2453 
2454 void ASTStmtReader::VisitOMPCancellationPointDirective(
2455     OMPCancellationPointDirective *D) {
2456   VisitStmt(D);
2457   VisitOMPExecutableDirective(D);
2458   D->setCancelRegion(static_cast<OpenMPDirectiveKind>(Record.readInt()));
2459 }
2460 
2461 void ASTStmtReader::VisitOMPCancelDirective(OMPCancelDirective *D) {
2462   VisitStmt(D);
2463   // The NumClauses field was read in ReadStmtFromStream.
2464   Record.skipInts(1);
2465   VisitOMPExecutableDirective(D);
2466   D->setCancelRegion(static_cast<OpenMPDirectiveKind>(Record.readInt()));
2467 }
2468 
2469 void ASTStmtReader::VisitOMPTaskLoopDirective(OMPTaskLoopDirective *D) {
2470   VisitOMPLoopDirective(D);
2471   D->setHasCancel(Record.readInt());
2472 }
2473 
2474 void ASTStmtReader::VisitOMPTaskLoopSimdDirective(OMPTaskLoopSimdDirective *D) {
2475   VisitOMPLoopDirective(D);
2476 }
2477 
2478 void ASTStmtReader::VisitOMPMasterTaskLoopDirective(
2479     OMPMasterTaskLoopDirective *D) {
2480   VisitOMPLoopDirective(D);
2481   D->setHasCancel(Record.readInt());
2482 }
2483 
2484 void ASTStmtReader::VisitOMPMasterTaskLoopSimdDirective(
2485     OMPMasterTaskLoopSimdDirective *D) {
2486   VisitOMPLoopDirective(D);
2487 }
2488 
2489 void ASTStmtReader::VisitOMPParallelMasterTaskLoopDirective(
2490     OMPParallelMasterTaskLoopDirective *D) {
2491   VisitOMPLoopDirective(D);
2492   D->setHasCancel(Record.readInt());
2493 }
2494 
2495 void ASTStmtReader::VisitOMPParallelMasterTaskLoopSimdDirective(
2496     OMPParallelMasterTaskLoopSimdDirective *D) {
2497   VisitOMPLoopDirective(D);
2498 }
2499 
2500 void ASTStmtReader::VisitOMPDistributeDirective(OMPDistributeDirective *D) {
2501   VisitOMPLoopDirective(D);
2502 }
2503 
2504 void ASTStmtReader::VisitOMPTargetUpdateDirective(OMPTargetUpdateDirective *D) {
2505   VisitStmt(D);
2506   Record.skipInts(1);
2507   VisitOMPExecutableDirective(D);
2508 }
2509 
2510 void ASTStmtReader::VisitOMPDistributeParallelForDirective(
2511     OMPDistributeParallelForDirective *D) {
2512   VisitOMPLoopDirective(D);
2513   D->setHasCancel(Record.readInt());
2514 }
2515 
2516 void ASTStmtReader::VisitOMPDistributeParallelForSimdDirective(
2517     OMPDistributeParallelForSimdDirective *D) {
2518   VisitOMPLoopDirective(D);
2519 }
2520 
2521 void ASTStmtReader::VisitOMPDistributeSimdDirective(
2522     OMPDistributeSimdDirective *D) {
2523   VisitOMPLoopDirective(D);
2524 }
2525 
2526 void ASTStmtReader::VisitOMPTargetParallelForSimdDirective(
2527     OMPTargetParallelForSimdDirective *D) {
2528   VisitOMPLoopDirective(D);
2529 }
2530 
2531 void ASTStmtReader::VisitOMPTargetSimdDirective(OMPTargetSimdDirective *D) {
2532   VisitOMPLoopDirective(D);
2533 }
2534 
2535 void ASTStmtReader::VisitOMPTeamsDistributeDirective(
2536     OMPTeamsDistributeDirective *D) {
2537   VisitOMPLoopDirective(D);
2538 }
2539 
2540 void ASTStmtReader::VisitOMPTeamsDistributeSimdDirective(
2541     OMPTeamsDistributeSimdDirective *D) {
2542   VisitOMPLoopDirective(D);
2543 }
2544 
2545 void ASTStmtReader::VisitOMPTeamsDistributeParallelForSimdDirective(
2546     OMPTeamsDistributeParallelForSimdDirective *D) {
2547   VisitOMPLoopDirective(D);
2548 }
2549 
2550 void ASTStmtReader::VisitOMPTeamsDistributeParallelForDirective(
2551     OMPTeamsDistributeParallelForDirective *D) {
2552   VisitOMPLoopDirective(D);
2553   D->setHasCancel(Record.readInt());
2554 }
2555 
2556 void ASTStmtReader::VisitOMPTargetTeamsDirective(OMPTargetTeamsDirective *D) {
2557   VisitStmt(D);
2558   // The NumClauses field was read in ReadStmtFromStream.
2559   Record.skipInts(1);
2560   VisitOMPExecutableDirective(D);
2561 }
2562 
2563 void ASTStmtReader::VisitOMPTargetTeamsDistributeDirective(
2564     OMPTargetTeamsDistributeDirective *D) {
2565   VisitOMPLoopDirective(D);
2566 }
2567 
2568 void ASTStmtReader::VisitOMPTargetTeamsDistributeParallelForDirective(
2569     OMPTargetTeamsDistributeParallelForDirective *D) {
2570   VisitOMPLoopDirective(D);
2571   D->setHasCancel(Record.readInt());
2572 }
2573 
2574 void ASTStmtReader::VisitOMPTargetTeamsDistributeParallelForSimdDirective(
2575     OMPTargetTeamsDistributeParallelForSimdDirective *D) {
2576   VisitOMPLoopDirective(D);
2577 }
2578 
2579 void ASTStmtReader::VisitOMPTargetTeamsDistributeSimdDirective(
2580     OMPTargetTeamsDistributeSimdDirective *D) {
2581   VisitOMPLoopDirective(D);
2582 }
2583 
2584 //===----------------------------------------------------------------------===//
2585 // ASTReader Implementation
2586 //===----------------------------------------------------------------------===//
2587 
2588 Stmt *ASTReader::ReadStmt(ModuleFile &F) {
2589   switch (ReadingKind) {
2590   case Read_None:
2591     llvm_unreachable("should not call this when not reading anything");
2592   case Read_Decl:
2593   case Read_Type:
2594     return ReadStmtFromStream(F);
2595   case Read_Stmt:
2596     return ReadSubStmt();
2597   }
2598 
2599   llvm_unreachable("ReadingKind not set ?");
2600 }
2601 
2602 Expr *ASTReader::ReadExpr(ModuleFile &F) {
2603   return cast_or_null<Expr>(ReadStmt(F));
2604 }
2605 
2606 Expr *ASTReader::ReadSubExpr() {
2607   return cast_or_null<Expr>(ReadSubStmt());
2608 }
2609 
2610 // Within the bitstream, expressions are stored in Reverse Polish
2611 // Notation, with each of the subexpressions preceding the
2612 // expression they are stored in. Subexpressions are stored from last to first.
2613 // To evaluate expressions, we continue reading expressions and placing them on
2614 // the stack, with expressions having operands removing those operands from the
2615 // stack. Evaluation terminates when we see a STMT_STOP record, and
2616 // the single remaining expression on the stack is our result.
2617 Stmt *ASTReader::ReadStmtFromStream(ModuleFile &F) {
2618   ReadingKindTracker ReadingKind(Read_Stmt, *this);
2619   llvm::BitstreamCursor &Cursor = F.DeclsCursor;
2620 
2621   // Map of offset to previously deserialized stmt. The offset points
2622   // just after the stmt record.
2623   llvm::DenseMap<uint64_t, Stmt *> StmtEntries;
2624 
2625 #ifndef NDEBUG
2626   unsigned PrevNumStmts = StmtStack.size();
2627 #endif
2628 
2629   ASTRecordReader Record(*this, F);
2630   ASTStmtReader Reader(Record, Cursor);
2631   Stmt::EmptyShell Empty;
2632 
2633   while (true) {
2634     llvm::Expected<llvm::BitstreamEntry> MaybeEntry =
2635         Cursor.advanceSkippingSubblocks();
2636     if (!MaybeEntry) {
2637       Error(toString(MaybeEntry.takeError()));
2638       return nullptr;
2639     }
2640     llvm::BitstreamEntry Entry = MaybeEntry.get();
2641 
2642     switch (Entry.Kind) {
2643     case llvm::BitstreamEntry::SubBlock: // Handled for us already.
2644     case llvm::BitstreamEntry::Error:
2645       Error("malformed block record in AST file");
2646       return nullptr;
2647     case llvm::BitstreamEntry::EndBlock:
2648       goto Done;
2649     case llvm::BitstreamEntry::Record:
2650       // The interesting case.
2651       break;
2652     }
2653 
2654     ASTContext &Context = getContext();
2655     Stmt *S = nullptr;
2656     bool Finished = false;
2657     bool IsStmtReference = false;
2658     Expected<unsigned> MaybeStmtCode = Record.readRecord(Cursor, Entry.ID);
2659     if (!MaybeStmtCode) {
2660       Error(toString(MaybeStmtCode.takeError()));
2661       return nullptr;
2662     }
2663     switch ((StmtCode)MaybeStmtCode.get()) {
2664     case STMT_STOP:
2665       Finished = true;
2666       break;
2667 
2668     case STMT_REF_PTR:
2669       IsStmtReference = true;
2670       assert(StmtEntries.find(Record[0]) != StmtEntries.end() &&
2671              "No stmt was recorded for this offset reference!");
2672       S = StmtEntries[Record.readInt()];
2673       break;
2674 
2675     case STMT_NULL_PTR:
2676       S = nullptr;
2677       break;
2678 
2679     case STMT_NULL:
2680       S = new (Context) NullStmt(Empty);
2681       break;
2682 
2683     case STMT_COMPOUND:
2684       S = CompoundStmt::CreateEmpty(
2685           Context, /*NumStmts=*/Record[ASTStmtReader::NumStmtFields]);
2686       break;
2687 
2688     case STMT_CASE:
2689       S = CaseStmt::CreateEmpty(
2690           Context,
2691           /*CaseStmtIsGNURange*/ Record[ASTStmtReader::NumStmtFields + 3]);
2692       break;
2693 
2694     case STMT_DEFAULT:
2695       S = new (Context) DefaultStmt(Empty);
2696       break;
2697 
2698     case STMT_LABEL:
2699       S = new (Context) LabelStmt(Empty);
2700       break;
2701 
2702     case STMT_ATTRIBUTED:
2703       S = AttributedStmt::CreateEmpty(
2704         Context,
2705         /*NumAttrs*/Record[ASTStmtReader::NumStmtFields]);
2706       break;
2707 
2708     case STMT_IF:
2709       S = IfStmt::CreateEmpty(
2710           Context,
2711           /* HasElse=*/Record[ASTStmtReader::NumStmtFields + 1],
2712           /* HasVar=*/Record[ASTStmtReader::NumStmtFields + 2],
2713           /* HasInit=*/Record[ASTStmtReader::NumStmtFields + 3]);
2714       break;
2715 
2716     case STMT_SWITCH:
2717       S = SwitchStmt::CreateEmpty(
2718           Context,
2719           /* HasInit=*/Record[ASTStmtReader::NumStmtFields],
2720           /* HasVar=*/Record[ASTStmtReader::NumStmtFields + 1]);
2721       break;
2722 
2723     case STMT_WHILE:
2724       S = WhileStmt::CreateEmpty(
2725           Context,
2726           /* HasVar=*/Record[ASTStmtReader::NumStmtFields]);
2727       break;
2728 
2729     case STMT_DO:
2730       S = new (Context) DoStmt(Empty);
2731       break;
2732 
2733     case STMT_FOR:
2734       S = new (Context) ForStmt(Empty);
2735       break;
2736 
2737     case STMT_GOTO:
2738       S = new (Context) GotoStmt(Empty);
2739       break;
2740 
2741     case STMT_INDIRECT_GOTO:
2742       S = new (Context) IndirectGotoStmt(Empty);
2743       break;
2744 
2745     case STMT_CONTINUE:
2746       S = new (Context) ContinueStmt(Empty);
2747       break;
2748 
2749     case STMT_BREAK:
2750       S = new (Context) BreakStmt(Empty);
2751       break;
2752 
2753     case STMT_RETURN:
2754       S = ReturnStmt::CreateEmpty(
2755           Context, /* HasNRVOCandidate=*/Record[ASTStmtReader::NumStmtFields]);
2756       break;
2757 
2758     case STMT_DECL:
2759       S = new (Context) DeclStmt(Empty);
2760       break;
2761 
2762     case STMT_GCCASM:
2763       S = new (Context) GCCAsmStmt(Empty);
2764       break;
2765 
2766     case STMT_MSASM:
2767       S = new (Context) MSAsmStmt(Empty);
2768       break;
2769 
2770     case STMT_CAPTURED:
2771       S = CapturedStmt::CreateDeserialized(
2772           Context, Record[ASTStmtReader::NumStmtFields]);
2773       break;
2774 
2775     case EXPR_CONSTANT:
2776       S = ConstantExpr::CreateEmpty(
2777           Context,
2778           static_cast<ConstantExpr::ResultStorageKind>(
2779               Record[ASTStmtReader::NumExprFields]),
2780           Empty);
2781       break;
2782 
2783     case EXPR_PREDEFINED:
2784       S = PredefinedExpr::CreateEmpty(
2785           Context,
2786           /*HasFunctionName*/ Record[ASTStmtReader::NumExprFields]);
2787       break;
2788 
2789     case EXPR_DECL_REF:
2790       S = DeclRefExpr::CreateEmpty(
2791         Context,
2792         /*HasQualifier=*/Record[ASTStmtReader::NumExprFields],
2793         /*HasFoundDecl=*/Record[ASTStmtReader::NumExprFields + 1],
2794         /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields + 2],
2795         /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields + 2] ?
2796           Record[ASTStmtReader::NumExprFields + 6] : 0);
2797       break;
2798 
2799     case EXPR_INTEGER_LITERAL:
2800       S = IntegerLiteral::Create(Context, Empty);
2801       break;
2802 
2803     case EXPR_FLOATING_LITERAL:
2804       S = FloatingLiteral::Create(Context, Empty);
2805       break;
2806 
2807     case EXPR_IMAGINARY_LITERAL:
2808       S = new (Context) ImaginaryLiteral(Empty);
2809       break;
2810 
2811     case EXPR_STRING_LITERAL:
2812       S = StringLiteral::CreateEmpty(
2813           Context,
2814           /* NumConcatenated=*/Record[ASTStmtReader::NumExprFields],
2815           /* Length=*/Record[ASTStmtReader::NumExprFields + 1],
2816           /* CharByteWidth=*/Record[ASTStmtReader::NumExprFields + 2]);
2817       break;
2818 
2819     case EXPR_CHARACTER_LITERAL:
2820       S = new (Context) CharacterLiteral(Empty);
2821       break;
2822 
2823     case EXPR_PAREN:
2824       S = new (Context) ParenExpr(Empty);
2825       break;
2826 
2827     case EXPR_PAREN_LIST:
2828       S = ParenListExpr::CreateEmpty(
2829           Context,
2830           /* NumExprs=*/Record[ASTStmtReader::NumExprFields]);
2831       break;
2832 
2833     case EXPR_UNARY_OPERATOR:
2834       S = new (Context) UnaryOperator(Empty);
2835       break;
2836 
2837     case EXPR_OFFSETOF:
2838       S = OffsetOfExpr::CreateEmpty(Context,
2839                                     Record[ASTStmtReader::NumExprFields],
2840                                     Record[ASTStmtReader::NumExprFields + 1]);
2841       break;
2842 
2843     case EXPR_SIZEOF_ALIGN_OF:
2844       S = new (Context) UnaryExprOrTypeTraitExpr(Empty);
2845       break;
2846 
2847     case EXPR_ARRAY_SUBSCRIPT:
2848       S = new (Context) ArraySubscriptExpr(Empty);
2849       break;
2850 
2851     case EXPR_OMP_ARRAY_SECTION:
2852       S = new (Context) OMPArraySectionExpr(Empty);
2853       break;
2854 
2855     case EXPR_CALL:
2856       S = CallExpr::CreateEmpty(
2857           Context, /*NumArgs=*/Record[ASTStmtReader::NumExprFields], Empty);
2858       break;
2859 
2860     case EXPR_MEMBER:
2861       S = MemberExpr::CreateEmpty(Context, Record[ASTStmtReader::NumExprFields],
2862                                   Record[ASTStmtReader::NumExprFields + 1],
2863                                   Record[ASTStmtReader::NumExprFields + 2],
2864                                   Record[ASTStmtReader::NumExprFields + 3]);
2865       break;
2866 
2867     case EXPR_BINARY_OPERATOR:
2868       S = new (Context) BinaryOperator(Empty);
2869       break;
2870 
2871     case EXPR_COMPOUND_ASSIGN_OPERATOR:
2872       S = new (Context) CompoundAssignOperator(Empty);
2873       break;
2874 
2875     case EXPR_CONDITIONAL_OPERATOR:
2876       S = new (Context) ConditionalOperator(Empty);
2877       break;
2878 
2879     case EXPR_BINARY_CONDITIONAL_OPERATOR:
2880       S = new (Context) BinaryConditionalOperator(Empty);
2881       break;
2882 
2883     case EXPR_IMPLICIT_CAST:
2884       S = ImplicitCastExpr::CreateEmpty(Context,
2885                        /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
2886       break;
2887 
2888     case EXPR_CSTYLE_CAST:
2889       S = CStyleCastExpr::CreateEmpty(Context,
2890                        /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
2891       break;
2892 
2893     case EXPR_COMPOUND_LITERAL:
2894       S = new (Context) CompoundLiteralExpr(Empty);
2895       break;
2896 
2897     case EXPR_EXT_VECTOR_ELEMENT:
2898       S = new (Context) ExtVectorElementExpr(Empty);
2899       break;
2900 
2901     case EXPR_INIT_LIST:
2902       S = new (Context) InitListExpr(Empty);
2903       break;
2904 
2905     case EXPR_DESIGNATED_INIT:
2906       S = DesignatedInitExpr::CreateEmpty(Context,
2907                                      Record[ASTStmtReader::NumExprFields] - 1);
2908 
2909       break;
2910 
2911     case EXPR_DESIGNATED_INIT_UPDATE:
2912       S = new (Context) DesignatedInitUpdateExpr(Empty);
2913       break;
2914 
2915     case EXPR_IMPLICIT_VALUE_INIT:
2916       S = new (Context) ImplicitValueInitExpr(Empty);
2917       break;
2918 
2919     case EXPR_NO_INIT:
2920       S = new (Context) NoInitExpr(Empty);
2921       break;
2922 
2923     case EXPR_ARRAY_INIT_LOOP:
2924       S = new (Context) ArrayInitLoopExpr(Empty);
2925       break;
2926 
2927     case EXPR_ARRAY_INIT_INDEX:
2928       S = new (Context) ArrayInitIndexExpr(Empty);
2929       break;
2930 
2931     case EXPR_VA_ARG:
2932       S = new (Context) VAArgExpr(Empty);
2933       break;
2934 
2935     case EXPR_SOURCE_LOC:
2936       S = new (Context) SourceLocExpr(Empty);
2937       break;
2938 
2939     case EXPR_ADDR_LABEL:
2940       S = new (Context) AddrLabelExpr(Empty);
2941       break;
2942 
2943     case EXPR_STMT:
2944       S = new (Context) StmtExpr(Empty);
2945       break;
2946 
2947     case EXPR_CHOOSE:
2948       S = new (Context) ChooseExpr(Empty);
2949       break;
2950 
2951     case EXPR_GNU_NULL:
2952       S = new (Context) GNUNullExpr(Empty);
2953       break;
2954 
2955     case EXPR_SHUFFLE_VECTOR:
2956       S = new (Context) ShuffleVectorExpr(Empty);
2957       break;
2958 
2959     case EXPR_CONVERT_VECTOR:
2960       S = new (Context) ConvertVectorExpr(Empty);
2961       break;
2962 
2963     case EXPR_BLOCK:
2964       S = new (Context) BlockExpr(Empty);
2965       break;
2966 
2967     case EXPR_GENERIC_SELECTION:
2968       S = GenericSelectionExpr::CreateEmpty(
2969           Context,
2970           /*NumAssocs=*/Record[ASTStmtReader::NumExprFields]);
2971       break;
2972 
2973     case EXPR_OBJC_STRING_LITERAL:
2974       S = new (Context) ObjCStringLiteral(Empty);
2975       break;
2976 
2977     case EXPR_OBJC_BOXED_EXPRESSION:
2978       S = new (Context) ObjCBoxedExpr(Empty);
2979       break;
2980 
2981     case EXPR_OBJC_ARRAY_LITERAL:
2982       S = ObjCArrayLiteral::CreateEmpty(Context,
2983                                         Record[ASTStmtReader::NumExprFields]);
2984       break;
2985 
2986     case EXPR_OBJC_DICTIONARY_LITERAL:
2987       S = ObjCDictionaryLiteral::CreateEmpty(Context,
2988             Record[ASTStmtReader::NumExprFields],
2989             Record[ASTStmtReader::NumExprFields + 1]);
2990       break;
2991 
2992     case EXPR_OBJC_ENCODE:
2993       S = new (Context) ObjCEncodeExpr(Empty);
2994       break;
2995 
2996     case EXPR_OBJC_SELECTOR_EXPR:
2997       S = new (Context) ObjCSelectorExpr(Empty);
2998       break;
2999 
3000     case EXPR_OBJC_PROTOCOL_EXPR:
3001       S = new (Context) ObjCProtocolExpr(Empty);
3002       break;
3003 
3004     case EXPR_OBJC_IVAR_REF_EXPR:
3005       S = new (Context) ObjCIvarRefExpr(Empty);
3006       break;
3007 
3008     case EXPR_OBJC_PROPERTY_REF_EXPR:
3009       S = new (Context) ObjCPropertyRefExpr(Empty);
3010       break;
3011 
3012     case EXPR_OBJC_SUBSCRIPT_REF_EXPR:
3013       S = new (Context) ObjCSubscriptRefExpr(Empty);
3014       break;
3015 
3016     case EXPR_OBJC_KVC_REF_EXPR:
3017       llvm_unreachable("mismatching AST file");
3018 
3019     case EXPR_OBJC_MESSAGE_EXPR:
3020       S = ObjCMessageExpr::CreateEmpty(Context,
3021                                      Record[ASTStmtReader::NumExprFields],
3022                                      Record[ASTStmtReader::NumExprFields + 1]);
3023       break;
3024 
3025     case EXPR_OBJC_ISA:
3026       S = new (Context) ObjCIsaExpr(Empty);
3027       break;
3028 
3029     case EXPR_OBJC_INDIRECT_COPY_RESTORE:
3030       S = new (Context) ObjCIndirectCopyRestoreExpr(Empty);
3031       break;
3032 
3033     case EXPR_OBJC_BRIDGED_CAST:
3034       S = new (Context) ObjCBridgedCastExpr(Empty);
3035       break;
3036 
3037     case STMT_OBJC_FOR_COLLECTION:
3038       S = new (Context) ObjCForCollectionStmt(Empty);
3039       break;
3040 
3041     case STMT_OBJC_CATCH:
3042       S = new (Context) ObjCAtCatchStmt(Empty);
3043       break;
3044 
3045     case STMT_OBJC_FINALLY:
3046       S = new (Context) ObjCAtFinallyStmt(Empty);
3047       break;
3048 
3049     case STMT_OBJC_AT_TRY:
3050       S = ObjCAtTryStmt::CreateEmpty(Context,
3051                                      Record[ASTStmtReader::NumStmtFields],
3052                                      Record[ASTStmtReader::NumStmtFields + 1]);
3053       break;
3054 
3055     case STMT_OBJC_AT_SYNCHRONIZED:
3056       S = new (Context) ObjCAtSynchronizedStmt(Empty);
3057       break;
3058 
3059     case STMT_OBJC_AT_THROW:
3060       S = new (Context) ObjCAtThrowStmt(Empty);
3061       break;
3062 
3063     case STMT_OBJC_AUTORELEASE_POOL:
3064       S = new (Context) ObjCAutoreleasePoolStmt(Empty);
3065       break;
3066 
3067     case EXPR_OBJC_BOOL_LITERAL:
3068       S = new (Context) ObjCBoolLiteralExpr(Empty);
3069       break;
3070 
3071     case EXPR_OBJC_AVAILABILITY_CHECK:
3072       S = new (Context) ObjCAvailabilityCheckExpr(Empty);
3073       break;
3074 
3075     case STMT_SEH_LEAVE:
3076       S = new (Context) SEHLeaveStmt(Empty);
3077       break;
3078 
3079     case STMT_SEH_EXCEPT:
3080       S = new (Context) SEHExceptStmt(Empty);
3081       break;
3082 
3083     case STMT_SEH_FINALLY:
3084       S = new (Context) SEHFinallyStmt(Empty);
3085       break;
3086 
3087     case STMT_SEH_TRY:
3088       S = new (Context) SEHTryStmt(Empty);
3089       break;
3090 
3091     case STMT_CXX_CATCH:
3092       S = new (Context) CXXCatchStmt(Empty);
3093       break;
3094 
3095     case STMT_CXX_TRY:
3096       S = CXXTryStmt::Create(Context, Empty,
3097              /*numHandlers=*/Record[ASTStmtReader::NumStmtFields]);
3098       break;
3099 
3100     case STMT_CXX_FOR_RANGE:
3101       S = new (Context) CXXForRangeStmt(Empty);
3102       break;
3103 
3104     case STMT_MS_DEPENDENT_EXISTS:
3105       S = new (Context) MSDependentExistsStmt(SourceLocation(), true,
3106                                               NestedNameSpecifierLoc(),
3107                                               DeclarationNameInfo(),
3108                                               nullptr);
3109       break;
3110 
3111     case STMT_OMP_PARALLEL_DIRECTIVE:
3112       S =
3113         OMPParallelDirective::CreateEmpty(Context,
3114                                           Record[ASTStmtReader::NumStmtFields],
3115                                           Empty);
3116       break;
3117 
3118     case STMT_OMP_SIMD_DIRECTIVE: {
3119       unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3120       unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3121       S = OMPSimdDirective::CreateEmpty(Context, NumClauses,
3122                                         CollapsedNum, Empty);
3123       break;
3124     }
3125 
3126     case STMT_OMP_FOR_DIRECTIVE: {
3127       unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3128       unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3129       S = OMPForDirective::CreateEmpty(Context, NumClauses, CollapsedNum,
3130                                        Empty);
3131       break;
3132     }
3133 
3134     case STMT_OMP_FOR_SIMD_DIRECTIVE: {
3135       unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3136       unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3137       S = OMPForSimdDirective::CreateEmpty(Context, NumClauses, CollapsedNum,
3138                                            Empty);
3139       break;
3140     }
3141 
3142     case STMT_OMP_SECTIONS_DIRECTIVE:
3143       S = OMPSectionsDirective::CreateEmpty(
3144           Context, Record[ASTStmtReader::NumStmtFields], Empty);
3145       break;
3146 
3147     case STMT_OMP_SECTION_DIRECTIVE:
3148       S = OMPSectionDirective::CreateEmpty(Context, Empty);
3149       break;
3150 
3151     case STMT_OMP_SINGLE_DIRECTIVE:
3152       S = OMPSingleDirective::CreateEmpty(
3153           Context, Record[ASTStmtReader::NumStmtFields], Empty);
3154       break;
3155 
3156     case STMT_OMP_MASTER_DIRECTIVE:
3157       S = OMPMasterDirective::CreateEmpty(Context, Empty);
3158       break;
3159 
3160     case STMT_OMP_CRITICAL_DIRECTIVE:
3161       S = OMPCriticalDirective::CreateEmpty(
3162           Context, Record[ASTStmtReader::NumStmtFields], Empty);
3163       break;
3164 
3165     case STMT_OMP_PARALLEL_FOR_DIRECTIVE: {
3166       unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3167       unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3168       S = OMPParallelForDirective::CreateEmpty(Context, NumClauses,
3169                                                CollapsedNum, Empty);
3170       break;
3171     }
3172 
3173     case STMT_OMP_PARALLEL_FOR_SIMD_DIRECTIVE: {
3174       unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3175       unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3176       S = OMPParallelForSimdDirective::CreateEmpty(Context, NumClauses,
3177                                                    CollapsedNum, Empty);
3178       break;
3179     }
3180 
3181     case STMT_OMP_PARALLEL_MASTER_DIRECTIVE:
3182       S = OMPParallelMasterDirective::CreateEmpty(
3183           Context, Record[ASTStmtReader::NumStmtFields], Empty);
3184       break;
3185 
3186     case STMT_OMP_PARALLEL_SECTIONS_DIRECTIVE:
3187       S = OMPParallelSectionsDirective::CreateEmpty(
3188           Context, Record[ASTStmtReader::NumStmtFields], Empty);
3189       break;
3190 
3191     case STMT_OMP_TASK_DIRECTIVE:
3192       S = OMPTaskDirective::CreateEmpty(
3193           Context, Record[ASTStmtReader::NumStmtFields], Empty);
3194       break;
3195 
3196     case STMT_OMP_TASKYIELD_DIRECTIVE:
3197       S = OMPTaskyieldDirective::CreateEmpty(Context, Empty);
3198       break;
3199 
3200     case STMT_OMP_BARRIER_DIRECTIVE:
3201       S = OMPBarrierDirective::CreateEmpty(Context, Empty);
3202       break;
3203 
3204     case STMT_OMP_TASKWAIT_DIRECTIVE:
3205       S = OMPTaskwaitDirective::CreateEmpty(Context, Empty);
3206       break;
3207 
3208     case STMT_OMP_TASKGROUP_DIRECTIVE:
3209       S = OMPTaskgroupDirective::CreateEmpty(
3210           Context, Record[ASTStmtReader::NumStmtFields], Empty);
3211       break;
3212 
3213     case STMT_OMP_FLUSH_DIRECTIVE:
3214       S = OMPFlushDirective::CreateEmpty(
3215           Context, Record[ASTStmtReader::NumStmtFields], Empty);
3216       break;
3217 
3218     case STMT_OMP_DEPOBJ_DIRECTIVE:
3219       S = OMPDepobjDirective::CreateEmpty(
3220           Context, Record[ASTStmtReader::NumStmtFields], Empty);
3221       break;
3222 
3223     case STMT_OMP_SCAN_DIRECTIVE:
3224       S = OMPScanDirective::CreateEmpty(
3225           Context, Record[ASTStmtReader::NumStmtFields], Empty);
3226       break;
3227 
3228     case STMT_OMP_ORDERED_DIRECTIVE:
3229       S = OMPOrderedDirective::CreateEmpty(
3230           Context, Record[ASTStmtReader::NumStmtFields], Empty);
3231       break;
3232 
3233     case STMT_OMP_ATOMIC_DIRECTIVE:
3234       S = OMPAtomicDirective::CreateEmpty(
3235           Context, Record[ASTStmtReader::NumStmtFields], Empty);
3236       break;
3237 
3238     case STMT_OMP_TARGET_DIRECTIVE:
3239       S = OMPTargetDirective::CreateEmpty(
3240           Context, Record[ASTStmtReader::NumStmtFields], Empty);
3241       break;
3242 
3243     case STMT_OMP_TARGET_DATA_DIRECTIVE:
3244       S = OMPTargetDataDirective::CreateEmpty(
3245           Context, Record[ASTStmtReader::NumStmtFields], Empty);
3246       break;
3247 
3248     case STMT_OMP_TARGET_ENTER_DATA_DIRECTIVE:
3249       S = OMPTargetEnterDataDirective::CreateEmpty(
3250           Context, Record[ASTStmtReader::NumStmtFields], Empty);
3251       break;
3252 
3253     case STMT_OMP_TARGET_EXIT_DATA_DIRECTIVE:
3254       S = OMPTargetExitDataDirective::CreateEmpty(
3255           Context, Record[ASTStmtReader::NumStmtFields], Empty);
3256       break;
3257 
3258     case STMT_OMP_TARGET_PARALLEL_DIRECTIVE:
3259       S = OMPTargetParallelDirective::CreateEmpty(
3260           Context, Record[ASTStmtReader::NumStmtFields], Empty);
3261       break;
3262 
3263     case STMT_OMP_TARGET_PARALLEL_FOR_DIRECTIVE: {
3264       unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3265       unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3266       S = OMPTargetParallelForDirective::CreateEmpty(Context, NumClauses,
3267                                                      CollapsedNum, Empty);
3268       break;
3269     }
3270 
3271     case STMT_OMP_TARGET_UPDATE_DIRECTIVE:
3272       S = OMPTargetUpdateDirective::CreateEmpty(
3273           Context, Record[ASTStmtReader::NumStmtFields], Empty);
3274       break;
3275 
3276     case STMT_OMP_TEAMS_DIRECTIVE:
3277       S = OMPTeamsDirective::CreateEmpty(
3278           Context, Record[ASTStmtReader::NumStmtFields], Empty);
3279       break;
3280 
3281     case STMT_OMP_CANCELLATION_POINT_DIRECTIVE:
3282       S = OMPCancellationPointDirective::CreateEmpty(Context, Empty);
3283       break;
3284 
3285     case STMT_OMP_CANCEL_DIRECTIVE:
3286       S = OMPCancelDirective::CreateEmpty(
3287           Context, Record[ASTStmtReader::NumStmtFields], Empty);
3288       break;
3289 
3290     case STMT_OMP_TASKLOOP_DIRECTIVE: {
3291       unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3292       unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3293       S = OMPTaskLoopDirective::CreateEmpty(Context, NumClauses, CollapsedNum,
3294                                             Empty);
3295       break;
3296     }
3297 
3298     case STMT_OMP_TASKLOOP_SIMD_DIRECTIVE: {
3299       unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3300       unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3301       S = OMPTaskLoopSimdDirective::CreateEmpty(Context, NumClauses,
3302                                                 CollapsedNum, Empty);
3303       break;
3304     }
3305 
3306     case STMT_OMP_MASTER_TASKLOOP_DIRECTIVE: {
3307       unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3308       unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3309       S = OMPMasterTaskLoopDirective::CreateEmpty(Context, NumClauses,
3310                                                   CollapsedNum, Empty);
3311       break;
3312     }
3313 
3314     case STMT_OMP_MASTER_TASKLOOP_SIMD_DIRECTIVE: {
3315       unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3316       unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3317       S = OMPMasterTaskLoopSimdDirective::CreateEmpty(Context, NumClauses,
3318                                                       CollapsedNum, Empty);
3319       break;
3320     }
3321 
3322     case STMT_OMP_PARALLEL_MASTER_TASKLOOP_DIRECTIVE: {
3323       unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3324       unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3325       S = OMPParallelMasterTaskLoopDirective::CreateEmpty(Context, NumClauses,
3326                                                           CollapsedNum, Empty);
3327       break;
3328     }
3329 
3330     case STMT_OMP_PARALLEL_MASTER_TASKLOOP_SIMD_DIRECTIVE: {
3331       unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3332       unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3333       S = OMPParallelMasterTaskLoopSimdDirective::CreateEmpty(
3334           Context, NumClauses, CollapsedNum, Empty);
3335       break;
3336     }
3337 
3338     case STMT_OMP_DISTRIBUTE_DIRECTIVE: {
3339       unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3340       unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3341       S = OMPDistributeDirective::CreateEmpty(Context, NumClauses, CollapsedNum,
3342                                               Empty);
3343       break;
3344     }
3345 
3346     case STMT_OMP_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE: {
3347       unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3348       unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3349       S = OMPDistributeParallelForDirective::CreateEmpty(Context, NumClauses,
3350                                                          CollapsedNum, Empty);
3351       break;
3352     }
3353 
3354     case STMT_OMP_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE: {
3355       unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3356       unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3357       S = OMPDistributeParallelForSimdDirective::CreateEmpty(Context, NumClauses,
3358                                                              CollapsedNum,
3359                                                              Empty);
3360       break;
3361     }
3362 
3363     case STMT_OMP_DISTRIBUTE_SIMD_DIRECTIVE: {
3364       unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3365       unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3366       S = OMPDistributeSimdDirective::CreateEmpty(Context, NumClauses,
3367                                                   CollapsedNum, Empty);
3368       break;
3369     }
3370 
3371     case STMT_OMP_TARGET_PARALLEL_FOR_SIMD_DIRECTIVE: {
3372       unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3373       unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3374       S = OMPTargetParallelForSimdDirective::CreateEmpty(Context, NumClauses,
3375                                                          CollapsedNum, Empty);
3376       break;
3377     }
3378 
3379     case STMT_OMP_TARGET_SIMD_DIRECTIVE: {
3380       auto NumClauses = Record[ASTStmtReader::NumStmtFields];
3381       auto CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3382       S = OMPTargetSimdDirective::CreateEmpty(Context, NumClauses, CollapsedNum,
3383                                               Empty);
3384       break;
3385     }
3386 
3387      case STMT_OMP_TEAMS_DISTRIBUTE_DIRECTIVE: {
3388       auto NumClauses = Record[ASTStmtReader::NumStmtFields];
3389       auto CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3390       S = OMPTeamsDistributeDirective::CreateEmpty(Context, NumClauses,
3391                                                    CollapsedNum, Empty);
3392       break;
3393     }
3394 
3395     case STMT_OMP_TEAMS_DISTRIBUTE_SIMD_DIRECTIVE: {
3396       unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3397       unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3398       S = OMPTeamsDistributeSimdDirective::CreateEmpty(Context, NumClauses,
3399                                                        CollapsedNum, Empty);
3400       break;
3401     }
3402 
3403     case STMT_OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE: {
3404       auto NumClauses = Record[ASTStmtReader::NumStmtFields];
3405       auto CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3406       S = OMPTeamsDistributeParallelForSimdDirective::CreateEmpty(
3407           Context, NumClauses, CollapsedNum, Empty);
3408       break;
3409     }
3410 
3411     case STMT_OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE: {
3412       auto NumClauses = Record[ASTStmtReader::NumStmtFields];
3413       auto CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3414       S = OMPTeamsDistributeParallelForDirective::CreateEmpty(
3415           Context, NumClauses, CollapsedNum, Empty);
3416       break;
3417     }
3418 
3419     case STMT_OMP_TARGET_TEAMS_DIRECTIVE:
3420       S = OMPTargetTeamsDirective::CreateEmpty(
3421           Context, Record[ASTStmtReader::NumStmtFields], Empty);
3422       break;
3423 
3424     case STMT_OMP_TARGET_TEAMS_DISTRIBUTE_DIRECTIVE: {
3425       auto NumClauses = Record[ASTStmtReader::NumStmtFields];
3426       auto CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3427       S = OMPTargetTeamsDistributeDirective::CreateEmpty(Context, NumClauses,
3428                                                          CollapsedNum, Empty);
3429       break;
3430     }
3431 
3432     case STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE: {
3433       auto NumClauses = Record[ASTStmtReader::NumStmtFields];
3434       auto CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3435       S = OMPTargetTeamsDistributeParallelForDirective::CreateEmpty(
3436           Context, NumClauses, CollapsedNum, Empty);
3437       break;
3438     }
3439 
3440     case STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE: {
3441       auto NumClauses = Record[ASTStmtReader::NumStmtFields];
3442       auto CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3443       S = OMPTargetTeamsDistributeParallelForSimdDirective::CreateEmpty(
3444           Context, NumClauses, CollapsedNum, Empty);
3445       break;
3446     }
3447 
3448     case STMT_OMP_TARGET_TEAMS_DISTRIBUTE_SIMD_DIRECTIVE: {
3449       auto NumClauses = Record[ASTStmtReader::NumStmtFields];
3450       auto CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3451       S = OMPTargetTeamsDistributeSimdDirective::CreateEmpty(
3452           Context, NumClauses, CollapsedNum, Empty);
3453       break;
3454     }
3455 
3456     case EXPR_CXX_OPERATOR_CALL:
3457       S = CXXOperatorCallExpr::CreateEmpty(
3458           Context, /*NumArgs=*/Record[ASTStmtReader::NumExprFields], Empty);
3459       break;
3460 
3461     case EXPR_CXX_MEMBER_CALL:
3462       S = CXXMemberCallExpr::CreateEmpty(
3463           Context, /*NumArgs=*/Record[ASTStmtReader::NumExprFields], Empty);
3464       break;
3465 
3466     case EXPR_CXX_REWRITTEN_BINARY_OPERATOR:
3467       S = new (Context) CXXRewrittenBinaryOperator(Empty);
3468       break;
3469 
3470     case EXPR_CXX_CONSTRUCT:
3471       S = CXXConstructExpr::CreateEmpty(
3472           Context,
3473           /* NumArgs=*/Record[ASTStmtReader::NumExprFields]);
3474       break;
3475 
3476     case EXPR_CXX_INHERITED_CTOR_INIT:
3477       S = new (Context) CXXInheritedCtorInitExpr(Empty);
3478       break;
3479 
3480     case EXPR_CXX_TEMPORARY_OBJECT:
3481       S = CXXTemporaryObjectExpr::CreateEmpty(
3482           Context,
3483           /* NumArgs=*/Record[ASTStmtReader::NumExprFields]);
3484       break;
3485 
3486     case EXPR_CXX_STATIC_CAST:
3487       S = CXXStaticCastExpr::CreateEmpty(Context,
3488                        /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
3489       break;
3490 
3491     case EXPR_CXX_DYNAMIC_CAST:
3492       S = CXXDynamicCastExpr::CreateEmpty(Context,
3493                        /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
3494       break;
3495 
3496     case EXPR_CXX_REINTERPRET_CAST:
3497       S = CXXReinterpretCastExpr::CreateEmpty(Context,
3498                        /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
3499       break;
3500 
3501     case EXPR_CXX_CONST_CAST:
3502       S = CXXConstCastExpr::CreateEmpty(Context);
3503       break;
3504 
3505     case EXPR_CXX_FUNCTIONAL_CAST:
3506       S = CXXFunctionalCastExpr::CreateEmpty(Context,
3507                        /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
3508       break;
3509 
3510     case EXPR_USER_DEFINED_LITERAL:
3511       S = UserDefinedLiteral::CreateEmpty(
3512           Context, /*NumArgs=*/Record[ASTStmtReader::NumExprFields], Empty);
3513       break;
3514 
3515     case EXPR_CXX_STD_INITIALIZER_LIST:
3516       S = new (Context) CXXStdInitializerListExpr(Empty);
3517       break;
3518 
3519     case EXPR_CXX_BOOL_LITERAL:
3520       S = new (Context) CXXBoolLiteralExpr(Empty);
3521       break;
3522 
3523     case EXPR_CXX_NULL_PTR_LITERAL:
3524       S = new (Context) CXXNullPtrLiteralExpr(Empty);
3525       break;
3526 
3527     case EXPR_CXX_TYPEID_EXPR:
3528       S = new (Context) CXXTypeidExpr(Empty, true);
3529       break;
3530 
3531     case EXPR_CXX_TYPEID_TYPE:
3532       S = new (Context) CXXTypeidExpr(Empty, false);
3533       break;
3534 
3535     case EXPR_CXX_UUIDOF_EXPR:
3536       S = new (Context) CXXUuidofExpr(Empty, true);
3537       break;
3538 
3539     case EXPR_CXX_PROPERTY_REF_EXPR:
3540       S = new (Context) MSPropertyRefExpr(Empty);
3541       break;
3542 
3543     case EXPR_CXX_PROPERTY_SUBSCRIPT_EXPR:
3544       S = new (Context) MSPropertySubscriptExpr(Empty);
3545       break;
3546 
3547     case EXPR_CXX_UUIDOF_TYPE:
3548       S = new (Context) CXXUuidofExpr(Empty, false);
3549       break;
3550 
3551     case EXPR_CXX_THIS:
3552       S = new (Context) CXXThisExpr(Empty);
3553       break;
3554 
3555     case EXPR_CXX_THROW:
3556       S = new (Context) CXXThrowExpr(Empty);
3557       break;
3558 
3559     case EXPR_CXX_DEFAULT_ARG:
3560       S = new (Context) CXXDefaultArgExpr(Empty);
3561       break;
3562 
3563     case EXPR_CXX_DEFAULT_INIT:
3564       S = new (Context) CXXDefaultInitExpr(Empty);
3565       break;
3566 
3567     case EXPR_CXX_BIND_TEMPORARY:
3568       S = new (Context) CXXBindTemporaryExpr(Empty);
3569       break;
3570 
3571     case EXPR_CXX_SCALAR_VALUE_INIT:
3572       S = new (Context) CXXScalarValueInitExpr(Empty);
3573       break;
3574 
3575     case EXPR_CXX_NEW:
3576       S = CXXNewExpr::CreateEmpty(
3577           Context,
3578           /*IsArray=*/Record[ASTStmtReader::NumExprFields],
3579           /*HasInit=*/Record[ASTStmtReader::NumExprFields + 1],
3580           /*NumPlacementArgs=*/Record[ASTStmtReader::NumExprFields + 2],
3581           /*IsParenTypeId=*/Record[ASTStmtReader::NumExprFields + 3]);
3582       break;
3583 
3584     case EXPR_CXX_DELETE:
3585       S = new (Context) CXXDeleteExpr(Empty);
3586       break;
3587 
3588     case EXPR_CXX_PSEUDO_DESTRUCTOR:
3589       S = new (Context) CXXPseudoDestructorExpr(Empty);
3590       break;
3591 
3592     case EXPR_EXPR_WITH_CLEANUPS:
3593       S = ExprWithCleanups::Create(Context, Empty,
3594                                    Record[ASTStmtReader::NumExprFields]);
3595       break;
3596 
3597     case EXPR_CXX_DEPENDENT_SCOPE_MEMBER:
3598       S = CXXDependentScopeMemberExpr::CreateEmpty(
3599           Context,
3600           /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields],
3601           /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields + 1],
3602           /*HasFirstQualifierFoundInScope=*/
3603           Record[ASTStmtReader::NumExprFields + 2]);
3604       break;
3605 
3606     case EXPR_CXX_DEPENDENT_SCOPE_DECL_REF:
3607       S = DependentScopeDeclRefExpr::CreateEmpty(Context,
3608          /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields],
3609                   /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]
3610                                    ? Record[ASTStmtReader::NumExprFields + 1]
3611                                    : 0);
3612       break;
3613 
3614     case EXPR_CXX_UNRESOLVED_CONSTRUCT:
3615       S = CXXUnresolvedConstructExpr::CreateEmpty(Context,
3616                               /*NumArgs=*/Record[ASTStmtReader::NumExprFields]);
3617       break;
3618 
3619     case EXPR_CXX_UNRESOLVED_MEMBER:
3620       S = UnresolvedMemberExpr::CreateEmpty(
3621           Context,
3622           /*NumResults=*/Record[ASTStmtReader::NumExprFields],
3623           /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields + 1],
3624           /*NumTemplateArgs=*/
3625           Record[ASTStmtReader::NumExprFields + 1]
3626               ? Record[ASTStmtReader::NumExprFields + 2]
3627               : 0);
3628       break;
3629 
3630     case EXPR_CXX_UNRESOLVED_LOOKUP:
3631       S = UnresolvedLookupExpr::CreateEmpty(
3632           Context,
3633           /*NumResults=*/Record[ASTStmtReader::NumExprFields],
3634           /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields + 1],
3635           /*NumTemplateArgs=*/
3636           Record[ASTStmtReader::NumExprFields + 1]
3637               ? Record[ASTStmtReader::NumExprFields + 2]
3638               : 0);
3639       break;
3640 
3641     case EXPR_TYPE_TRAIT:
3642       S = TypeTraitExpr::CreateDeserialized(Context,
3643             Record[ASTStmtReader::NumExprFields]);
3644       break;
3645 
3646     case EXPR_ARRAY_TYPE_TRAIT:
3647       S = new (Context) ArrayTypeTraitExpr(Empty);
3648       break;
3649 
3650     case EXPR_CXX_EXPRESSION_TRAIT:
3651       S = new (Context) ExpressionTraitExpr(Empty);
3652       break;
3653 
3654     case EXPR_CXX_NOEXCEPT:
3655       S = new (Context) CXXNoexceptExpr(Empty);
3656       break;
3657 
3658     case EXPR_PACK_EXPANSION:
3659       S = new (Context) PackExpansionExpr(Empty);
3660       break;
3661 
3662     case EXPR_SIZEOF_PACK:
3663       S = SizeOfPackExpr::CreateDeserialized(
3664               Context,
3665               /*NumPartialArgs=*/Record[ASTStmtReader::NumExprFields]);
3666       break;
3667 
3668     case EXPR_SUBST_NON_TYPE_TEMPLATE_PARM:
3669       S = new (Context) SubstNonTypeTemplateParmExpr(Empty);
3670       break;
3671 
3672     case EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK:
3673       S = new (Context) SubstNonTypeTemplateParmPackExpr(Empty);
3674       break;
3675 
3676     case EXPR_FUNCTION_PARM_PACK:
3677       S = FunctionParmPackExpr::CreateEmpty(Context,
3678                                           Record[ASTStmtReader::NumExprFields]);
3679       break;
3680 
3681     case EXPR_MATERIALIZE_TEMPORARY:
3682       S = new (Context) MaterializeTemporaryExpr(Empty);
3683       break;
3684 
3685     case EXPR_CXX_FOLD:
3686       S = new (Context) CXXFoldExpr(Empty);
3687       break;
3688 
3689     case EXPR_OPAQUE_VALUE:
3690       S = new (Context) OpaqueValueExpr(Empty);
3691       break;
3692 
3693     case EXPR_CUDA_KERNEL_CALL:
3694       S = CUDAKernelCallExpr::CreateEmpty(
3695           Context, /*NumArgs=*/Record[ASTStmtReader::NumExprFields], Empty);
3696       break;
3697 
3698     case EXPR_ASTYPE:
3699       S = new (Context) AsTypeExpr(Empty);
3700       break;
3701 
3702     case EXPR_PSEUDO_OBJECT: {
3703       unsigned numSemanticExprs = Record[ASTStmtReader::NumExprFields];
3704       S = PseudoObjectExpr::Create(Context, Empty, numSemanticExprs);
3705       break;
3706     }
3707 
3708     case EXPR_ATOMIC:
3709       S = new (Context) AtomicExpr(Empty);
3710       break;
3711 
3712     case EXPR_LAMBDA: {
3713       unsigned NumCaptures = Record[ASTStmtReader::NumExprFields];
3714       S = LambdaExpr::CreateDeserialized(Context, NumCaptures);
3715       break;
3716     }
3717 
3718     case STMT_COROUTINE_BODY: {
3719       unsigned NumParams = Record[ASTStmtReader::NumStmtFields];
3720       S = CoroutineBodyStmt::Create(Context, Empty, NumParams);
3721       break;
3722     }
3723 
3724     case STMT_CORETURN:
3725       S = new (Context) CoreturnStmt(Empty);
3726       break;
3727 
3728     case EXPR_COAWAIT:
3729       S = new (Context) CoawaitExpr(Empty);
3730       break;
3731 
3732     case EXPR_COYIELD:
3733       S = new (Context) CoyieldExpr(Empty);
3734       break;
3735 
3736     case EXPR_DEPENDENT_COAWAIT:
3737       S = new (Context) DependentCoawaitExpr(Empty);
3738       break;
3739 
3740     case EXPR_CONCEPT_SPECIALIZATION: {
3741       unsigned numTemplateArgs = Record[ASTStmtReader::NumExprFields];
3742       S = ConceptSpecializationExpr::Create(Context, Empty, numTemplateArgs);
3743       break;
3744     }
3745 
3746     case EXPR_REQUIRES:
3747       unsigned numLocalParameters = Record[ASTStmtReader::NumExprFields];
3748       unsigned numRequirement = Record[ASTStmtReader::NumExprFields + 1];
3749       S = RequiresExpr::Create(Context, Empty, numLocalParameters,
3750                                numRequirement);
3751       break;
3752     }
3753 
3754     // We hit a STMT_STOP, so we're done with this expression.
3755     if (Finished)
3756       break;
3757 
3758     ++NumStatementsRead;
3759 
3760     if (S && !IsStmtReference) {
3761       Reader.Visit(S);
3762       StmtEntries[Cursor.GetCurrentBitNo()] = S;
3763     }
3764 
3765     assert(Record.getIdx() == Record.size() &&
3766            "Invalid deserialization of statement");
3767     StmtStack.push_back(S);
3768   }
3769 Done:
3770   assert(StmtStack.size() > PrevNumStmts && "Read too many sub-stmts!");
3771   assert(StmtStack.size() == PrevNumStmts + 1 && "Extra expressions on stack!");
3772   return StmtStack.pop_back_val();
3773 }
3774