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