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