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