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