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