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