1 //===--- ASTReaderStmt.cpp - Stmt/Expr Deserialization ----------*- C++ -*-===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // Statement/expression deserialization.  This implements the
11 // ASTReader::ReadStmt method.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #include "clang/Serialization/ASTReader.h"
16 #include "clang/AST/ASTContext.h"
17 #include "clang/AST/DeclCXX.h"
18 #include "clang/AST/DeclTemplate.h"
19 #include "clang/AST/StmtVisitor.h"
20 #include "clang/Lex/Token.h"
21 #include "llvm/ADT/SmallString.h"
22 using namespace clang;
23 using namespace clang::serialization;
24 
25 namespace clang {
26 
27   class ASTStmtReader : public StmtVisitor<ASTStmtReader> {
28     friend class OMPClauseReader;
29     typedef ASTReader::RecordData RecordData;
30 
31     ASTReader &Reader;
32     ModuleFile &F;
33     llvm::BitstreamCursor &DeclsCursor;
34     const ASTReader::RecordData &Record;
35     unsigned &Idx;
36 
37     Token ReadToken(const RecordData &R, unsigned &I) {
38       return Reader.ReadToken(F, R, I);
39     }
40 
41     SourceLocation ReadSourceLocation(const RecordData &R, unsigned &I) {
42       return Reader.ReadSourceLocation(F, R, I);
43     }
44 
45     SourceRange ReadSourceRange(const RecordData &R, unsigned &I) {
46       return Reader.ReadSourceRange(F, R, I);
47     }
48 
49     std::string ReadString(const RecordData &R, unsigned &I) {
50       return Reader.ReadString(R, I);
51     }
52 
53     TypeSourceInfo *GetTypeSourceInfo(const RecordData &R, unsigned &I) {
54       return Reader.GetTypeSourceInfo(F, R, I);
55     }
56 
57     serialization::DeclID ReadDeclID(const RecordData &R, unsigned &I) {
58       return Reader.ReadDeclID(F, R, I);
59     }
60 
61     Decl *ReadDecl(const RecordData &R, unsigned &I) {
62       return Reader.ReadDecl(F, R, I);
63     }
64 
65     template<typename T>
66     T *ReadDeclAs(const RecordData &R, unsigned &I) {
67       return Reader.ReadDeclAs<T>(F, R, I);
68     }
69 
70     void ReadDeclarationNameLoc(DeclarationNameLoc &DNLoc, DeclarationName Name,
71                                 const ASTReader::RecordData &R, unsigned &I) {
72       Reader.ReadDeclarationNameLoc(F, DNLoc, Name, R, I);
73     }
74 
75     void ReadDeclarationNameInfo(DeclarationNameInfo &NameInfo,
76                                 const ASTReader::RecordData &R, unsigned &I) {
77       Reader.ReadDeclarationNameInfo(F, NameInfo, R, I);
78     }
79 
80   public:
81     ASTStmtReader(ASTReader &Reader, ModuleFile &F,
82                   llvm::BitstreamCursor &Cursor,
83                   const ASTReader::RecordData &Record, unsigned &Idx)
84       : Reader(Reader), F(F), DeclsCursor(Cursor), Record(Record), Idx(Idx) { }
85 
86     /// \brief The number of record fields required for the Stmt class
87     /// itself.
88     static const unsigned NumStmtFields = 0;
89 
90     /// \brief The number of record fields required for the Expr class
91     /// itself.
92     static const unsigned NumExprFields = NumStmtFields + 7;
93 
94     /// \brief Read and initialize a ExplicitTemplateArgumentList structure.
95     void ReadTemplateKWAndArgsInfo(ASTTemplateKWAndArgsInfo &Args,
96                                    unsigned NumTemplateArgs);
97     /// \brief Read and initialize a ExplicitTemplateArgumentList structure.
98     void ReadExplicitTemplateArgumentList(ASTTemplateArgumentListInfo &ArgList,
99                                           unsigned NumTemplateArgs);
100 
101     void VisitStmt(Stmt *S);
102 #define STMT(Type, Base) \
103     void Visit##Type(Type *);
104 #include "clang/AST/StmtNodes.inc"
105   };
106 }
107 
108 void ASTStmtReader::
109 ReadTemplateKWAndArgsInfo(ASTTemplateKWAndArgsInfo &Args,
110                           unsigned NumTemplateArgs) {
111   SourceLocation TemplateKWLoc = ReadSourceLocation(Record, Idx);
112   TemplateArgumentListInfo ArgInfo;
113   ArgInfo.setLAngleLoc(ReadSourceLocation(Record, Idx));
114   ArgInfo.setRAngleLoc(ReadSourceLocation(Record, Idx));
115   for (unsigned i = 0; i != NumTemplateArgs; ++i)
116     ArgInfo.addArgument(
117         Reader.ReadTemplateArgumentLoc(F, Record, Idx));
118   Args.initializeFrom(TemplateKWLoc, ArgInfo);
119 }
120 
121 void ASTStmtReader::VisitStmt(Stmt *S) {
122   assert(Idx == NumStmtFields && "Incorrect statement field count");
123 }
124 
125 void ASTStmtReader::VisitNullStmt(NullStmt *S) {
126   VisitStmt(S);
127   S->setSemiLoc(ReadSourceLocation(Record, Idx));
128   S->HasLeadingEmptyMacro = Record[Idx++];
129 }
130 
131 void ASTStmtReader::VisitCompoundStmt(CompoundStmt *S) {
132   VisitStmt(S);
133   SmallVector<Stmt *, 16> Stmts;
134   unsigned NumStmts = Record[Idx++];
135   while (NumStmts--)
136     Stmts.push_back(Reader.ReadSubStmt());
137   S->setStmts(Reader.getContext(), Stmts.data(), Stmts.size());
138   S->setLBracLoc(ReadSourceLocation(Record, Idx));
139   S->setRBracLoc(ReadSourceLocation(Record, Idx));
140 }
141 
142 void ASTStmtReader::VisitSwitchCase(SwitchCase *S) {
143   VisitStmt(S);
144   Reader.RecordSwitchCaseID(S, Record[Idx++]);
145   S->setKeywordLoc(ReadSourceLocation(Record, Idx));
146   S->setColonLoc(ReadSourceLocation(Record, Idx));
147 }
148 
149 void ASTStmtReader::VisitCaseStmt(CaseStmt *S) {
150   VisitSwitchCase(S);
151   S->setLHS(Reader.ReadSubExpr());
152   S->setRHS(Reader.ReadSubExpr());
153   S->setSubStmt(Reader.ReadSubStmt());
154   S->setEllipsisLoc(ReadSourceLocation(Record, Idx));
155 }
156 
157 void ASTStmtReader::VisitDefaultStmt(DefaultStmt *S) {
158   VisitSwitchCase(S);
159   S->setSubStmt(Reader.ReadSubStmt());
160 }
161 
162 void ASTStmtReader::VisitLabelStmt(LabelStmt *S) {
163   VisitStmt(S);
164   LabelDecl *LD = ReadDeclAs<LabelDecl>(Record, Idx);
165   LD->setStmt(S);
166   S->setDecl(LD);
167   S->setSubStmt(Reader.ReadSubStmt());
168   S->setIdentLoc(ReadSourceLocation(Record, Idx));
169 }
170 
171 void ASTStmtReader::VisitAttributedStmt(AttributedStmt *S) {
172   VisitStmt(S);
173   uint64_t NumAttrs = Record[Idx++];
174   AttrVec Attrs;
175   Reader.ReadAttributes(F, Attrs, Record, Idx);
176   (void)NumAttrs;
177   assert(NumAttrs == S->NumAttrs);
178   assert(NumAttrs == Attrs.size());
179   std::copy(Attrs.begin(), Attrs.end(), S->Attrs);
180   S->SubStmt = Reader.ReadSubStmt();
181   S->AttrLoc = ReadSourceLocation(Record, Idx);
182 }
183 
184 void ASTStmtReader::VisitIfStmt(IfStmt *S) {
185   VisitStmt(S);
186   S->setConditionVariable(Reader.getContext(),
187                           ReadDeclAs<VarDecl>(Record, Idx));
188   S->setCond(Reader.ReadSubExpr());
189   S->setThen(Reader.ReadSubStmt());
190   S->setElse(Reader.ReadSubStmt());
191   S->setIfLoc(ReadSourceLocation(Record, Idx));
192   S->setElseLoc(ReadSourceLocation(Record, Idx));
193 }
194 
195 void ASTStmtReader::VisitSwitchStmt(SwitchStmt *S) {
196   VisitStmt(S);
197   S->setConditionVariable(Reader.getContext(),
198                           ReadDeclAs<VarDecl>(Record, Idx));
199   S->setCond(Reader.ReadSubExpr());
200   S->setBody(Reader.ReadSubStmt());
201   S->setSwitchLoc(ReadSourceLocation(Record, Idx));
202   if (Record[Idx++])
203     S->setAllEnumCasesCovered();
204 
205   SwitchCase *PrevSC = 0;
206   for (unsigned N = Record.size(); Idx != N; ++Idx) {
207     SwitchCase *SC = Reader.getSwitchCaseWithID(Record[Idx]);
208     if (PrevSC)
209       PrevSC->setNextSwitchCase(SC);
210     else
211       S->setSwitchCaseList(SC);
212 
213     PrevSC = SC;
214   }
215 }
216 
217 void ASTStmtReader::VisitWhileStmt(WhileStmt *S) {
218   VisitStmt(S);
219   S->setConditionVariable(Reader.getContext(),
220                           ReadDeclAs<VarDecl>(Record, Idx));
221 
222   S->setCond(Reader.ReadSubExpr());
223   S->setBody(Reader.ReadSubStmt());
224   S->setWhileLoc(ReadSourceLocation(Record, Idx));
225 }
226 
227 void ASTStmtReader::VisitDoStmt(DoStmt *S) {
228   VisitStmt(S);
229   S->setCond(Reader.ReadSubExpr());
230   S->setBody(Reader.ReadSubStmt());
231   S->setDoLoc(ReadSourceLocation(Record, Idx));
232   S->setWhileLoc(ReadSourceLocation(Record, Idx));
233   S->setRParenLoc(ReadSourceLocation(Record, Idx));
234 }
235 
236 void ASTStmtReader::VisitForStmt(ForStmt *S) {
237   VisitStmt(S);
238   S->setInit(Reader.ReadSubStmt());
239   S->setCond(Reader.ReadSubExpr());
240   S->setConditionVariable(Reader.getContext(),
241                           ReadDeclAs<VarDecl>(Record, Idx));
242   S->setInc(Reader.ReadSubExpr());
243   S->setBody(Reader.ReadSubStmt());
244   S->setForLoc(ReadSourceLocation(Record, Idx));
245   S->setLParenLoc(ReadSourceLocation(Record, Idx));
246   S->setRParenLoc(ReadSourceLocation(Record, Idx));
247 }
248 
249 void ASTStmtReader::VisitGotoStmt(GotoStmt *S) {
250   VisitStmt(S);
251   S->setLabel(ReadDeclAs<LabelDecl>(Record, Idx));
252   S->setGotoLoc(ReadSourceLocation(Record, Idx));
253   S->setLabelLoc(ReadSourceLocation(Record, Idx));
254 }
255 
256 void ASTStmtReader::VisitIndirectGotoStmt(IndirectGotoStmt *S) {
257   VisitStmt(S);
258   S->setGotoLoc(ReadSourceLocation(Record, Idx));
259   S->setStarLoc(ReadSourceLocation(Record, Idx));
260   S->setTarget(Reader.ReadSubExpr());
261 }
262 
263 void ASTStmtReader::VisitContinueStmt(ContinueStmt *S) {
264   VisitStmt(S);
265   S->setContinueLoc(ReadSourceLocation(Record, Idx));
266 }
267 
268 void ASTStmtReader::VisitBreakStmt(BreakStmt *S) {
269   VisitStmt(S);
270   S->setBreakLoc(ReadSourceLocation(Record, Idx));
271 }
272 
273 void ASTStmtReader::VisitReturnStmt(ReturnStmt *S) {
274   VisitStmt(S);
275   S->setRetValue(Reader.ReadSubExpr());
276   S->setReturnLoc(ReadSourceLocation(Record, Idx));
277   S->setNRVOCandidate(ReadDeclAs<VarDecl>(Record, Idx));
278 }
279 
280 void ASTStmtReader::VisitDeclStmt(DeclStmt *S) {
281   VisitStmt(S);
282   S->setStartLoc(ReadSourceLocation(Record, Idx));
283   S->setEndLoc(ReadSourceLocation(Record, Idx));
284 
285   if (Idx + 1 == Record.size()) {
286     // Single declaration
287     S->setDeclGroup(DeclGroupRef(ReadDecl(Record, Idx)));
288   } else {
289     SmallVector<Decl *, 16> Decls;
290     Decls.reserve(Record.size() - Idx);
291     for (unsigned N = Record.size(); Idx != N; )
292       Decls.push_back(ReadDecl(Record, Idx));
293     S->setDeclGroup(DeclGroupRef(DeclGroup::Create(Reader.getContext(),
294                                                    Decls.data(),
295                                                    Decls.size())));
296   }
297 }
298 
299 void ASTStmtReader::VisitAsmStmt(AsmStmt *S) {
300   VisitStmt(S);
301   S->NumOutputs = Record[Idx++];
302   S->NumInputs = Record[Idx++];
303   S->NumClobbers = Record[Idx++];
304   S->setAsmLoc(ReadSourceLocation(Record, Idx));
305   S->setVolatile(Record[Idx++]);
306   S->setSimple(Record[Idx++]);
307 }
308 
309 void ASTStmtReader::VisitGCCAsmStmt(GCCAsmStmt *S) {
310   VisitAsmStmt(S);
311   S->setRParenLoc(ReadSourceLocation(Record, Idx));
312   S->setAsmString(cast_or_null<StringLiteral>(Reader.ReadSubStmt()));
313 
314   unsigned NumOutputs = S->getNumOutputs();
315   unsigned NumInputs = S->getNumInputs();
316   unsigned NumClobbers = S->getNumClobbers();
317 
318   // Outputs and inputs
319   SmallVector<IdentifierInfo *, 16> Names;
320   SmallVector<StringLiteral*, 16> Constraints;
321   SmallVector<Stmt*, 16> Exprs;
322   for (unsigned I = 0, N = NumOutputs + NumInputs; I != N; ++I) {
323     Names.push_back(Reader.GetIdentifierInfo(F, Record, Idx));
324     Constraints.push_back(cast_or_null<StringLiteral>(Reader.ReadSubStmt()));
325     Exprs.push_back(Reader.ReadSubStmt());
326   }
327 
328   // Constraints
329   SmallVector<StringLiteral*, 16> Clobbers;
330   for (unsigned I = 0; I != NumClobbers; ++I)
331     Clobbers.push_back(cast_or_null<StringLiteral>(Reader.ReadSubStmt()));
332 
333   S->setOutputsAndInputsAndClobbers(Reader.getContext(),
334                                     Names.data(), Constraints.data(),
335                                     Exprs.data(), NumOutputs, NumInputs,
336                                     Clobbers.data(), NumClobbers);
337 }
338 
339 void ASTStmtReader::VisitMSAsmStmt(MSAsmStmt *S) {
340   VisitAsmStmt(S);
341   S->LBraceLoc = ReadSourceLocation(Record, Idx);
342   S->EndLoc = ReadSourceLocation(Record, Idx);
343   S->NumAsmToks = Record[Idx++];
344   std::string AsmStr = ReadString(Record, Idx);
345 
346   // Read the tokens.
347   SmallVector<Token, 16> AsmToks;
348   AsmToks.reserve(S->NumAsmToks);
349   for (unsigned i = 0, e = S->NumAsmToks; i != e; ++i) {
350     AsmToks.push_back(ReadToken(Record, Idx));
351   }
352 
353   // The calls to reserve() for the FooData vectors are mandatory to
354   // prevent dead StringRefs in the Foo vectors.
355 
356   // Read the clobbers.
357   SmallVector<std::string, 16> ClobbersData;
358   SmallVector<StringRef, 16> Clobbers;
359   ClobbersData.reserve(S->NumClobbers);
360   Clobbers.reserve(S->NumClobbers);
361   for (unsigned i = 0, e = S->NumClobbers; i != e; ++i) {
362     ClobbersData.push_back(ReadString(Record, Idx));
363     Clobbers.push_back(ClobbersData.back());
364   }
365 
366   // Read the operands.
367   unsigned NumOperands = S->NumOutputs + S->NumInputs;
368   SmallVector<Expr*, 16> Exprs;
369   SmallVector<std::string, 16> ConstraintsData;
370   SmallVector<StringRef, 16> Constraints;
371   Exprs.reserve(NumOperands);
372   ConstraintsData.reserve(NumOperands);
373   Constraints.reserve(NumOperands);
374   for (unsigned i = 0; i != NumOperands; ++i) {
375     Exprs.push_back(cast<Expr>(Reader.ReadSubStmt()));
376     ConstraintsData.push_back(ReadString(Record, Idx));
377     Constraints.push_back(ConstraintsData.back());
378   }
379 
380   S->initialize(Reader.getContext(), AsmStr, AsmToks,
381                 Constraints, Exprs, Clobbers);
382 }
383 
384 void ASTStmtReader::VisitCapturedStmt(CapturedStmt *S) {
385   VisitStmt(S);
386   ++Idx;
387   S->setCapturedDecl(ReadDeclAs<CapturedDecl>(Record, Idx));
388   S->setCapturedRegionKind(static_cast<CapturedRegionKind>(Record[Idx++]));
389   S->setCapturedRecordDecl(ReadDeclAs<RecordDecl>(Record, Idx));
390 
391   // Capture inits
392   for (CapturedStmt::capture_init_iterator I = S->capture_init_begin(),
393                                            E = S->capture_init_end();
394        I != E; ++I)
395     *I = Reader.ReadSubExpr();
396 
397   // Body
398   S->setCapturedStmt(Reader.ReadSubStmt());
399   S->getCapturedDecl()->setBody(S->getCapturedStmt());
400 
401   // Captures
402   for (auto &I : S->captures()) {
403     I.VarAndKind.setPointer(ReadDeclAs<VarDecl>(Record, Idx));
404     I.VarAndKind
405         .setInt(static_cast<CapturedStmt::VariableCaptureKind>(Record[Idx++]));
406     I.Loc = ReadSourceLocation(Record, Idx);
407   }
408 }
409 
410 void ASTStmtReader::VisitExpr(Expr *E) {
411   VisitStmt(E);
412   E->setType(Reader.readType(F, Record, Idx));
413   E->setTypeDependent(Record[Idx++]);
414   E->setValueDependent(Record[Idx++]);
415   E->setInstantiationDependent(Record[Idx++]);
416   E->ExprBits.ContainsUnexpandedParameterPack = Record[Idx++];
417   E->setValueKind(static_cast<ExprValueKind>(Record[Idx++]));
418   E->setObjectKind(static_cast<ExprObjectKind>(Record[Idx++]));
419   assert(Idx == NumExprFields && "Incorrect expression field count");
420 }
421 
422 void ASTStmtReader::VisitPredefinedExpr(PredefinedExpr *E) {
423   VisitExpr(E);
424   E->setLocation(ReadSourceLocation(Record, Idx));
425   E->setIdentType((PredefinedExpr::IdentType)Record[Idx++]);
426 }
427 
428 void ASTStmtReader::VisitDeclRefExpr(DeclRefExpr *E) {
429   VisitExpr(E);
430 
431   E->DeclRefExprBits.HasQualifier = Record[Idx++];
432   E->DeclRefExprBits.HasFoundDecl = Record[Idx++];
433   E->DeclRefExprBits.HasTemplateKWAndArgsInfo = Record[Idx++];
434   E->DeclRefExprBits.HadMultipleCandidates = Record[Idx++];
435   E->DeclRefExprBits.RefersToEnclosingLocal = Record[Idx++];
436   unsigned NumTemplateArgs = 0;
437   if (E->hasTemplateKWAndArgsInfo())
438     NumTemplateArgs = Record[Idx++];
439 
440   if (E->hasQualifier())
441     E->getInternalQualifierLoc()
442       = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
443 
444   if (E->hasFoundDecl())
445     E->getInternalFoundDecl() = ReadDeclAs<NamedDecl>(Record, Idx);
446 
447   if (E->hasTemplateKWAndArgsInfo())
448     ReadTemplateKWAndArgsInfo(*E->getTemplateKWAndArgsInfo(),
449                               NumTemplateArgs);
450 
451   E->setDecl(ReadDeclAs<ValueDecl>(Record, Idx));
452   E->setLocation(ReadSourceLocation(Record, Idx));
453   ReadDeclarationNameLoc(E->DNLoc, E->getDecl()->getDeclName(), Record, Idx);
454 }
455 
456 void ASTStmtReader::VisitIntegerLiteral(IntegerLiteral *E) {
457   VisitExpr(E);
458   E->setLocation(ReadSourceLocation(Record, Idx));
459   E->setValue(Reader.getContext(), Reader.ReadAPInt(Record, Idx));
460 }
461 
462 void ASTStmtReader::VisitFloatingLiteral(FloatingLiteral *E) {
463   VisitExpr(E);
464   E->setRawSemantics(static_cast<Stmt::APFloatSemantics>(Record[Idx++]));
465   E->setExact(Record[Idx++]);
466   E->setValue(Reader.getContext(),
467               Reader.ReadAPFloat(Record, E->getSemantics(), Idx));
468   E->setLocation(ReadSourceLocation(Record, Idx));
469 }
470 
471 void ASTStmtReader::VisitImaginaryLiteral(ImaginaryLiteral *E) {
472   VisitExpr(E);
473   E->setSubExpr(Reader.ReadSubExpr());
474 }
475 
476 void ASTStmtReader::VisitStringLiteral(StringLiteral *E) {
477   VisitExpr(E);
478   unsigned Len = Record[Idx++];
479   assert(Record[Idx] == E->getNumConcatenated() &&
480          "Wrong number of concatenated tokens!");
481   ++Idx;
482   StringLiteral::StringKind kind =
483         static_cast<StringLiteral::StringKind>(Record[Idx++]);
484   bool isPascal = Record[Idx++];
485 
486   // Read string data
487   SmallString<16> Str(&Record[Idx], &Record[Idx] + Len);
488   E->setString(Reader.getContext(), Str.str(), kind, isPascal);
489   Idx += Len;
490 
491   // Read source locations
492   for (unsigned I = 0, N = E->getNumConcatenated(); I != N; ++I)
493     E->setStrTokenLoc(I, ReadSourceLocation(Record, Idx));
494 }
495 
496 void ASTStmtReader::VisitCharacterLiteral(CharacterLiteral *E) {
497   VisitExpr(E);
498   E->setValue(Record[Idx++]);
499   E->setLocation(ReadSourceLocation(Record, Idx));
500   E->setKind(static_cast<CharacterLiteral::CharacterKind>(Record[Idx++]));
501 }
502 
503 void ASTStmtReader::VisitParenExpr(ParenExpr *E) {
504   VisitExpr(E);
505   E->setLParen(ReadSourceLocation(Record, Idx));
506   E->setRParen(ReadSourceLocation(Record, Idx));
507   E->setSubExpr(Reader.ReadSubExpr());
508 }
509 
510 void ASTStmtReader::VisitParenListExpr(ParenListExpr *E) {
511   VisitExpr(E);
512   unsigned NumExprs = Record[Idx++];
513   E->Exprs = new (Reader.getContext()) Stmt*[NumExprs];
514   for (unsigned i = 0; i != NumExprs; ++i)
515     E->Exprs[i] = Reader.ReadSubStmt();
516   E->NumExprs = NumExprs;
517   E->LParenLoc = ReadSourceLocation(Record, Idx);
518   E->RParenLoc = ReadSourceLocation(Record, Idx);
519 }
520 
521 void ASTStmtReader::VisitUnaryOperator(UnaryOperator *E) {
522   VisitExpr(E);
523   E->setSubExpr(Reader.ReadSubExpr());
524   E->setOpcode((UnaryOperator::Opcode)Record[Idx++]);
525   E->setOperatorLoc(ReadSourceLocation(Record, Idx));
526 }
527 
528 void ASTStmtReader::VisitOffsetOfExpr(OffsetOfExpr *E) {
529   typedef OffsetOfExpr::OffsetOfNode Node;
530   VisitExpr(E);
531   assert(E->getNumComponents() == Record[Idx]);
532   ++Idx;
533   assert(E->getNumExpressions() == Record[Idx]);
534   ++Idx;
535   E->setOperatorLoc(ReadSourceLocation(Record, Idx));
536   E->setRParenLoc(ReadSourceLocation(Record, Idx));
537   E->setTypeSourceInfo(GetTypeSourceInfo(Record, Idx));
538   for (unsigned I = 0, N = E->getNumComponents(); I != N; ++I) {
539     Node::Kind Kind = static_cast<Node::Kind>(Record[Idx++]);
540     SourceLocation Start = ReadSourceLocation(Record, Idx);
541     SourceLocation End = ReadSourceLocation(Record, Idx);
542     switch (Kind) {
543     case Node::Array:
544       E->setComponent(I, Node(Start, Record[Idx++], End));
545       break;
546 
547     case Node::Field:
548       E->setComponent(I, Node(Start, ReadDeclAs<FieldDecl>(Record, Idx), End));
549       break;
550 
551     case Node::Identifier:
552       E->setComponent(I,
553                       Node(Start,
554                            Reader.GetIdentifierInfo(F, Record, Idx),
555                            End));
556       break;
557 
558     case Node::Base: {
559       CXXBaseSpecifier *Base = new (Reader.getContext()) CXXBaseSpecifier();
560       *Base = Reader.ReadCXXBaseSpecifier(F, Record, Idx);
561       E->setComponent(I, Node(Base));
562       break;
563     }
564     }
565   }
566 
567   for (unsigned I = 0, N = E->getNumExpressions(); I != N; ++I)
568     E->setIndexExpr(I, Reader.ReadSubExpr());
569 }
570 
571 void ASTStmtReader::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E) {
572   VisitExpr(E);
573   E->setKind(static_cast<UnaryExprOrTypeTrait>(Record[Idx++]));
574   if (Record[Idx] == 0) {
575     E->setArgument(Reader.ReadSubExpr());
576     ++Idx;
577   } else {
578     E->setArgument(GetTypeSourceInfo(Record, Idx));
579   }
580   E->setOperatorLoc(ReadSourceLocation(Record, Idx));
581   E->setRParenLoc(ReadSourceLocation(Record, Idx));
582 }
583 
584 void ASTStmtReader::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
585   VisitExpr(E);
586   E->setLHS(Reader.ReadSubExpr());
587   E->setRHS(Reader.ReadSubExpr());
588   E->setRBracketLoc(ReadSourceLocation(Record, Idx));
589 }
590 
591 void ASTStmtReader::VisitCallExpr(CallExpr *E) {
592   VisitExpr(E);
593   E->setNumArgs(Reader.getContext(), Record[Idx++]);
594   E->setRParenLoc(ReadSourceLocation(Record, Idx));
595   E->setCallee(Reader.ReadSubExpr());
596   for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
597     E->setArg(I, Reader.ReadSubExpr());
598 }
599 
600 void ASTStmtReader::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
601   VisitCallExpr(E);
602 }
603 
604 void ASTStmtReader::VisitMemberExpr(MemberExpr *E) {
605   // Don't call VisitExpr, this is fully initialized at creation.
606   assert(E->getStmtClass() == Stmt::MemberExprClass &&
607          "It's a subclass, we must advance Idx!");
608 }
609 
610 void ASTStmtReader::VisitObjCIsaExpr(ObjCIsaExpr *E) {
611   VisitExpr(E);
612   E->setBase(Reader.ReadSubExpr());
613   E->setIsaMemberLoc(ReadSourceLocation(Record, Idx));
614   E->setOpLoc(ReadSourceLocation(Record, Idx));
615   E->setArrow(Record[Idx++]);
616 }
617 
618 void ASTStmtReader::
619 VisitObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *E) {
620   VisitExpr(E);
621   E->Operand = Reader.ReadSubExpr();
622   E->setShouldCopy(Record[Idx++]);
623 }
624 
625 void ASTStmtReader::VisitObjCBridgedCastExpr(ObjCBridgedCastExpr *E) {
626   VisitExplicitCastExpr(E);
627   E->LParenLoc = ReadSourceLocation(Record, Idx);
628   E->BridgeKeywordLoc = ReadSourceLocation(Record, Idx);
629   E->Kind = Record[Idx++];
630 }
631 
632 void ASTStmtReader::VisitCastExpr(CastExpr *E) {
633   VisitExpr(E);
634   unsigned NumBaseSpecs = Record[Idx++];
635   assert(NumBaseSpecs == E->path_size());
636   E->setSubExpr(Reader.ReadSubExpr());
637   E->setCastKind((CastExpr::CastKind)Record[Idx++]);
638   CastExpr::path_iterator BaseI = E->path_begin();
639   while (NumBaseSpecs--) {
640     CXXBaseSpecifier *BaseSpec = new (Reader.getContext()) CXXBaseSpecifier;
641     *BaseSpec = Reader.ReadCXXBaseSpecifier(F, Record, Idx);
642     *BaseI++ = BaseSpec;
643   }
644 }
645 
646 void ASTStmtReader::VisitBinaryOperator(BinaryOperator *E) {
647   VisitExpr(E);
648   E->setLHS(Reader.ReadSubExpr());
649   E->setRHS(Reader.ReadSubExpr());
650   E->setOpcode((BinaryOperator::Opcode)Record[Idx++]);
651   E->setOperatorLoc(ReadSourceLocation(Record, Idx));
652   E->setFPContractable((bool)Record[Idx++]);
653 }
654 
655 void ASTStmtReader::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
656   VisitBinaryOperator(E);
657   E->setComputationLHSType(Reader.readType(F, Record, Idx));
658   E->setComputationResultType(Reader.readType(F, Record, Idx));
659 }
660 
661 void ASTStmtReader::VisitConditionalOperator(ConditionalOperator *E) {
662   VisitExpr(E);
663   E->SubExprs[ConditionalOperator::COND] = Reader.ReadSubExpr();
664   E->SubExprs[ConditionalOperator::LHS] = Reader.ReadSubExpr();
665   E->SubExprs[ConditionalOperator::RHS] = Reader.ReadSubExpr();
666   E->QuestionLoc = ReadSourceLocation(Record, Idx);
667   E->ColonLoc = ReadSourceLocation(Record, Idx);
668 }
669 
670 void
671 ASTStmtReader::VisitBinaryConditionalOperator(BinaryConditionalOperator *E) {
672   VisitExpr(E);
673   E->OpaqueValue = cast<OpaqueValueExpr>(Reader.ReadSubExpr());
674   E->SubExprs[BinaryConditionalOperator::COMMON] = Reader.ReadSubExpr();
675   E->SubExprs[BinaryConditionalOperator::COND] = Reader.ReadSubExpr();
676   E->SubExprs[BinaryConditionalOperator::LHS] = Reader.ReadSubExpr();
677   E->SubExprs[BinaryConditionalOperator::RHS] = Reader.ReadSubExpr();
678   E->QuestionLoc = ReadSourceLocation(Record, Idx);
679   E->ColonLoc = ReadSourceLocation(Record, Idx);
680 }
681 
682 void ASTStmtReader::VisitImplicitCastExpr(ImplicitCastExpr *E) {
683   VisitCastExpr(E);
684 }
685 
686 void ASTStmtReader::VisitExplicitCastExpr(ExplicitCastExpr *E) {
687   VisitCastExpr(E);
688   E->setTypeInfoAsWritten(GetTypeSourceInfo(Record, Idx));
689 }
690 
691 void ASTStmtReader::VisitCStyleCastExpr(CStyleCastExpr *E) {
692   VisitExplicitCastExpr(E);
693   E->setLParenLoc(ReadSourceLocation(Record, Idx));
694   E->setRParenLoc(ReadSourceLocation(Record, Idx));
695 }
696 
697 void ASTStmtReader::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
698   VisitExpr(E);
699   E->setLParenLoc(ReadSourceLocation(Record, Idx));
700   E->setTypeSourceInfo(GetTypeSourceInfo(Record, Idx));
701   E->setInitializer(Reader.ReadSubExpr());
702   E->setFileScope(Record[Idx++]);
703 }
704 
705 void ASTStmtReader::VisitExtVectorElementExpr(ExtVectorElementExpr *E) {
706   VisitExpr(E);
707   E->setBase(Reader.ReadSubExpr());
708   E->setAccessor(Reader.GetIdentifierInfo(F, Record, Idx));
709   E->setAccessorLoc(ReadSourceLocation(Record, Idx));
710 }
711 
712 void ASTStmtReader::VisitInitListExpr(InitListExpr *E) {
713   VisitExpr(E);
714   if (InitListExpr *SyntForm = cast_or_null<InitListExpr>(Reader.ReadSubStmt()))
715     E->setSyntacticForm(SyntForm);
716   E->setLBraceLoc(ReadSourceLocation(Record, Idx));
717   E->setRBraceLoc(ReadSourceLocation(Record, Idx));
718   bool isArrayFiller = Record[Idx++];
719   Expr *filler = 0;
720   if (isArrayFiller) {
721     filler = Reader.ReadSubExpr();
722     E->ArrayFillerOrUnionFieldInit = filler;
723   } else
724     E->ArrayFillerOrUnionFieldInit = ReadDeclAs<FieldDecl>(Record, Idx);
725   E->sawArrayRangeDesignator(Record[Idx++]);
726   unsigned NumInits = Record[Idx++];
727   E->reserveInits(Reader.getContext(), NumInits);
728   if (isArrayFiller) {
729     for (unsigned I = 0; I != NumInits; ++I) {
730       Expr *init = Reader.ReadSubExpr();
731       E->updateInit(Reader.getContext(), I, init ? init : filler);
732     }
733   } else {
734     for (unsigned I = 0; I != NumInits; ++I)
735       E->updateInit(Reader.getContext(), I, Reader.ReadSubExpr());
736   }
737 }
738 
739 void ASTStmtReader::VisitDesignatedInitExpr(DesignatedInitExpr *E) {
740   typedef DesignatedInitExpr::Designator Designator;
741 
742   VisitExpr(E);
743   unsigned NumSubExprs = Record[Idx++];
744   assert(NumSubExprs == E->getNumSubExprs() && "Wrong number of subexprs");
745   for (unsigned I = 0; I != NumSubExprs; ++I)
746     E->setSubExpr(I, Reader.ReadSubExpr());
747   E->setEqualOrColonLoc(ReadSourceLocation(Record, Idx));
748   E->setGNUSyntax(Record[Idx++]);
749 
750   SmallVector<Designator, 4> Designators;
751   while (Idx < Record.size()) {
752     switch ((DesignatorTypes)Record[Idx++]) {
753     case DESIG_FIELD_DECL: {
754       FieldDecl *Field = ReadDeclAs<FieldDecl>(Record, Idx);
755       SourceLocation DotLoc
756         = ReadSourceLocation(Record, Idx);
757       SourceLocation FieldLoc
758         = ReadSourceLocation(Record, Idx);
759       Designators.push_back(Designator(Field->getIdentifier(), DotLoc,
760                                        FieldLoc));
761       Designators.back().setField(Field);
762       break;
763     }
764 
765     case DESIG_FIELD_NAME: {
766       const IdentifierInfo *Name = Reader.GetIdentifierInfo(F, Record, Idx);
767       SourceLocation DotLoc
768         = ReadSourceLocation(Record, Idx);
769       SourceLocation FieldLoc
770         = ReadSourceLocation(Record, Idx);
771       Designators.push_back(Designator(Name, DotLoc, FieldLoc));
772       break;
773     }
774 
775     case DESIG_ARRAY: {
776       unsigned Index = Record[Idx++];
777       SourceLocation LBracketLoc
778         = ReadSourceLocation(Record, Idx);
779       SourceLocation RBracketLoc
780         = ReadSourceLocation(Record, Idx);
781       Designators.push_back(Designator(Index, LBracketLoc, RBracketLoc));
782       break;
783     }
784 
785     case DESIG_ARRAY_RANGE: {
786       unsigned Index = Record[Idx++];
787       SourceLocation LBracketLoc
788         = ReadSourceLocation(Record, Idx);
789       SourceLocation EllipsisLoc
790         = ReadSourceLocation(Record, Idx);
791       SourceLocation RBracketLoc
792         = ReadSourceLocation(Record, Idx);
793       Designators.push_back(Designator(Index, LBracketLoc, EllipsisLoc,
794                                        RBracketLoc));
795       break;
796     }
797     }
798   }
799   E->setDesignators(Reader.getContext(),
800                     Designators.data(), Designators.size());
801 }
802 
803 void ASTStmtReader::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
804   VisitExpr(E);
805 }
806 
807 void ASTStmtReader::VisitVAArgExpr(VAArgExpr *E) {
808   VisitExpr(E);
809   E->setSubExpr(Reader.ReadSubExpr());
810   E->setWrittenTypeInfo(GetTypeSourceInfo(Record, Idx));
811   E->setBuiltinLoc(ReadSourceLocation(Record, Idx));
812   E->setRParenLoc(ReadSourceLocation(Record, Idx));
813 }
814 
815 void ASTStmtReader::VisitAddrLabelExpr(AddrLabelExpr *E) {
816   VisitExpr(E);
817   E->setAmpAmpLoc(ReadSourceLocation(Record, Idx));
818   E->setLabelLoc(ReadSourceLocation(Record, Idx));
819   E->setLabel(ReadDeclAs<LabelDecl>(Record, Idx));
820 }
821 
822 void ASTStmtReader::VisitStmtExpr(StmtExpr *E) {
823   VisitExpr(E);
824   E->setLParenLoc(ReadSourceLocation(Record, Idx));
825   E->setRParenLoc(ReadSourceLocation(Record, Idx));
826   E->setSubStmt(cast_or_null<CompoundStmt>(Reader.ReadSubStmt()));
827 }
828 
829 void ASTStmtReader::VisitChooseExpr(ChooseExpr *E) {
830   VisitExpr(E);
831   E->setCond(Reader.ReadSubExpr());
832   E->setLHS(Reader.ReadSubExpr());
833   E->setRHS(Reader.ReadSubExpr());
834   E->setBuiltinLoc(ReadSourceLocation(Record, Idx));
835   E->setRParenLoc(ReadSourceLocation(Record, Idx));
836   E->setIsConditionTrue(Record[Idx++]);
837 }
838 
839 void ASTStmtReader::VisitGNUNullExpr(GNUNullExpr *E) {
840   VisitExpr(E);
841   E->setTokenLocation(ReadSourceLocation(Record, Idx));
842 }
843 
844 void ASTStmtReader::VisitShuffleVectorExpr(ShuffleVectorExpr *E) {
845   VisitExpr(E);
846   SmallVector<Expr *, 16> Exprs;
847   unsigned NumExprs = Record[Idx++];
848   while (NumExprs--)
849     Exprs.push_back(Reader.ReadSubExpr());
850   E->setExprs(Reader.getContext(), Exprs);
851   E->setBuiltinLoc(ReadSourceLocation(Record, Idx));
852   E->setRParenLoc(ReadSourceLocation(Record, Idx));
853 }
854 
855 void ASTStmtReader::VisitConvertVectorExpr(ConvertVectorExpr *E) {
856   VisitExpr(E);
857   E->BuiltinLoc = ReadSourceLocation(Record, Idx);
858   E->RParenLoc = ReadSourceLocation(Record, Idx);
859   E->TInfo = GetTypeSourceInfo(Record, Idx);
860   E->SrcExpr = Reader.ReadSubExpr();
861 }
862 
863 void ASTStmtReader::VisitBlockExpr(BlockExpr *E) {
864   VisitExpr(E);
865   E->setBlockDecl(ReadDeclAs<BlockDecl>(Record, Idx));
866 }
867 
868 void ASTStmtReader::VisitGenericSelectionExpr(GenericSelectionExpr *E) {
869   VisitExpr(E);
870   E->NumAssocs = Record[Idx++];
871   E->AssocTypes = new (Reader.getContext()) TypeSourceInfo*[E->NumAssocs];
872   E->SubExprs =
873    new(Reader.getContext()) Stmt*[GenericSelectionExpr::END_EXPR+E->NumAssocs];
874 
875   E->SubExprs[GenericSelectionExpr::CONTROLLING] = Reader.ReadSubExpr();
876   for (unsigned I = 0, N = E->getNumAssocs(); I != N; ++I) {
877     E->AssocTypes[I] = GetTypeSourceInfo(Record, Idx);
878     E->SubExprs[GenericSelectionExpr::END_EXPR+I] = Reader.ReadSubExpr();
879   }
880   E->ResultIndex = Record[Idx++];
881 
882   E->GenericLoc = ReadSourceLocation(Record, Idx);
883   E->DefaultLoc = ReadSourceLocation(Record, Idx);
884   E->RParenLoc = ReadSourceLocation(Record, Idx);
885 }
886 
887 void ASTStmtReader::VisitPseudoObjectExpr(PseudoObjectExpr *E) {
888   VisitExpr(E);
889   unsigned numSemanticExprs = Record[Idx++];
890   assert(numSemanticExprs + 1 == E->PseudoObjectExprBits.NumSubExprs);
891   E->PseudoObjectExprBits.ResultIndex = Record[Idx++];
892 
893   // Read the syntactic expression.
894   E->getSubExprsBuffer()[0] = Reader.ReadSubExpr();
895 
896   // Read all the semantic expressions.
897   for (unsigned i = 0; i != numSemanticExprs; ++i) {
898     Expr *subExpr = Reader.ReadSubExpr();
899     E->getSubExprsBuffer()[i+1] = subExpr;
900   }
901 }
902 
903 void ASTStmtReader::VisitAtomicExpr(AtomicExpr *E) {
904   VisitExpr(E);
905   E->Op = AtomicExpr::AtomicOp(Record[Idx++]);
906   E->NumSubExprs = AtomicExpr::getNumSubExprs(E->Op);
907   for (unsigned I = 0; I != E->NumSubExprs; ++I)
908     E->SubExprs[I] = Reader.ReadSubExpr();
909   E->BuiltinLoc = ReadSourceLocation(Record, Idx);
910   E->RParenLoc = ReadSourceLocation(Record, Idx);
911 }
912 
913 //===----------------------------------------------------------------------===//
914 // Objective-C Expressions and Statements
915 
916 void ASTStmtReader::VisitObjCStringLiteral(ObjCStringLiteral *E) {
917   VisitExpr(E);
918   E->setString(cast<StringLiteral>(Reader.ReadSubStmt()));
919   E->setAtLoc(ReadSourceLocation(Record, Idx));
920 }
921 
922 void ASTStmtReader::VisitObjCBoxedExpr(ObjCBoxedExpr *E) {
923   VisitExpr(E);
924   // could be one of several IntegerLiteral, FloatLiteral, etc.
925   E->SubExpr = Reader.ReadSubStmt();
926   E->BoxingMethod = ReadDeclAs<ObjCMethodDecl>(Record, Idx);
927   E->Range = ReadSourceRange(Record, Idx);
928 }
929 
930 void ASTStmtReader::VisitObjCArrayLiteral(ObjCArrayLiteral *E) {
931   VisitExpr(E);
932   unsigned NumElements = Record[Idx++];
933   assert(NumElements == E->getNumElements() && "Wrong number of elements");
934   Expr **Elements = E->getElements();
935   for (unsigned I = 0, N = NumElements; I != N; ++I)
936     Elements[I] = Reader.ReadSubExpr();
937   E->ArrayWithObjectsMethod = ReadDeclAs<ObjCMethodDecl>(Record, Idx);
938   E->Range = ReadSourceRange(Record, Idx);
939 }
940 
941 void ASTStmtReader::VisitObjCDictionaryLiteral(ObjCDictionaryLiteral *E) {
942   VisitExpr(E);
943   unsigned NumElements = Record[Idx++];
944   assert(NumElements == E->getNumElements() && "Wrong number of elements");
945   bool HasPackExpansions = Record[Idx++];
946   assert(HasPackExpansions == E->HasPackExpansions &&"Pack expansion mismatch");
947   ObjCDictionaryLiteral::KeyValuePair *KeyValues = E->getKeyValues();
948   ObjCDictionaryLiteral::ExpansionData *Expansions = E->getExpansionData();
949   for (unsigned I = 0; I != NumElements; ++I) {
950     KeyValues[I].Key = Reader.ReadSubExpr();
951     KeyValues[I].Value = Reader.ReadSubExpr();
952     if (HasPackExpansions) {
953       Expansions[I].EllipsisLoc = ReadSourceLocation(Record, Idx);
954       Expansions[I].NumExpansionsPlusOne = Record[Idx++];
955     }
956   }
957   E->DictWithObjectsMethod = ReadDeclAs<ObjCMethodDecl>(Record, Idx);
958   E->Range = ReadSourceRange(Record, Idx);
959 }
960 
961 void ASTStmtReader::VisitObjCEncodeExpr(ObjCEncodeExpr *E) {
962   VisitExpr(E);
963   E->setEncodedTypeSourceInfo(GetTypeSourceInfo(Record, Idx));
964   E->setAtLoc(ReadSourceLocation(Record, Idx));
965   E->setRParenLoc(ReadSourceLocation(Record, Idx));
966 }
967 
968 void ASTStmtReader::VisitObjCSelectorExpr(ObjCSelectorExpr *E) {
969   VisitExpr(E);
970   E->setSelector(Reader.ReadSelector(F, Record, Idx));
971   E->setAtLoc(ReadSourceLocation(Record, Idx));
972   E->setRParenLoc(ReadSourceLocation(Record, Idx));
973 }
974 
975 void ASTStmtReader::VisitObjCProtocolExpr(ObjCProtocolExpr *E) {
976   VisitExpr(E);
977   E->setProtocol(ReadDeclAs<ObjCProtocolDecl>(Record, Idx));
978   E->setAtLoc(ReadSourceLocation(Record, Idx));
979   E->ProtoLoc = ReadSourceLocation(Record, Idx);
980   E->setRParenLoc(ReadSourceLocation(Record, Idx));
981 }
982 
983 void ASTStmtReader::VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
984   VisitExpr(E);
985   E->setDecl(ReadDeclAs<ObjCIvarDecl>(Record, Idx));
986   E->setLocation(ReadSourceLocation(Record, Idx));
987   E->setOpLoc(ReadSourceLocation(Record, Idx));
988   E->setBase(Reader.ReadSubExpr());
989   E->setIsArrow(Record[Idx++]);
990   E->setIsFreeIvar(Record[Idx++]);
991 }
992 
993 void ASTStmtReader::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
994   VisitExpr(E);
995   unsigned MethodRefFlags = Record[Idx++];
996   bool Implicit = Record[Idx++] != 0;
997   if (Implicit) {
998     ObjCMethodDecl *Getter = ReadDeclAs<ObjCMethodDecl>(Record, Idx);
999     ObjCMethodDecl *Setter = ReadDeclAs<ObjCMethodDecl>(Record, Idx);
1000     E->setImplicitProperty(Getter, Setter, MethodRefFlags);
1001   } else {
1002     E->setExplicitProperty(ReadDeclAs<ObjCPropertyDecl>(Record, Idx),
1003                            MethodRefFlags);
1004   }
1005   E->setLocation(ReadSourceLocation(Record, Idx));
1006   E->setReceiverLocation(ReadSourceLocation(Record, Idx));
1007   switch (Record[Idx++]) {
1008   case 0:
1009     E->setBase(Reader.ReadSubExpr());
1010     break;
1011   case 1:
1012     E->setSuperReceiver(Reader.readType(F, Record, Idx));
1013     break;
1014   case 2:
1015     E->setClassReceiver(ReadDeclAs<ObjCInterfaceDecl>(Record, Idx));
1016     break;
1017   }
1018 }
1019 
1020 void ASTStmtReader::VisitObjCSubscriptRefExpr(ObjCSubscriptRefExpr *E) {
1021   VisitExpr(E);
1022   E->setRBracket(ReadSourceLocation(Record, Idx));
1023   E->setBaseExpr(Reader.ReadSubExpr());
1024   E->setKeyExpr(Reader.ReadSubExpr());
1025   E->GetAtIndexMethodDecl = ReadDeclAs<ObjCMethodDecl>(Record, Idx);
1026   E->SetAtIndexMethodDecl = ReadDeclAs<ObjCMethodDecl>(Record, Idx);
1027 }
1028 
1029 void ASTStmtReader::VisitObjCMessageExpr(ObjCMessageExpr *E) {
1030   VisitExpr(E);
1031   assert(Record[Idx] == E->getNumArgs());
1032   ++Idx;
1033   unsigned NumStoredSelLocs = Record[Idx++];
1034   E->SelLocsKind = Record[Idx++];
1035   E->setDelegateInitCall(Record[Idx++]);
1036   E->IsImplicit = Record[Idx++];
1037   ObjCMessageExpr::ReceiverKind Kind
1038     = static_cast<ObjCMessageExpr::ReceiverKind>(Record[Idx++]);
1039   switch (Kind) {
1040   case ObjCMessageExpr::Instance:
1041     E->setInstanceReceiver(Reader.ReadSubExpr());
1042     break;
1043 
1044   case ObjCMessageExpr::Class:
1045     E->setClassReceiver(GetTypeSourceInfo(Record, Idx));
1046     break;
1047 
1048   case ObjCMessageExpr::SuperClass:
1049   case ObjCMessageExpr::SuperInstance: {
1050     QualType T = Reader.readType(F, Record, Idx);
1051     SourceLocation SuperLoc = ReadSourceLocation(Record, Idx);
1052     E->setSuper(SuperLoc, T, Kind == ObjCMessageExpr::SuperInstance);
1053     break;
1054   }
1055   }
1056 
1057   assert(Kind == E->getReceiverKind());
1058 
1059   if (Record[Idx++])
1060     E->setMethodDecl(ReadDeclAs<ObjCMethodDecl>(Record, Idx));
1061   else
1062     E->setSelector(Reader.ReadSelector(F, Record, Idx));
1063 
1064   E->LBracLoc = ReadSourceLocation(Record, Idx);
1065   E->RBracLoc = ReadSourceLocation(Record, Idx);
1066 
1067   for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
1068     E->setArg(I, Reader.ReadSubExpr());
1069 
1070   SourceLocation *Locs = E->getStoredSelLocs();
1071   for (unsigned I = 0; I != NumStoredSelLocs; ++I)
1072     Locs[I] = ReadSourceLocation(Record, Idx);
1073 }
1074 
1075 void ASTStmtReader::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) {
1076   VisitStmt(S);
1077   S->setElement(Reader.ReadSubStmt());
1078   S->setCollection(Reader.ReadSubExpr());
1079   S->setBody(Reader.ReadSubStmt());
1080   S->setForLoc(ReadSourceLocation(Record, Idx));
1081   S->setRParenLoc(ReadSourceLocation(Record, Idx));
1082 }
1083 
1084 void ASTStmtReader::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) {
1085   VisitStmt(S);
1086   S->setCatchBody(Reader.ReadSubStmt());
1087   S->setCatchParamDecl(ReadDeclAs<VarDecl>(Record, Idx));
1088   S->setAtCatchLoc(ReadSourceLocation(Record, Idx));
1089   S->setRParenLoc(ReadSourceLocation(Record, Idx));
1090 }
1091 
1092 void ASTStmtReader::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
1093   VisitStmt(S);
1094   S->setFinallyBody(Reader.ReadSubStmt());
1095   S->setAtFinallyLoc(ReadSourceLocation(Record, Idx));
1096 }
1097 
1098 void ASTStmtReader::VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S) {
1099   VisitStmt(S);
1100   S->setSubStmt(Reader.ReadSubStmt());
1101   S->setAtLoc(ReadSourceLocation(Record, Idx));
1102 }
1103 
1104 void ASTStmtReader::VisitObjCAtTryStmt(ObjCAtTryStmt *S) {
1105   VisitStmt(S);
1106   assert(Record[Idx] == S->getNumCatchStmts());
1107   ++Idx;
1108   bool HasFinally = Record[Idx++];
1109   S->setTryBody(Reader.ReadSubStmt());
1110   for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I)
1111     S->setCatchStmt(I, cast_or_null<ObjCAtCatchStmt>(Reader.ReadSubStmt()));
1112 
1113   if (HasFinally)
1114     S->setFinallyStmt(Reader.ReadSubStmt());
1115   S->setAtTryLoc(ReadSourceLocation(Record, Idx));
1116 }
1117 
1118 void ASTStmtReader::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S) {
1119   VisitStmt(S);
1120   S->setSynchExpr(Reader.ReadSubStmt());
1121   S->setSynchBody(Reader.ReadSubStmt());
1122   S->setAtSynchronizedLoc(ReadSourceLocation(Record, Idx));
1123 }
1124 
1125 void ASTStmtReader::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) {
1126   VisitStmt(S);
1127   S->setThrowExpr(Reader.ReadSubStmt());
1128   S->setThrowLoc(ReadSourceLocation(Record, Idx));
1129 }
1130 
1131 void ASTStmtReader::VisitObjCBoolLiteralExpr(ObjCBoolLiteralExpr *E) {
1132   VisitExpr(E);
1133   E->setValue(Record[Idx++]);
1134   E->setLocation(ReadSourceLocation(Record, Idx));
1135 }
1136 
1137 //===----------------------------------------------------------------------===//
1138 // C++ Expressions and Statements
1139 //===----------------------------------------------------------------------===//
1140 
1141 void ASTStmtReader::VisitCXXCatchStmt(CXXCatchStmt *S) {
1142   VisitStmt(S);
1143   S->CatchLoc = ReadSourceLocation(Record, Idx);
1144   S->ExceptionDecl = ReadDeclAs<VarDecl>(Record, Idx);
1145   S->HandlerBlock = Reader.ReadSubStmt();
1146 }
1147 
1148 void ASTStmtReader::VisitCXXTryStmt(CXXTryStmt *S) {
1149   VisitStmt(S);
1150   assert(Record[Idx] == S->getNumHandlers() && "NumStmtFields is wrong ?");
1151   ++Idx;
1152   S->TryLoc = ReadSourceLocation(Record, Idx);
1153   S->getStmts()[0] = Reader.ReadSubStmt();
1154   for (unsigned i = 0, e = S->getNumHandlers(); i != e; ++i)
1155     S->getStmts()[i + 1] = Reader.ReadSubStmt();
1156 }
1157 
1158 void ASTStmtReader::VisitCXXForRangeStmt(CXXForRangeStmt *S) {
1159   VisitStmt(S);
1160   S->setForLoc(ReadSourceLocation(Record, Idx));
1161   S->setColonLoc(ReadSourceLocation(Record, Idx));
1162   S->setRParenLoc(ReadSourceLocation(Record, Idx));
1163   S->setRangeStmt(Reader.ReadSubStmt());
1164   S->setBeginEndStmt(Reader.ReadSubStmt());
1165   S->setCond(Reader.ReadSubExpr());
1166   S->setInc(Reader.ReadSubExpr());
1167   S->setLoopVarStmt(Reader.ReadSubStmt());
1168   S->setBody(Reader.ReadSubStmt());
1169 }
1170 
1171 void ASTStmtReader::VisitMSDependentExistsStmt(MSDependentExistsStmt *S) {
1172   VisitStmt(S);
1173   S->KeywordLoc = ReadSourceLocation(Record, Idx);
1174   S->IsIfExists = Record[Idx++];
1175   S->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1176   ReadDeclarationNameInfo(S->NameInfo, Record, Idx);
1177   S->SubStmt = Reader.ReadSubStmt();
1178 }
1179 
1180 void ASTStmtReader::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
1181   VisitCallExpr(E);
1182   E->Operator = (OverloadedOperatorKind)Record[Idx++];
1183   E->Range = Reader.ReadSourceRange(F, Record, Idx);
1184   E->setFPContractable((bool)Record[Idx++]);
1185 }
1186 
1187 void ASTStmtReader::VisitCXXConstructExpr(CXXConstructExpr *E) {
1188   VisitExpr(E);
1189   E->NumArgs = Record[Idx++];
1190   if (E->NumArgs)
1191     E->Args = new (Reader.getContext()) Stmt*[E->NumArgs];
1192   for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
1193     E->setArg(I, Reader.ReadSubExpr());
1194   E->setConstructor(ReadDeclAs<CXXConstructorDecl>(Record, Idx));
1195   E->setLocation(ReadSourceLocation(Record, Idx));
1196   E->setElidable(Record[Idx++]);
1197   E->setHadMultipleCandidates(Record[Idx++]);
1198   E->setListInitialization(Record[Idx++]);
1199   E->setRequiresZeroInitialization(Record[Idx++]);
1200   E->setConstructionKind((CXXConstructExpr::ConstructionKind)Record[Idx++]);
1201   E->ParenOrBraceRange = ReadSourceRange(Record, Idx);
1202 }
1203 
1204 void ASTStmtReader::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E) {
1205   VisitCXXConstructExpr(E);
1206   E->Type = GetTypeSourceInfo(Record, Idx);
1207 }
1208 
1209 void ASTStmtReader::VisitLambdaExpr(LambdaExpr *E) {
1210   VisitExpr(E);
1211   unsigned NumCaptures = Record[Idx++];
1212   assert(NumCaptures == E->NumCaptures);(void)NumCaptures;
1213   unsigned NumArrayIndexVars = Record[Idx++];
1214   E->IntroducerRange = ReadSourceRange(Record, Idx);
1215   E->CaptureDefault = static_cast<LambdaCaptureDefault>(Record[Idx++]);
1216   E->CaptureDefaultLoc = ReadSourceLocation(Record, Idx);
1217   E->ExplicitParams = Record[Idx++];
1218   E->ExplicitResultType = Record[Idx++];
1219   E->ClosingBrace = ReadSourceLocation(Record, Idx);
1220 
1221   // Read capture initializers.
1222   for (LambdaExpr::capture_init_iterator C = E->capture_init_begin(),
1223                                       CEnd = E->capture_init_end();
1224        C != CEnd; ++C)
1225     *C = Reader.ReadSubExpr();
1226 
1227   // Read array capture index variables.
1228   if (NumArrayIndexVars > 0) {
1229     unsigned *ArrayIndexStarts = E->getArrayIndexStarts();
1230     for (unsigned I = 0; I != NumCaptures + 1; ++I)
1231       ArrayIndexStarts[I] = Record[Idx++];
1232 
1233     VarDecl **ArrayIndexVars = E->getArrayIndexVars();
1234     for (unsigned I = 0; I != NumArrayIndexVars; ++I)
1235       ArrayIndexVars[I] = ReadDeclAs<VarDecl>(Record, Idx);
1236   }
1237 }
1238 
1239 void
1240 ASTStmtReader::VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E) {
1241   VisitExpr(E);
1242   E->SubExpr = Reader.ReadSubExpr();
1243 }
1244 
1245 void ASTStmtReader::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) {
1246   VisitExplicitCastExpr(E);
1247   SourceRange R = ReadSourceRange(Record, Idx);
1248   E->Loc = R.getBegin();
1249   E->RParenLoc = R.getEnd();
1250   R = ReadSourceRange(Record, Idx);
1251   E->AngleBrackets = R;
1252 }
1253 
1254 void ASTStmtReader::VisitCXXStaticCastExpr(CXXStaticCastExpr *E) {
1255   return VisitCXXNamedCastExpr(E);
1256 }
1257 
1258 void ASTStmtReader::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *E) {
1259   return VisitCXXNamedCastExpr(E);
1260 }
1261 
1262 void ASTStmtReader::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *E) {
1263   return VisitCXXNamedCastExpr(E);
1264 }
1265 
1266 void ASTStmtReader::VisitCXXConstCastExpr(CXXConstCastExpr *E) {
1267   return VisitCXXNamedCastExpr(E);
1268 }
1269 
1270 void ASTStmtReader::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E) {
1271   VisitExplicitCastExpr(E);
1272   E->setLParenLoc(ReadSourceLocation(Record, Idx));
1273   E->setRParenLoc(ReadSourceLocation(Record, Idx));
1274 }
1275 
1276 void ASTStmtReader::VisitUserDefinedLiteral(UserDefinedLiteral *E) {
1277   VisitCallExpr(E);
1278   E->UDSuffixLoc = ReadSourceLocation(Record, Idx);
1279 }
1280 
1281 void ASTStmtReader::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
1282   VisitExpr(E);
1283   E->setValue(Record[Idx++]);
1284   E->setLocation(ReadSourceLocation(Record, Idx));
1285 }
1286 
1287 void ASTStmtReader::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) {
1288   VisitExpr(E);
1289   E->setLocation(ReadSourceLocation(Record, Idx));
1290 }
1291 
1292 void ASTStmtReader::VisitCXXTypeidExpr(CXXTypeidExpr *E) {
1293   VisitExpr(E);
1294   E->setSourceRange(ReadSourceRange(Record, Idx));
1295   if (E->isTypeOperand()) { // typeid(int)
1296     E->setTypeOperandSourceInfo(
1297         GetTypeSourceInfo(Record, Idx));
1298     return;
1299   }
1300 
1301   // typeid(42+2)
1302   E->setExprOperand(Reader.ReadSubExpr());
1303 }
1304 
1305 void ASTStmtReader::VisitCXXThisExpr(CXXThisExpr *E) {
1306   VisitExpr(E);
1307   E->setLocation(ReadSourceLocation(Record, Idx));
1308   E->setImplicit(Record[Idx++]);
1309 }
1310 
1311 void ASTStmtReader::VisitCXXThrowExpr(CXXThrowExpr *E) {
1312   VisitExpr(E);
1313   E->ThrowLoc = ReadSourceLocation(Record, Idx);
1314   E->Op = Reader.ReadSubExpr();
1315   E->IsThrownVariableInScope = Record[Idx++];
1316 }
1317 
1318 void ASTStmtReader::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
1319   VisitExpr(E);
1320 
1321   assert((bool)Record[Idx] == E->Param.getInt() && "We messed up at creation ?");
1322   ++Idx; // HasOtherExprStored and SubExpr was handled during creation.
1323   E->Param.setPointer(ReadDeclAs<ParmVarDecl>(Record, Idx));
1324   E->Loc = ReadSourceLocation(Record, Idx);
1325 }
1326 
1327 void ASTStmtReader::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E) {
1328   VisitExpr(E);
1329   E->Field = ReadDeclAs<FieldDecl>(Record, Idx);
1330   E->Loc = ReadSourceLocation(Record, Idx);
1331 }
1332 
1333 void ASTStmtReader::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
1334   VisitExpr(E);
1335   E->setTemporary(Reader.ReadCXXTemporary(F, Record, Idx));
1336   E->setSubExpr(Reader.ReadSubExpr());
1337 }
1338 
1339 void ASTStmtReader::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
1340   VisitExpr(E);
1341   E->TypeInfo = GetTypeSourceInfo(Record, Idx);
1342   E->RParenLoc = ReadSourceLocation(Record, Idx);
1343 }
1344 
1345 void ASTStmtReader::VisitCXXNewExpr(CXXNewExpr *E) {
1346   VisitExpr(E);
1347   E->GlobalNew = Record[Idx++];
1348   bool isArray = Record[Idx++];
1349   E->UsualArrayDeleteWantsSize = Record[Idx++];
1350   unsigned NumPlacementArgs = Record[Idx++];
1351   E->StoredInitializationStyle = Record[Idx++];
1352   E->setOperatorNew(ReadDeclAs<FunctionDecl>(Record, Idx));
1353   E->setOperatorDelete(ReadDeclAs<FunctionDecl>(Record, Idx));
1354   E->AllocatedTypeInfo = GetTypeSourceInfo(Record, Idx);
1355   E->TypeIdParens = ReadSourceRange(Record, Idx);
1356   E->Range = ReadSourceRange(Record, Idx);
1357   E->DirectInitRange = ReadSourceRange(Record, Idx);
1358 
1359   E->AllocateArgsArray(Reader.getContext(), isArray, NumPlacementArgs,
1360                        E->StoredInitializationStyle != 0);
1361 
1362   // Install all the subexpressions.
1363   for (CXXNewExpr::raw_arg_iterator I = E->raw_arg_begin(),e = E->raw_arg_end();
1364        I != e; ++I)
1365     *I = Reader.ReadSubStmt();
1366 }
1367 
1368 void ASTStmtReader::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
1369   VisitExpr(E);
1370   E->GlobalDelete = Record[Idx++];
1371   E->ArrayForm = Record[Idx++];
1372   E->ArrayFormAsWritten = Record[Idx++];
1373   E->UsualArrayDeleteWantsSize = Record[Idx++];
1374   E->OperatorDelete = ReadDeclAs<FunctionDecl>(Record, Idx);
1375   E->Argument = Reader.ReadSubExpr();
1376   E->Loc = ReadSourceLocation(Record, Idx);
1377 }
1378 
1379 void ASTStmtReader::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) {
1380   VisitExpr(E);
1381 
1382   E->Base = Reader.ReadSubExpr();
1383   E->IsArrow = Record[Idx++];
1384   E->OperatorLoc = ReadSourceLocation(Record, Idx);
1385   E->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1386   E->ScopeType = GetTypeSourceInfo(Record, Idx);
1387   E->ColonColonLoc = ReadSourceLocation(Record, Idx);
1388   E->TildeLoc = ReadSourceLocation(Record, Idx);
1389 
1390   IdentifierInfo *II = Reader.GetIdentifierInfo(F, Record, Idx);
1391   if (II)
1392     E->setDestroyedType(II, ReadSourceLocation(Record, Idx));
1393   else
1394     E->setDestroyedType(GetTypeSourceInfo(Record, Idx));
1395 }
1396 
1397 void ASTStmtReader::VisitExprWithCleanups(ExprWithCleanups *E) {
1398   VisitExpr(E);
1399 
1400   unsigned NumObjects = Record[Idx++];
1401   assert(NumObjects == E->getNumObjects());
1402   for (unsigned i = 0; i != NumObjects; ++i)
1403     E->getObjectsBuffer()[i] = ReadDeclAs<BlockDecl>(Record, Idx);
1404 
1405   E->SubExpr = Reader.ReadSubExpr();
1406 }
1407 
1408 void
1409 ASTStmtReader::VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E){
1410   VisitExpr(E);
1411 
1412   if (Record[Idx++]) // HasTemplateKWAndArgsInfo
1413     ReadTemplateKWAndArgsInfo(*E->getTemplateKWAndArgsInfo(),
1414                               /*NumTemplateArgs=*/Record[Idx++]);
1415 
1416   E->Base = Reader.ReadSubExpr();
1417   E->BaseType = Reader.readType(F, Record, Idx);
1418   E->IsArrow = Record[Idx++];
1419   E->OperatorLoc = ReadSourceLocation(Record, Idx);
1420   E->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1421   E->FirstQualifierFoundInScope = ReadDeclAs<NamedDecl>(Record, Idx);
1422   ReadDeclarationNameInfo(E->MemberNameInfo, Record, Idx);
1423 }
1424 
1425 void
1426 ASTStmtReader::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) {
1427   VisitExpr(E);
1428 
1429   if (Record[Idx++]) // HasTemplateKWAndArgsInfo
1430     ReadTemplateKWAndArgsInfo(*E->getTemplateKWAndArgsInfo(),
1431                               /*NumTemplateArgs=*/Record[Idx++]);
1432 
1433   E->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1434   ReadDeclarationNameInfo(E->NameInfo, Record, Idx);
1435 }
1436 
1437 void
1438 ASTStmtReader::VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E) {
1439   VisitExpr(E);
1440   assert(Record[Idx] == E->arg_size() && "Read wrong record during creation ?");
1441   ++Idx; // NumArgs;
1442   for (unsigned I = 0, N = E->arg_size(); I != N; ++I)
1443     E->setArg(I, Reader.ReadSubExpr());
1444   E->Type = GetTypeSourceInfo(Record, Idx);
1445   E->setLParenLoc(ReadSourceLocation(Record, Idx));
1446   E->setRParenLoc(ReadSourceLocation(Record, Idx));
1447 }
1448 
1449 void ASTStmtReader::VisitOverloadExpr(OverloadExpr *E) {
1450   VisitExpr(E);
1451 
1452   if (Record[Idx++]) // HasTemplateKWAndArgsInfo
1453     ReadTemplateKWAndArgsInfo(*E->getTemplateKWAndArgsInfo(),
1454                               /*NumTemplateArgs=*/Record[Idx++]);
1455 
1456   unsigned NumDecls = Record[Idx++];
1457   UnresolvedSet<8> Decls;
1458   for (unsigned i = 0; i != NumDecls; ++i) {
1459     NamedDecl *D = ReadDeclAs<NamedDecl>(Record, Idx);
1460     AccessSpecifier AS = (AccessSpecifier)Record[Idx++];
1461     Decls.addDecl(D, AS);
1462   }
1463   E->initializeResults(Reader.getContext(), Decls.begin(), Decls.end());
1464 
1465   ReadDeclarationNameInfo(E->NameInfo, Record, Idx);
1466   E->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1467 }
1468 
1469 void ASTStmtReader::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) {
1470   VisitOverloadExpr(E);
1471   E->IsArrow = Record[Idx++];
1472   E->HasUnresolvedUsing = Record[Idx++];
1473   E->Base = Reader.ReadSubExpr();
1474   E->BaseType = Reader.readType(F, Record, Idx);
1475   E->OperatorLoc = ReadSourceLocation(Record, Idx);
1476 }
1477 
1478 void ASTStmtReader::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) {
1479   VisitOverloadExpr(E);
1480   E->RequiresADL = Record[Idx++];
1481   E->Overloaded = Record[Idx++];
1482   E->NamingClass = ReadDeclAs<CXXRecordDecl>(Record, Idx);
1483 }
1484 
1485 void ASTStmtReader::VisitTypeTraitExpr(TypeTraitExpr *E) {
1486   VisitExpr(E);
1487   E->TypeTraitExprBits.NumArgs = Record[Idx++];
1488   E->TypeTraitExprBits.Kind = Record[Idx++];
1489   E->TypeTraitExprBits.Value = Record[Idx++];
1490   SourceRange Range = ReadSourceRange(Record, Idx);
1491   E->Loc = Range.getBegin();
1492   E->RParenLoc = Range.getEnd();
1493 
1494   TypeSourceInfo **Args = E->getTypeSourceInfos();
1495   for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
1496     Args[I] = GetTypeSourceInfo(Record, Idx);
1497 }
1498 
1499 void ASTStmtReader::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
1500   VisitExpr(E);
1501   E->ATT = (ArrayTypeTrait)Record[Idx++];
1502   E->Value = (unsigned int)Record[Idx++];
1503   SourceRange Range = ReadSourceRange(Record, Idx);
1504   E->Loc = Range.getBegin();
1505   E->RParen = Range.getEnd();
1506   E->QueriedType = GetTypeSourceInfo(Record, Idx);
1507 }
1508 
1509 void ASTStmtReader::VisitExpressionTraitExpr(ExpressionTraitExpr *E) {
1510   VisitExpr(E);
1511   E->ET = (ExpressionTrait)Record[Idx++];
1512   E->Value = (bool)Record[Idx++];
1513   SourceRange Range = ReadSourceRange(Record, Idx);
1514   E->QueriedExpression = Reader.ReadSubExpr();
1515   E->Loc = Range.getBegin();
1516   E->RParen = Range.getEnd();
1517 }
1518 
1519 void ASTStmtReader::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) {
1520   VisitExpr(E);
1521   E->Value = (bool)Record[Idx++];
1522   E->Range = ReadSourceRange(Record, Idx);
1523   E->Operand = Reader.ReadSubExpr();
1524 }
1525 
1526 void ASTStmtReader::VisitPackExpansionExpr(PackExpansionExpr *E) {
1527   VisitExpr(E);
1528   E->EllipsisLoc = ReadSourceLocation(Record, Idx);
1529   E->NumExpansions = Record[Idx++];
1530   E->Pattern = Reader.ReadSubExpr();
1531 }
1532 
1533 void ASTStmtReader::VisitSizeOfPackExpr(SizeOfPackExpr *E) {
1534   VisitExpr(E);
1535   E->OperatorLoc = ReadSourceLocation(Record, Idx);
1536   E->PackLoc = ReadSourceLocation(Record, Idx);
1537   E->RParenLoc = ReadSourceLocation(Record, Idx);
1538   E->Length = Record[Idx++];
1539   E->Pack = ReadDeclAs<NamedDecl>(Record, Idx);
1540 }
1541 
1542 void ASTStmtReader::VisitSubstNonTypeTemplateParmExpr(
1543                                               SubstNonTypeTemplateParmExpr *E) {
1544   VisitExpr(E);
1545   E->Param = ReadDeclAs<NonTypeTemplateParmDecl>(Record, Idx);
1546   E->NameLoc = ReadSourceLocation(Record, Idx);
1547   E->Replacement = Reader.ReadSubExpr();
1548 }
1549 
1550 void ASTStmtReader::VisitSubstNonTypeTemplateParmPackExpr(
1551                                           SubstNonTypeTemplateParmPackExpr *E) {
1552   VisitExpr(E);
1553   E->Param = ReadDeclAs<NonTypeTemplateParmDecl>(Record, Idx);
1554   TemplateArgument ArgPack = Reader.ReadTemplateArgument(F, Record, Idx);
1555   if (ArgPack.getKind() != TemplateArgument::Pack)
1556     return;
1557 
1558   E->Arguments = ArgPack.pack_begin();
1559   E->NumArguments = ArgPack.pack_size();
1560   E->NameLoc = ReadSourceLocation(Record, Idx);
1561 }
1562 
1563 void ASTStmtReader::VisitFunctionParmPackExpr(FunctionParmPackExpr *E) {
1564   VisitExpr(E);
1565   E->NumParameters = Record[Idx++];
1566   E->ParamPack = ReadDeclAs<ParmVarDecl>(Record, Idx);
1567   E->NameLoc = ReadSourceLocation(Record, Idx);
1568   ParmVarDecl **Parms = reinterpret_cast<ParmVarDecl**>(E+1);
1569   for (unsigned i = 0, n = E->NumParameters; i != n; ++i)
1570     Parms[i] = ReadDeclAs<ParmVarDecl>(Record, Idx);
1571 }
1572 
1573 void ASTStmtReader::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) {
1574   VisitExpr(E);
1575   E->Temporary = Reader.ReadSubExpr();
1576   E->ExtendingDecl = ReadDeclAs<ValueDecl>(Record, Idx);
1577 }
1578 
1579 void ASTStmtReader::VisitOpaqueValueExpr(OpaqueValueExpr *E) {
1580   VisitExpr(E);
1581   E->SourceExpr = Reader.ReadSubExpr();
1582   E->Loc = ReadSourceLocation(Record, Idx);
1583 }
1584 
1585 //===----------------------------------------------------------------------===//
1586 // Microsoft Expressions and Statements
1587 //===----------------------------------------------------------------------===//
1588 void ASTStmtReader::VisitMSPropertyRefExpr(MSPropertyRefExpr *E) {
1589   VisitExpr(E);
1590   E->IsArrow = (Record[Idx++] != 0);
1591   E->BaseExpr = Reader.ReadSubExpr();
1592   E->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1593   E->MemberLoc = ReadSourceLocation(Record, Idx);
1594   E->TheDecl = ReadDeclAs<MSPropertyDecl>(Record, Idx);
1595 }
1596 
1597 void ASTStmtReader::VisitCXXUuidofExpr(CXXUuidofExpr *E) {
1598   VisitExpr(E);
1599   E->setSourceRange(ReadSourceRange(Record, Idx));
1600   if (E->isTypeOperand()) { // __uuidof(ComType)
1601     E->setTypeOperandSourceInfo(
1602         GetTypeSourceInfo(Record, Idx));
1603     return;
1604   }
1605 
1606   // __uuidof(expr)
1607   E->setExprOperand(Reader.ReadSubExpr());
1608 }
1609 
1610 void ASTStmtReader::VisitSEHExceptStmt(SEHExceptStmt *S) {
1611   VisitStmt(S);
1612   S->Loc = ReadSourceLocation(Record, Idx);
1613   S->Children[SEHExceptStmt::FILTER_EXPR] = Reader.ReadSubStmt();
1614   S->Children[SEHExceptStmt::BLOCK] = Reader.ReadSubStmt();
1615 }
1616 
1617 void ASTStmtReader::VisitSEHFinallyStmt(SEHFinallyStmt *S) {
1618   VisitStmt(S);
1619   S->Loc = ReadSourceLocation(Record, Idx);
1620   S->Block = Reader.ReadSubStmt();
1621 }
1622 
1623 void ASTStmtReader::VisitSEHTryStmt(SEHTryStmt *S) {
1624   VisitStmt(S);
1625   S->IsCXXTry = Record[Idx++];
1626   S->TryLoc = ReadSourceLocation(Record, Idx);
1627   S->Children[SEHTryStmt::TRY] = Reader.ReadSubStmt();
1628   S->Children[SEHTryStmt::HANDLER] = Reader.ReadSubStmt();
1629 }
1630 
1631 //===----------------------------------------------------------------------===//
1632 // CUDA Expressions and Statements
1633 //===----------------------------------------------------------------------===//
1634 
1635 void ASTStmtReader::VisitCUDAKernelCallExpr(CUDAKernelCallExpr *E) {
1636   VisitCallExpr(E);
1637   E->setConfig(cast<CallExpr>(Reader.ReadSubExpr()));
1638 }
1639 
1640 //===----------------------------------------------------------------------===//
1641 // OpenCL Expressions and Statements.
1642 //===----------------------------------------------------------------------===//
1643 void ASTStmtReader::VisitAsTypeExpr(AsTypeExpr *E) {
1644   VisitExpr(E);
1645   E->BuiltinLoc = ReadSourceLocation(Record, Idx);
1646   E->RParenLoc = ReadSourceLocation(Record, Idx);
1647   E->SrcExpr = Reader.ReadSubExpr();
1648 }
1649 
1650 //===----------------------------------------------------------------------===//
1651 // OpenMP Clauses.
1652 //===----------------------------------------------------------------------===//
1653 
1654 namespace clang {
1655 class OMPClauseReader : public OMPClauseVisitor<OMPClauseReader> {
1656   ASTStmtReader *Reader;
1657   ASTContext &Context;
1658   const ASTReader::RecordData &Record;
1659   unsigned &Idx;
1660 public:
1661   OMPClauseReader(ASTStmtReader *R, ASTContext &C,
1662                   const ASTReader::RecordData &Record, unsigned &Idx)
1663     : Reader(R), Context(C), Record(Record), Idx(Idx) { }
1664 #define OPENMP_CLAUSE(Name, Class)    \
1665   void Visit##Class(Class *S);
1666 #include "clang/Basic/OpenMPKinds.def"
1667   OMPClause *readClause();
1668 };
1669 }
1670 
1671 OMPClause *OMPClauseReader::readClause() {
1672   OMPClause *C;
1673   switch (Record[Idx++]) {
1674   case OMPC_if:
1675     C = new (Context) OMPIfClause();
1676     break;
1677   case OMPC_num_threads:
1678     C = new (Context) OMPNumThreadsClause();
1679     break;
1680   case OMPC_safelen:
1681     C = new (Context) OMPSafelenClause();
1682     break;
1683   case OMPC_default:
1684     C = new (Context) OMPDefaultClause();
1685     break;
1686   case OMPC_private:
1687     C = OMPPrivateClause::CreateEmpty(Context, Record[Idx++]);
1688     break;
1689   case OMPC_firstprivate:
1690     C = OMPFirstprivateClause::CreateEmpty(Context, Record[Idx++]);
1691     break;
1692   case OMPC_shared:
1693     C = OMPSharedClause::CreateEmpty(Context, Record[Idx++]);
1694     break;
1695   case OMPC_linear:
1696     C = OMPLinearClause::CreateEmpty(Context, Record[Idx++]);
1697     break;
1698   case OMPC_copyin:
1699     C = OMPCopyinClause::CreateEmpty(Context, Record[Idx++]);
1700     break;
1701   }
1702   Visit(C);
1703   C->setLocStart(Reader->ReadSourceLocation(Record, Idx));
1704   C->setLocEnd(Reader->ReadSourceLocation(Record, Idx));
1705 
1706   return C;
1707 }
1708 
1709 void OMPClauseReader::VisitOMPIfClause(OMPIfClause *C) {
1710   C->setCondition(Reader->Reader.ReadSubExpr());
1711   C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));
1712 }
1713 
1714 void OMPClauseReader::VisitOMPNumThreadsClause(OMPNumThreadsClause *C) {
1715   C->setNumThreads(Reader->Reader.ReadSubExpr());
1716   C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));
1717 }
1718 
1719 void OMPClauseReader::VisitOMPSafelenClause(OMPSafelenClause *C) {
1720   C->setSafelen(Reader->Reader.ReadSubExpr());
1721   C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));
1722 }
1723 
1724 void OMPClauseReader::VisitOMPDefaultClause(OMPDefaultClause *C) {
1725   C->setDefaultKind(
1726        static_cast<OpenMPDefaultClauseKind>(Record[Idx++]));
1727   C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));
1728   C->setDefaultKindKwLoc(Reader->ReadSourceLocation(Record, Idx));
1729 }
1730 
1731 void OMPClauseReader::VisitOMPPrivateClause(OMPPrivateClause *C) {
1732   C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));
1733   unsigned NumVars = C->varlist_size();
1734   SmallVector<Expr *, 16> Vars;
1735   Vars.reserve(NumVars);
1736   for (unsigned i = 0; i != NumVars; ++i)
1737     Vars.push_back(Reader->Reader.ReadSubExpr());
1738   C->setVarRefs(Vars);
1739 }
1740 
1741 void OMPClauseReader::VisitOMPFirstprivateClause(OMPFirstprivateClause *C) {
1742   C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));
1743   unsigned NumVars = C->varlist_size();
1744   SmallVector<Expr *, 16> Vars;
1745   Vars.reserve(NumVars);
1746   for (unsigned i = 0; i != NumVars; ++i)
1747     Vars.push_back(Reader->Reader.ReadSubExpr());
1748   C->setVarRefs(Vars);
1749 }
1750 
1751 void OMPClauseReader::VisitOMPSharedClause(OMPSharedClause *C) {
1752   C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));
1753   unsigned NumVars = C->varlist_size();
1754   SmallVector<Expr *, 16> Vars;
1755   Vars.reserve(NumVars);
1756   for (unsigned i = 0; i != NumVars; ++i)
1757     Vars.push_back(Reader->Reader.ReadSubExpr());
1758   C->setVarRefs(Vars);
1759 }
1760 
1761 void OMPClauseReader::VisitOMPLinearClause(OMPLinearClause *C) {
1762   C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));
1763   C->setColonLoc(Reader->ReadSourceLocation(Record, Idx));
1764   unsigned NumVars = C->varlist_size();
1765   SmallVector<Expr *, 16> Vars;
1766   Vars.reserve(NumVars);
1767   for (unsigned i = 0; i != NumVars; ++i)
1768     Vars.push_back(Reader->Reader.ReadSubExpr());
1769   C->setVarRefs(Vars);
1770   C->setStep(Reader->Reader.ReadSubExpr());
1771 }
1772 
1773 void OMPClauseReader::VisitOMPCopyinClause(OMPCopyinClause *C) {
1774   C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));
1775   unsigned NumVars = C->varlist_size();
1776   SmallVector<Expr *, 16> Vars;
1777   Vars.reserve(NumVars);
1778   for (unsigned i = 0; i != NumVars; ++i)
1779     Vars.push_back(Reader->Reader.ReadSubExpr());
1780   C->setVarRefs(Vars);
1781 }
1782 
1783 //===----------------------------------------------------------------------===//
1784 // OpenMP Directives.
1785 //===----------------------------------------------------------------------===//
1786 void ASTStmtReader::VisitOMPExecutableDirective(OMPExecutableDirective *E) {
1787   E->setLocStart(ReadSourceLocation(Record, Idx));
1788   E->setLocEnd(ReadSourceLocation(Record, Idx));
1789   OMPClauseReader ClauseReader(this, Reader.getContext(), Record, Idx);
1790   SmallVector<OMPClause *, 5> Clauses;
1791   for (unsigned i = 0; i < E->getNumClauses(); ++i)
1792     Clauses.push_back(ClauseReader.readClause());
1793   E->setClauses(Clauses);
1794   E->setAssociatedStmt(Reader.ReadSubStmt());
1795 }
1796 
1797 void ASTStmtReader::VisitOMPParallelDirective(OMPParallelDirective *D) {
1798   VisitStmt(D);
1799   // The NumClauses field was read in ReadStmtFromStream.
1800   ++Idx;
1801   VisitOMPExecutableDirective(D);
1802 }
1803 
1804 void ASTStmtReader::VisitOMPSimdDirective(OMPSimdDirective *D) {
1805   VisitStmt(D);
1806   // Two fields (NumClauses and CollapsedNum) were read in ReadStmtFromStream.
1807   Idx += 2;
1808   VisitOMPExecutableDirective(D);
1809 }
1810 
1811 //===----------------------------------------------------------------------===//
1812 // ASTReader Implementation
1813 //===----------------------------------------------------------------------===//
1814 
1815 Stmt *ASTReader::ReadStmt(ModuleFile &F) {
1816   switch (ReadingKind) {
1817   case Read_None:
1818     llvm_unreachable("should not call this when not reading anything");
1819   case Read_Decl:
1820   case Read_Type:
1821     return ReadStmtFromStream(F);
1822   case Read_Stmt:
1823     return ReadSubStmt();
1824   }
1825 
1826   llvm_unreachable("ReadingKind not set ?");
1827 }
1828 
1829 Expr *ASTReader::ReadExpr(ModuleFile &F) {
1830   return cast_or_null<Expr>(ReadStmt(F));
1831 }
1832 
1833 Expr *ASTReader::ReadSubExpr() {
1834   return cast_or_null<Expr>(ReadSubStmt());
1835 }
1836 
1837 // Within the bitstream, expressions are stored in Reverse Polish
1838 // Notation, with each of the subexpressions preceding the
1839 // expression they are stored in. Subexpressions are stored from last to first.
1840 // To evaluate expressions, we continue reading expressions and placing them on
1841 // the stack, with expressions having operands removing those operands from the
1842 // stack. Evaluation terminates when we see a STMT_STOP record, and
1843 // the single remaining expression on the stack is our result.
1844 Stmt *ASTReader::ReadStmtFromStream(ModuleFile &F) {
1845 
1846   ReadingKindTracker ReadingKind(Read_Stmt, *this);
1847   llvm::BitstreamCursor &Cursor = F.DeclsCursor;
1848 
1849   // Map of offset to previously deserialized stmt. The offset points
1850   /// just after the stmt record.
1851   llvm::DenseMap<uint64_t, Stmt *> StmtEntries;
1852 
1853 #ifndef NDEBUG
1854   unsigned PrevNumStmts = StmtStack.size();
1855 #endif
1856 
1857   RecordData Record;
1858   unsigned Idx;
1859   ASTStmtReader Reader(*this, F, Cursor, Record, Idx);
1860   Stmt::EmptyShell Empty;
1861 
1862   while (true) {
1863     llvm::BitstreamEntry Entry = Cursor.advanceSkippingSubblocks();
1864 
1865     switch (Entry.Kind) {
1866     case llvm::BitstreamEntry::SubBlock: // Handled for us already.
1867     case llvm::BitstreamEntry::Error:
1868       Error("malformed block record in AST file");
1869       return 0;
1870     case llvm::BitstreamEntry::EndBlock:
1871       goto Done;
1872     case llvm::BitstreamEntry::Record:
1873       // The interesting case.
1874       break;
1875     }
1876 
1877 
1878     Stmt *S = 0;
1879     Idx = 0;
1880     Record.clear();
1881     bool Finished = false;
1882     bool IsStmtReference = false;
1883     switch ((StmtCode)Cursor.readRecord(Entry.ID, Record)) {
1884     case STMT_STOP:
1885       Finished = true;
1886       break;
1887 
1888     case STMT_REF_PTR:
1889       IsStmtReference = true;
1890       assert(StmtEntries.find(Record[0]) != StmtEntries.end() &&
1891              "No stmt was recorded for this offset reference!");
1892       S = StmtEntries[Record[Idx++]];
1893       break;
1894 
1895     case STMT_NULL_PTR:
1896       S = 0;
1897       break;
1898 
1899     case STMT_NULL:
1900       S = new (Context) NullStmt(Empty);
1901       break;
1902 
1903     case STMT_COMPOUND:
1904       S = new (Context) CompoundStmt(Empty);
1905       break;
1906 
1907     case STMT_CASE:
1908       S = new (Context) CaseStmt(Empty);
1909       break;
1910 
1911     case STMT_DEFAULT:
1912       S = new (Context) DefaultStmt(Empty);
1913       break;
1914 
1915     case STMT_LABEL:
1916       S = new (Context) LabelStmt(Empty);
1917       break;
1918 
1919     case STMT_ATTRIBUTED:
1920       S = AttributedStmt::CreateEmpty(
1921         Context,
1922         /*NumAttrs*/Record[ASTStmtReader::NumStmtFields]);
1923       break;
1924 
1925     case STMT_IF:
1926       S = new (Context) IfStmt(Empty);
1927       break;
1928 
1929     case STMT_SWITCH:
1930       S = new (Context) SwitchStmt(Empty);
1931       break;
1932 
1933     case STMT_WHILE:
1934       S = new (Context) WhileStmt(Empty);
1935       break;
1936 
1937     case STMT_DO:
1938       S = new (Context) DoStmt(Empty);
1939       break;
1940 
1941     case STMT_FOR:
1942       S = new (Context) ForStmt(Empty);
1943       break;
1944 
1945     case STMT_GOTO:
1946       S = new (Context) GotoStmt(Empty);
1947       break;
1948 
1949     case STMT_INDIRECT_GOTO:
1950       S = new (Context) IndirectGotoStmt(Empty);
1951       break;
1952 
1953     case STMT_CONTINUE:
1954       S = new (Context) ContinueStmt(Empty);
1955       break;
1956 
1957     case STMT_BREAK:
1958       S = new (Context) BreakStmt(Empty);
1959       break;
1960 
1961     case STMT_RETURN:
1962       S = new (Context) ReturnStmt(Empty);
1963       break;
1964 
1965     case STMT_DECL:
1966       S = new (Context) DeclStmt(Empty);
1967       break;
1968 
1969     case STMT_GCCASM:
1970       S = new (Context) GCCAsmStmt(Empty);
1971       break;
1972 
1973     case STMT_MSASM:
1974       S = new (Context) MSAsmStmt(Empty);
1975       break;
1976 
1977     case STMT_CAPTURED:
1978       S = CapturedStmt::CreateDeserialized(Context,
1979                                            Record[ASTStmtReader::NumStmtFields]);
1980       break;
1981 
1982     case EXPR_PREDEFINED:
1983       S = new (Context) PredefinedExpr(Empty);
1984       break;
1985 
1986     case EXPR_DECL_REF:
1987       S = DeclRefExpr::CreateEmpty(
1988         Context,
1989         /*HasQualifier=*/Record[ASTStmtReader::NumExprFields],
1990         /*HasFoundDecl=*/Record[ASTStmtReader::NumExprFields + 1],
1991         /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields + 2],
1992         /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields + 2] ?
1993           Record[ASTStmtReader::NumExprFields + 5] : 0);
1994       break;
1995 
1996     case EXPR_INTEGER_LITERAL:
1997       S = IntegerLiteral::Create(Context, Empty);
1998       break;
1999 
2000     case EXPR_FLOATING_LITERAL:
2001       S = FloatingLiteral::Create(Context, Empty);
2002       break;
2003 
2004     case EXPR_IMAGINARY_LITERAL:
2005       S = new (Context) ImaginaryLiteral(Empty);
2006       break;
2007 
2008     case EXPR_STRING_LITERAL:
2009       S = StringLiteral::CreateEmpty(Context,
2010                                      Record[ASTStmtReader::NumExprFields + 1]);
2011       break;
2012 
2013     case EXPR_CHARACTER_LITERAL:
2014       S = new (Context) CharacterLiteral(Empty);
2015       break;
2016 
2017     case EXPR_PAREN:
2018       S = new (Context) ParenExpr(Empty);
2019       break;
2020 
2021     case EXPR_PAREN_LIST:
2022       S = new (Context) ParenListExpr(Empty);
2023       break;
2024 
2025     case EXPR_UNARY_OPERATOR:
2026       S = new (Context) UnaryOperator(Empty);
2027       break;
2028 
2029     case EXPR_OFFSETOF:
2030       S = OffsetOfExpr::CreateEmpty(Context,
2031                                     Record[ASTStmtReader::NumExprFields],
2032                                     Record[ASTStmtReader::NumExprFields + 1]);
2033       break;
2034 
2035     case EXPR_SIZEOF_ALIGN_OF:
2036       S = new (Context) UnaryExprOrTypeTraitExpr(Empty);
2037       break;
2038 
2039     case EXPR_ARRAY_SUBSCRIPT:
2040       S = new (Context) ArraySubscriptExpr(Empty);
2041       break;
2042 
2043     case EXPR_CALL:
2044       S = new (Context) CallExpr(Context, Stmt::CallExprClass, Empty);
2045       break;
2046 
2047     case EXPR_MEMBER: {
2048       // We load everything here and fully initialize it at creation.
2049       // That way we can use MemberExpr::Create and don't have to duplicate its
2050       // logic with a MemberExpr::CreateEmpty.
2051 
2052       assert(Idx == 0);
2053       NestedNameSpecifierLoc QualifierLoc;
2054       if (Record[Idx++]) { // HasQualifier.
2055         QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, Idx);
2056       }
2057 
2058       SourceLocation TemplateKWLoc;
2059       TemplateArgumentListInfo ArgInfo;
2060       bool HasTemplateKWAndArgsInfo = Record[Idx++];
2061       if (HasTemplateKWAndArgsInfo) {
2062         TemplateKWLoc = ReadSourceLocation(F, Record, Idx);
2063         unsigned NumTemplateArgs = Record[Idx++];
2064         ArgInfo.setLAngleLoc(ReadSourceLocation(F, Record, Idx));
2065         ArgInfo.setRAngleLoc(ReadSourceLocation(F, Record, Idx));
2066         for (unsigned i = 0; i != NumTemplateArgs; ++i)
2067           ArgInfo.addArgument(ReadTemplateArgumentLoc(F, Record, Idx));
2068       }
2069 
2070       bool HadMultipleCandidates = Record[Idx++];
2071 
2072       NamedDecl *FoundD = ReadDeclAs<NamedDecl>(F, Record, Idx);
2073       AccessSpecifier AS = (AccessSpecifier)Record[Idx++];
2074       DeclAccessPair FoundDecl = DeclAccessPair::make(FoundD, AS);
2075 
2076       QualType T = readType(F, Record, Idx);
2077       ExprValueKind VK = static_cast<ExprValueKind>(Record[Idx++]);
2078       ExprObjectKind OK = static_cast<ExprObjectKind>(Record[Idx++]);
2079       Expr *Base = ReadSubExpr();
2080       ValueDecl *MemberD = ReadDeclAs<ValueDecl>(F, Record, Idx);
2081       SourceLocation MemberLoc = ReadSourceLocation(F, Record, Idx);
2082       DeclarationNameInfo MemberNameInfo(MemberD->getDeclName(), MemberLoc);
2083       bool IsArrow = Record[Idx++];
2084 
2085       S = MemberExpr::Create(Context, Base, IsArrow, QualifierLoc,
2086                              TemplateKWLoc, MemberD, FoundDecl, MemberNameInfo,
2087                              HasTemplateKWAndArgsInfo ? &ArgInfo : 0,
2088                              T, VK, OK);
2089       ReadDeclarationNameLoc(F, cast<MemberExpr>(S)->MemberDNLoc,
2090                              MemberD->getDeclName(), Record, Idx);
2091       if (HadMultipleCandidates)
2092         cast<MemberExpr>(S)->setHadMultipleCandidates(true);
2093       break;
2094     }
2095 
2096     case EXPR_BINARY_OPERATOR:
2097       S = new (Context) BinaryOperator(Empty);
2098       break;
2099 
2100     case EXPR_COMPOUND_ASSIGN_OPERATOR:
2101       S = new (Context) CompoundAssignOperator(Empty);
2102       break;
2103 
2104     case EXPR_CONDITIONAL_OPERATOR:
2105       S = new (Context) ConditionalOperator(Empty);
2106       break;
2107 
2108     case EXPR_BINARY_CONDITIONAL_OPERATOR:
2109       S = new (Context) BinaryConditionalOperator(Empty);
2110       break;
2111 
2112     case EXPR_IMPLICIT_CAST:
2113       S = ImplicitCastExpr::CreateEmpty(Context,
2114                        /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
2115       break;
2116 
2117     case EXPR_CSTYLE_CAST:
2118       S = CStyleCastExpr::CreateEmpty(Context,
2119                        /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
2120       break;
2121 
2122     case EXPR_COMPOUND_LITERAL:
2123       S = new (Context) CompoundLiteralExpr(Empty);
2124       break;
2125 
2126     case EXPR_EXT_VECTOR_ELEMENT:
2127       S = new (Context) ExtVectorElementExpr(Empty);
2128       break;
2129 
2130     case EXPR_INIT_LIST:
2131       S = new (Context) InitListExpr(Empty);
2132       break;
2133 
2134     case EXPR_DESIGNATED_INIT:
2135       S = DesignatedInitExpr::CreateEmpty(Context,
2136                                      Record[ASTStmtReader::NumExprFields] - 1);
2137 
2138       break;
2139 
2140     case EXPR_IMPLICIT_VALUE_INIT:
2141       S = new (Context) ImplicitValueInitExpr(Empty);
2142       break;
2143 
2144     case EXPR_VA_ARG:
2145       S = new (Context) VAArgExpr(Empty);
2146       break;
2147 
2148     case EXPR_ADDR_LABEL:
2149       S = new (Context) AddrLabelExpr(Empty);
2150       break;
2151 
2152     case EXPR_STMT:
2153       S = new (Context) StmtExpr(Empty);
2154       break;
2155 
2156     case EXPR_CHOOSE:
2157       S = new (Context) ChooseExpr(Empty);
2158       break;
2159 
2160     case EXPR_GNU_NULL:
2161       S = new (Context) GNUNullExpr(Empty);
2162       break;
2163 
2164     case EXPR_SHUFFLE_VECTOR:
2165       S = new (Context) ShuffleVectorExpr(Empty);
2166       break;
2167 
2168     case EXPR_CONVERT_VECTOR:
2169       S = new (Context) ConvertVectorExpr(Empty);
2170       break;
2171 
2172     case EXPR_BLOCK:
2173       S = new (Context) BlockExpr(Empty);
2174       break;
2175 
2176     case EXPR_GENERIC_SELECTION:
2177       S = new (Context) GenericSelectionExpr(Empty);
2178       break;
2179 
2180     case EXPR_OBJC_STRING_LITERAL:
2181       S = new (Context) ObjCStringLiteral(Empty);
2182       break;
2183     case EXPR_OBJC_BOXED_EXPRESSION:
2184       S = new (Context) ObjCBoxedExpr(Empty);
2185       break;
2186     case EXPR_OBJC_ARRAY_LITERAL:
2187       S = ObjCArrayLiteral::CreateEmpty(Context,
2188                                         Record[ASTStmtReader::NumExprFields]);
2189       break;
2190     case EXPR_OBJC_DICTIONARY_LITERAL:
2191       S = ObjCDictionaryLiteral::CreateEmpty(Context,
2192             Record[ASTStmtReader::NumExprFields],
2193             Record[ASTStmtReader::NumExprFields + 1]);
2194       break;
2195     case EXPR_OBJC_ENCODE:
2196       S = new (Context) ObjCEncodeExpr(Empty);
2197       break;
2198     case EXPR_OBJC_SELECTOR_EXPR:
2199       S = new (Context) ObjCSelectorExpr(Empty);
2200       break;
2201     case EXPR_OBJC_PROTOCOL_EXPR:
2202       S = new (Context) ObjCProtocolExpr(Empty);
2203       break;
2204     case EXPR_OBJC_IVAR_REF_EXPR:
2205       S = new (Context) ObjCIvarRefExpr(Empty);
2206       break;
2207     case EXPR_OBJC_PROPERTY_REF_EXPR:
2208       S = new (Context) ObjCPropertyRefExpr(Empty);
2209       break;
2210     case EXPR_OBJC_SUBSCRIPT_REF_EXPR:
2211       S = new (Context) ObjCSubscriptRefExpr(Empty);
2212       break;
2213     case EXPR_OBJC_KVC_REF_EXPR:
2214       llvm_unreachable("mismatching AST file");
2215     case EXPR_OBJC_MESSAGE_EXPR:
2216       S = ObjCMessageExpr::CreateEmpty(Context,
2217                                      Record[ASTStmtReader::NumExprFields],
2218                                      Record[ASTStmtReader::NumExprFields + 1]);
2219       break;
2220     case EXPR_OBJC_ISA:
2221       S = new (Context) ObjCIsaExpr(Empty);
2222       break;
2223     case EXPR_OBJC_INDIRECT_COPY_RESTORE:
2224       S = new (Context) ObjCIndirectCopyRestoreExpr(Empty);
2225       break;
2226     case EXPR_OBJC_BRIDGED_CAST:
2227       S = new (Context) ObjCBridgedCastExpr(Empty);
2228       break;
2229     case STMT_OBJC_FOR_COLLECTION:
2230       S = new (Context) ObjCForCollectionStmt(Empty);
2231       break;
2232     case STMT_OBJC_CATCH:
2233       S = new (Context) ObjCAtCatchStmt(Empty);
2234       break;
2235     case STMT_OBJC_FINALLY:
2236       S = new (Context) ObjCAtFinallyStmt(Empty);
2237       break;
2238     case STMT_OBJC_AT_TRY:
2239       S = ObjCAtTryStmt::CreateEmpty(Context,
2240                                      Record[ASTStmtReader::NumStmtFields],
2241                                      Record[ASTStmtReader::NumStmtFields + 1]);
2242       break;
2243     case STMT_OBJC_AT_SYNCHRONIZED:
2244       S = new (Context) ObjCAtSynchronizedStmt(Empty);
2245       break;
2246     case STMT_OBJC_AT_THROW:
2247       S = new (Context) ObjCAtThrowStmt(Empty);
2248       break;
2249     case STMT_OBJC_AUTORELEASE_POOL:
2250       S = new (Context) ObjCAutoreleasePoolStmt(Empty);
2251       break;
2252     case EXPR_OBJC_BOOL_LITERAL:
2253       S = new (Context) ObjCBoolLiteralExpr(Empty);
2254       break;
2255     case STMT_SEH_EXCEPT:
2256       S = new (Context) SEHExceptStmt(Empty);
2257       break;
2258     case STMT_SEH_FINALLY:
2259       S = new (Context) SEHFinallyStmt(Empty);
2260       break;
2261     case STMT_SEH_TRY:
2262       S = new (Context) SEHTryStmt(Empty);
2263       break;
2264     case STMT_CXX_CATCH:
2265       S = new (Context) CXXCatchStmt(Empty);
2266       break;
2267 
2268     case STMT_CXX_TRY:
2269       S = CXXTryStmt::Create(Context, Empty,
2270              /*NumHandlers=*/Record[ASTStmtReader::NumStmtFields]);
2271       break;
2272 
2273     case STMT_CXX_FOR_RANGE:
2274       S = new (Context) CXXForRangeStmt(Empty);
2275       break;
2276 
2277     case STMT_MS_DEPENDENT_EXISTS:
2278       S = new (Context) MSDependentExistsStmt(SourceLocation(), true,
2279                                               NestedNameSpecifierLoc(),
2280                                               DeclarationNameInfo(),
2281                                               0);
2282       break;
2283 
2284     case STMT_OMP_PARALLEL_DIRECTIVE:
2285       S =
2286         OMPParallelDirective::CreateEmpty(Context,
2287                                           Record[ASTStmtReader::NumStmtFields],
2288                                           Empty);
2289       break;
2290 
2291     case STMT_OMP_SIMD_DIRECTIVE: {
2292       unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
2293       unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
2294       S = OMPSimdDirective::CreateEmpty(Context, NumClauses,
2295                                         CollapsedNum, Empty);
2296       break;
2297     }
2298 
2299     case EXPR_CXX_OPERATOR_CALL:
2300       S = new (Context) CXXOperatorCallExpr(Context, Empty);
2301       break;
2302 
2303     case EXPR_CXX_MEMBER_CALL:
2304       S = new (Context) CXXMemberCallExpr(Context, Empty);
2305       break;
2306 
2307     case EXPR_CXX_CONSTRUCT:
2308       S = new (Context) CXXConstructExpr(Empty);
2309       break;
2310 
2311     case EXPR_CXX_TEMPORARY_OBJECT:
2312       S = new (Context) CXXTemporaryObjectExpr(Empty);
2313       break;
2314 
2315     case EXPR_CXX_STATIC_CAST:
2316       S = CXXStaticCastExpr::CreateEmpty(Context,
2317                        /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
2318       break;
2319 
2320     case EXPR_CXX_DYNAMIC_CAST:
2321       S = CXXDynamicCastExpr::CreateEmpty(Context,
2322                        /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
2323       break;
2324 
2325     case EXPR_CXX_REINTERPRET_CAST:
2326       S = CXXReinterpretCastExpr::CreateEmpty(Context,
2327                        /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
2328       break;
2329 
2330     case EXPR_CXX_CONST_CAST:
2331       S = CXXConstCastExpr::CreateEmpty(Context);
2332       break;
2333 
2334     case EXPR_CXX_FUNCTIONAL_CAST:
2335       S = CXXFunctionalCastExpr::CreateEmpty(Context,
2336                        /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
2337       break;
2338 
2339     case EXPR_USER_DEFINED_LITERAL:
2340       S = new (Context) UserDefinedLiteral(Context, Empty);
2341       break;
2342 
2343     case EXPR_CXX_STD_INITIALIZER_LIST:
2344       S = new (Context) CXXStdInitializerListExpr(Empty);
2345       break;
2346 
2347     case EXPR_CXX_BOOL_LITERAL:
2348       S = new (Context) CXXBoolLiteralExpr(Empty);
2349       break;
2350 
2351     case EXPR_CXX_NULL_PTR_LITERAL:
2352       S = new (Context) CXXNullPtrLiteralExpr(Empty);
2353       break;
2354     case EXPR_CXX_TYPEID_EXPR:
2355       S = new (Context) CXXTypeidExpr(Empty, true);
2356       break;
2357     case EXPR_CXX_TYPEID_TYPE:
2358       S = new (Context) CXXTypeidExpr(Empty, false);
2359       break;
2360     case EXPR_CXX_UUIDOF_EXPR:
2361       S = new (Context) CXXUuidofExpr(Empty, true);
2362       break;
2363     case EXPR_CXX_PROPERTY_REF_EXPR:
2364       S = new (Context) MSPropertyRefExpr(Empty);
2365       break;
2366     case EXPR_CXX_UUIDOF_TYPE:
2367       S = new (Context) CXXUuidofExpr(Empty, false);
2368       break;
2369     case EXPR_CXX_THIS:
2370       S = new (Context) CXXThisExpr(Empty);
2371       break;
2372     case EXPR_CXX_THROW:
2373       S = new (Context) CXXThrowExpr(Empty);
2374       break;
2375     case EXPR_CXX_DEFAULT_ARG: {
2376       bool HasOtherExprStored = Record[ASTStmtReader::NumExprFields];
2377       if (HasOtherExprStored) {
2378         Expr *SubExpr = ReadSubExpr();
2379         S = CXXDefaultArgExpr::Create(Context, SourceLocation(), 0, SubExpr);
2380       } else
2381         S = new (Context) CXXDefaultArgExpr(Empty);
2382       break;
2383     }
2384     case EXPR_CXX_DEFAULT_INIT:
2385       S = new (Context) CXXDefaultInitExpr(Empty);
2386       break;
2387     case EXPR_CXX_BIND_TEMPORARY:
2388       S = new (Context) CXXBindTemporaryExpr(Empty);
2389       break;
2390 
2391     case EXPR_CXX_SCALAR_VALUE_INIT:
2392       S = new (Context) CXXScalarValueInitExpr(Empty);
2393       break;
2394     case EXPR_CXX_NEW:
2395       S = new (Context) CXXNewExpr(Empty);
2396       break;
2397     case EXPR_CXX_DELETE:
2398       S = new (Context) CXXDeleteExpr(Empty);
2399       break;
2400     case EXPR_CXX_PSEUDO_DESTRUCTOR:
2401       S = new (Context) CXXPseudoDestructorExpr(Empty);
2402       break;
2403 
2404     case EXPR_EXPR_WITH_CLEANUPS:
2405       S = ExprWithCleanups::Create(Context, Empty,
2406                                    Record[ASTStmtReader::NumExprFields]);
2407       break;
2408 
2409     case EXPR_CXX_DEPENDENT_SCOPE_MEMBER:
2410       S = CXXDependentScopeMemberExpr::CreateEmpty(Context,
2411          /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields],
2412                   /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]
2413                                    ? Record[ASTStmtReader::NumExprFields + 1]
2414                                    : 0);
2415       break;
2416 
2417     case EXPR_CXX_DEPENDENT_SCOPE_DECL_REF:
2418       S = DependentScopeDeclRefExpr::CreateEmpty(Context,
2419          /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields],
2420                   /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]
2421                                    ? Record[ASTStmtReader::NumExprFields + 1]
2422                                    : 0);
2423       break;
2424 
2425     case EXPR_CXX_UNRESOLVED_CONSTRUCT:
2426       S = CXXUnresolvedConstructExpr::CreateEmpty(Context,
2427                               /*NumArgs=*/Record[ASTStmtReader::NumExprFields]);
2428       break;
2429 
2430     case EXPR_CXX_UNRESOLVED_MEMBER:
2431       S = UnresolvedMemberExpr::CreateEmpty(Context,
2432          /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields],
2433                   /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]
2434                                    ? Record[ASTStmtReader::NumExprFields + 1]
2435                                    : 0);
2436       break;
2437 
2438     case EXPR_CXX_UNRESOLVED_LOOKUP:
2439       S = UnresolvedLookupExpr::CreateEmpty(Context,
2440          /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields],
2441                   /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]
2442                                    ? Record[ASTStmtReader::NumExprFields + 1]
2443                                    : 0);
2444       break;
2445 
2446     case EXPR_TYPE_TRAIT:
2447       S = TypeTraitExpr::CreateDeserialized(Context,
2448             Record[ASTStmtReader::NumExprFields]);
2449       break;
2450 
2451     case EXPR_ARRAY_TYPE_TRAIT:
2452       S = new (Context) ArrayTypeTraitExpr(Empty);
2453       break;
2454 
2455     case EXPR_CXX_EXPRESSION_TRAIT:
2456       S = new (Context) ExpressionTraitExpr(Empty);
2457       break;
2458 
2459     case EXPR_CXX_NOEXCEPT:
2460       S = new (Context) CXXNoexceptExpr(Empty);
2461       break;
2462 
2463     case EXPR_PACK_EXPANSION:
2464       S = new (Context) PackExpansionExpr(Empty);
2465       break;
2466 
2467     case EXPR_SIZEOF_PACK:
2468       S = new (Context) SizeOfPackExpr(Empty);
2469       break;
2470 
2471     case EXPR_SUBST_NON_TYPE_TEMPLATE_PARM:
2472       S = new (Context) SubstNonTypeTemplateParmExpr(Empty);
2473       break;
2474 
2475     case EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK:
2476       S = new (Context) SubstNonTypeTemplateParmPackExpr(Empty);
2477       break;
2478 
2479     case EXPR_FUNCTION_PARM_PACK:
2480       S = FunctionParmPackExpr::CreateEmpty(Context,
2481                                           Record[ASTStmtReader::NumExprFields]);
2482       break;
2483 
2484     case EXPR_MATERIALIZE_TEMPORARY:
2485       S = new (Context) MaterializeTemporaryExpr(Empty);
2486       break;
2487 
2488     case EXPR_OPAQUE_VALUE:
2489       S = new (Context) OpaqueValueExpr(Empty);
2490       break;
2491 
2492     case EXPR_CUDA_KERNEL_CALL:
2493       S = new (Context) CUDAKernelCallExpr(Context, Empty);
2494       break;
2495 
2496     case EXPR_ASTYPE:
2497       S = new (Context) AsTypeExpr(Empty);
2498       break;
2499 
2500     case EXPR_PSEUDO_OBJECT: {
2501       unsigned numSemanticExprs = Record[ASTStmtReader::NumExprFields];
2502       S = PseudoObjectExpr::Create(Context, Empty, numSemanticExprs);
2503       break;
2504     }
2505 
2506     case EXPR_ATOMIC:
2507       S = new (Context) AtomicExpr(Empty);
2508       break;
2509 
2510     case EXPR_LAMBDA: {
2511       unsigned NumCaptures = Record[ASTStmtReader::NumExprFields];
2512       unsigned NumArrayIndexVars = Record[ASTStmtReader::NumExprFields + 1];
2513       S = LambdaExpr::CreateDeserialized(Context, NumCaptures,
2514                                          NumArrayIndexVars);
2515       break;
2516     }
2517     }
2518 
2519     // We hit a STMT_STOP, so we're done with this expression.
2520     if (Finished)
2521       break;
2522 
2523     ++NumStatementsRead;
2524 
2525     if (S && !IsStmtReference) {
2526       Reader.Visit(S);
2527       StmtEntries[Cursor.GetCurrentBitNo()] = S;
2528     }
2529 
2530 
2531     assert(Idx == Record.size() && "Invalid deserialization of statement");
2532     StmtStack.push_back(S);
2533   }
2534 Done:
2535   assert(StmtStack.size() > PrevNumStmts && "Read too many sub-stmts!");
2536   assert(StmtStack.size() == PrevNumStmts + 1 && "Extra expressions on stack!");
2537   return StmtStack.pop_back_val();
2538 }
2539