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/DeclCXX.h"
17 #include "clang/AST/DeclTemplate.h"
18 #include "clang/AST/StmtVisitor.h"
19 using namespace clang;
20 using namespace clang::serialization;
21 
22 namespace clang {
23 
24   class ASTStmtReader : public StmtVisitor<ASTStmtReader> {
25     typedef ASTReader::RecordData RecordData;
26 
27     ASTReader &Reader;
28     Module &F;
29     llvm::BitstreamCursor &DeclsCursor;
30     const ASTReader::RecordData &Record;
31     unsigned &Idx;
32 
33     SourceLocation ReadSourceLocation(const RecordData &R, unsigned &I) {
34       return Reader.ReadSourceLocation(F, R, I);
35     }
36 
37     SourceRange ReadSourceRange(const RecordData &R, unsigned &I) {
38       return Reader.ReadSourceRange(F, R, I);
39     }
40 
41     TypeSourceInfo *GetTypeSourceInfo(const RecordData &R, unsigned &I) {
42       return Reader.GetTypeSourceInfo(F, R, I);
43     }
44 
45     serialization::DeclID ReadDeclID(const RecordData &R, unsigned &I) {
46       return Reader.ReadDeclID(F, R, I);
47     }
48 
49     Decl *ReadDecl(const RecordData &R, unsigned &I) {
50       return Reader.ReadDecl(F, R, I);
51     }
52 
53     template<typename T>
54     T *ReadDeclAs(const RecordData &R, unsigned &I) {
55       return Reader.ReadDeclAs<T>(F, R, I);
56     }
57 
58     void ReadDeclarationNameLoc(DeclarationNameLoc &DNLoc, DeclarationName Name,
59                                 const ASTReader::RecordData &R, unsigned &I) {
60       Reader.ReadDeclarationNameLoc(F, DNLoc, Name, R, I);
61     }
62 
63     void ReadDeclarationNameInfo(DeclarationNameInfo &NameInfo,
64                                 const ASTReader::RecordData &R, unsigned &I) {
65       Reader.ReadDeclarationNameInfo(F, NameInfo, R, I);
66     }
67 
68   public:
69     ASTStmtReader(ASTReader &Reader, Module &F,
70                   llvm::BitstreamCursor &Cursor,
71                   const ASTReader::RecordData &Record, unsigned &Idx)
72       : Reader(Reader), F(F), DeclsCursor(Cursor), Record(Record), Idx(Idx) { }
73 
74     /// \brief The number of record fields required for the Stmt class
75     /// itself.
76     static const unsigned NumStmtFields = 0;
77 
78     /// \brief The number of record fields required for the Expr class
79     /// itself.
80     static const unsigned NumExprFields = NumStmtFields + 7;
81 
82     /// \brief Read and initialize a ExplicitTemplateArgumentList structure.
83     void ReadExplicitTemplateArgumentList(ExplicitTemplateArgumentList &ArgList,
84                                           unsigned NumTemplateArgs);
85 
86     void VisitStmt(Stmt *S);
87 #define STMT(Type, Base) \
88     void Visit##Type(Type *);
89 #include "clang/AST/StmtNodes.inc"
90   };
91 }
92 
93 void ASTStmtReader::
94 ReadExplicitTemplateArgumentList(ExplicitTemplateArgumentList &ArgList,
95                                  unsigned NumTemplateArgs) {
96   TemplateArgumentListInfo ArgInfo;
97   ArgInfo.setLAngleLoc(ReadSourceLocation(Record, Idx));
98   ArgInfo.setRAngleLoc(ReadSourceLocation(Record, Idx));
99   for (unsigned i = 0; i != NumTemplateArgs; ++i)
100     ArgInfo.addArgument(
101         Reader.ReadTemplateArgumentLoc(F, Record, Idx));
102   ArgList.initializeFrom(ArgInfo);
103 }
104 
105 void ASTStmtReader::VisitStmt(Stmt *S) {
106   assert(Idx == NumStmtFields && "Incorrect statement field count");
107 }
108 
109 void ASTStmtReader::VisitNullStmt(NullStmt *S) {
110   VisitStmt(S);
111   S->setSemiLoc(ReadSourceLocation(Record, Idx));
112   S->HasLeadingEmptyMacro = Record[Idx++];
113 }
114 
115 void ASTStmtReader::VisitCompoundStmt(CompoundStmt *S) {
116   VisitStmt(S);
117   SmallVector<Stmt *, 16> Stmts;
118   unsigned NumStmts = Record[Idx++];
119   while (NumStmts--)
120     Stmts.push_back(Reader.ReadSubStmt());
121   S->setStmts(Reader.getContext(), Stmts.data(), Stmts.size());
122   S->setLBracLoc(ReadSourceLocation(Record, Idx));
123   S->setRBracLoc(ReadSourceLocation(Record, Idx));
124 }
125 
126 void ASTStmtReader::VisitSwitchCase(SwitchCase *S) {
127   VisitStmt(S);
128   Reader.RecordSwitchCaseID(S, Record[Idx++]);
129 }
130 
131 void ASTStmtReader::VisitCaseStmt(CaseStmt *S) {
132   VisitSwitchCase(S);
133   S->setLHS(Reader.ReadSubExpr());
134   S->setRHS(Reader.ReadSubExpr());
135   S->setSubStmt(Reader.ReadSubStmt());
136   S->setCaseLoc(ReadSourceLocation(Record, Idx));
137   S->setEllipsisLoc(ReadSourceLocation(Record, Idx));
138   S->setColonLoc(ReadSourceLocation(Record, Idx));
139 }
140 
141 void ASTStmtReader::VisitDefaultStmt(DefaultStmt *S) {
142   VisitSwitchCase(S);
143   S->setSubStmt(Reader.ReadSubStmt());
144   S->setDefaultLoc(ReadSourceLocation(Record, Idx));
145   S->setColonLoc(ReadSourceLocation(Record, Idx));
146 }
147 
148 void ASTStmtReader::VisitLabelStmt(LabelStmt *S) {
149   VisitStmt(S);
150   LabelDecl *LD = ReadDeclAs<LabelDecl>(Record, Idx);
151   LD->setStmt(S);
152   S->setDecl(LD);
153   S->setSubStmt(Reader.ReadSubStmt());
154   S->setIdentLoc(ReadSourceLocation(Record, Idx));
155 }
156 
157 void ASTStmtReader::VisitIfStmt(IfStmt *S) {
158   VisitStmt(S);
159   S->setConditionVariable(Reader.getContext(),
160                           ReadDeclAs<VarDecl>(Record, Idx));
161   S->setCond(Reader.ReadSubExpr());
162   S->setThen(Reader.ReadSubStmt());
163   S->setElse(Reader.ReadSubStmt());
164   S->setIfLoc(ReadSourceLocation(Record, Idx));
165   S->setElseLoc(ReadSourceLocation(Record, Idx));
166 }
167 
168 void ASTStmtReader::VisitSwitchStmt(SwitchStmt *S) {
169   VisitStmt(S);
170   S->setConditionVariable(Reader.getContext(),
171                           ReadDeclAs<VarDecl>(Record, Idx));
172   S->setCond(Reader.ReadSubExpr());
173   S->setBody(Reader.ReadSubStmt());
174   S->setSwitchLoc(ReadSourceLocation(Record, Idx));
175   if (Record[Idx++])
176     S->setAllEnumCasesCovered();
177 
178   SwitchCase *PrevSC = 0;
179   for (unsigned N = Record.size(); Idx != N; ++Idx) {
180     SwitchCase *SC = Reader.getSwitchCaseWithID(Record[Idx]);
181     if (PrevSC)
182       PrevSC->setNextSwitchCase(SC);
183     else
184       S->setSwitchCaseList(SC);
185 
186     PrevSC = SC;
187   }
188 }
189 
190 void ASTStmtReader::VisitWhileStmt(WhileStmt *S) {
191   VisitStmt(S);
192   S->setConditionVariable(Reader.getContext(),
193                           ReadDeclAs<VarDecl>(Record, Idx));
194 
195   S->setCond(Reader.ReadSubExpr());
196   S->setBody(Reader.ReadSubStmt());
197   S->setWhileLoc(ReadSourceLocation(Record, Idx));
198 }
199 
200 void ASTStmtReader::VisitDoStmt(DoStmt *S) {
201   VisitStmt(S);
202   S->setCond(Reader.ReadSubExpr());
203   S->setBody(Reader.ReadSubStmt());
204   S->setDoLoc(ReadSourceLocation(Record, Idx));
205   S->setWhileLoc(ReadSourceLocation(Record, Idx));
206   S->setRParenLoc(ReadSourceLocation(Record, Idx));
207 }
208 
209 void ASTStmtReader::VisitForStmt(ForStmt *S) {
210   VisitStmt(S);
211   S->setInit(Reader.ReadSubStmt());
212   S->setCond(Reader.ReadSubExpr());
213   S->setConditionVariable(Reader.getContext(),
214                           ReadDeclAs<VarDecl>(Record, Idx));
215   S->setInc(Reader.ReadSubExpr());
216   S->setBody(Reader.ReadSubStmt());
217   S->setForLoc(ReadSourceLocation(Record, Idx));
218   S->setLParenLoc(ReadSourceLocation(Record, Idx));
219   S->setRParenLoc(ReadSourceLocation(Record, Idx));
220 }
221 
222 void ASTStmtReader::VisitGotoStmt(GotoStmt *S) {
223   VisitStmt(S);
224   S->setLabel(ReadDeclAs<LabelDecl>(Record, Idx));
225   S->setGotoLoc(ReadSourceLocation(Record, Idx));
226   S->setLabelLoc(ReadSourceLocation(Record, Idx));
227 }
228 
229 void ASTStmtReader::VisitIndirectGotoStmt(IndirectGotoStmt *S) {
230   VisitStmt(S);
231   S->setGotoLoc(ReadSourceLocation(Record, Idx));
232   S->setStarLoc(ReadSourceLocation(Record, Idx));
233   S->setTarget(Reader.ReadSubExpr());
234 }
235 
236 void ASTStmtReader::VisitContinueStmt(ContinueStmt *S) {
237   VisitStmt(S);
238   S->setContinueLoc(ReadSourceLocation(Record, Idx));
239 }
240 
241 void ASTStmtReader::VisitBreakStmt(BreakStmt *S) {
242   VisitStmt(S);
243   S->setBreakLoc(ReadSourceLocation(Record, Idx));
244 }
245 
246 void ASTStmtReader::VisitReturnStmt(ReturnStmt *S) {
247   VisitStmt(S);
248   S->setRetValue(Reader.ReadSubExpr());
249   S->setReturnLoc(ReadSourceLocation(Record, Idx));
250   S->setNRVOCandidate(ReadDeclAs<VarDecl>(Record, Idx));
251 }
252 
253 void ASTStmtReader::VisitDeclStmt(DeclStmt *S) {
254   VisitStmt(S);
255   S->setStartLoc(ReadSourceLocation(Record, Idx));
256   S->setEndLoc(ReadSourceLocation(Record, Idx));
257 
258   if (Idx + 1 == Record.size()) {
259     // Single declaration
260     S->setDeclGroup(DeclGroupRef(ReadDecl(Record, Idx)));
261   } else {
262     SmallVector<Decl *, 16> Decls;
263     Decls.reserve(Record.size() - Idx);
264     for (unsigned N = Record.size(); Idx != N; )
265       Decls.push_back(ReadDecl(Record, Idx));
266     S->setDeclGroup(DeclGroupRef(DeclGroup::Create(Reader.getContext(),
267                                                    Decls.data(),
268                                                    Decls.size())));
269   }
270 }
271 
272 void ASTStmtReader::VisitAsmStmt(AsmStmt *S) {
273   VisitStmt(S);
274   unsigned NumOutputs = Record[Idx++];
275   unsigned NumInputs = Record[Idx++];
276   unsigned NumClobbers = Record[Idx++];
277   S->setAsmLoc(ReadSourceLocation(Record, Idx));
278   S->setRParenLoc(ReadSourceLocation(Record, Idx));
279   S->setVolatile(Record[Idx++]);
280   S->setSimple(Record[Idx++]);
281   S->setMSAsm(Record[Idx++]);
282 
283   S->setAsmString(cast_or_null<StringLiteral>(Reader.ReadSubStmt()));
284 
285   // Outputs and inputs
286   SmallVector<IdentifierInfo *, 16> Names;
287   SmallVector<StringLiteral*, 16> Constraints;
288   SmallVector<Stmt*, 16> Exprs;
289   for (unsigned I = 0, N = NumOutputs + NumInputs; I != N; ++I) {
290     Names.push_back(Reader.GetIdentifierInfo(F, Record, Idx));
291     Constraints.push_back(cast_or_null<StringLiteral>(Reader.ReadSubStmt()));
292     Exprs.push_back(Reader.ReadSubStmt());
293   }
294 
295   // Constraints
296   SmallVector<StringLiteral*, 16> Clobbers;
297   for (unsigned I = 0; I != NumClobbers; ++I)
298     Clobbers.push_back(cast_or_null<StringLiteral>(Reader.ReadSubStmt()));
299 
300   S->setOutputsAndInputsAndClobbers(Reader.getContext(),
301                                     Names.data(), Constraints.data(),
302                                     Exprs.data(), NumOutputs, NumInputs,
303                                     Clobbers.data(), NumClobbers);
304 }
305 
306 void ASTStmtReader::VisitExpr(Expr *E) {
307   VisitStmt(E);
308   E->setType(Reader.readType(F, Record, Idx));
309   E->setTypeDependent(Record[Idx++]);
310   E->setValueDependent(Record[Idx++]);
311   E->setInstantiationDependent(Record[Idx++]);
312   E->ExprBits.ContainsUnexpandedParameterPack = Record[Idx++];
313   E->setValueKind(static_cast<ExprValueKind>(Record[Idx++]));
314   E->setObjectKind(static_cast<ExprObjectKind>(Record[Idx++]));
315   assert(Idx == NumExprFields && "Incorrect expression field count");
316 }
317 
318 void ASTStmtReader::VisitPredefinedExpr(PredefinedExpr *E) {
319   VisitExpr(E);
320   E->setLocation(ReadSourceLocation(Record, Idx));
321   E->setIdentType((PredefinedExpr::IdentType)Record[Idx++]);
322 }
323 
324 void ASTStmtReader::VisitDeclRefExpr(DeclRefExpr *E) {
325   VisitExpr(E);
326 
327   E->DeclRefExprBits.HasQualifier = Record[Idx++];
328   E->DeclRefExprBits.HasFoundDecl = Record[Idx++];
329   E->DeclRefExprBits.HasExplicitTemplateArgs = Record[Idx++];
330   unsigned NumTemplateArgs = 0;
331   if (E->hasExplicitTemplateArgs())
332     NumTemplateArgs = Record[Idx++];
333 
334   if (E->hasQualifier())
335     E->getInternalQualifierLoc()
336       = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
337 
338   if (E->hasFoundDecl())
339     E->getInternalFoundDecl() = ReadDeclAs<NamedDecl>(Record, Idx);
340 
341   if (E->hasExplicitTemplateArgs())
342     ReadExplicitTemplateArgumentList(E->getExplicitTemplateArgs(),
343                                      NumTemplateArgs);
344 
345   E->setDecl(ReadDeclAs<ValueDecl>(Record, Idx));
346   E->setLocation(ReadSourceLocation(Record, Idx));
347   ReadDeclarationNameLoc(E->DNLoc, E->getDecl()->getDeclName(), Record, Idx);
348 }
349 
350 void ASTStmtReader::VisitIntegerLiteral(IntegerLiteral *E) {
351   VisitExpr(E);
352   E->setLocation(ReadSourceLocation(Record, Idx));
353   E->setValue(Reader.getContext(), Reader.ReadAPInt(Record, Idx));
354 }
355 
356 void ASTStmtReader::VisitFloatingLiteral(FloatingLiteral *E) {
357   VisitExpr(E);
358   E->setValue(Reader.getContext(), Reader.ReadAPFloat(Record, Idx));
359   E->setExact(Record[Idx++]);
360   E->setLocation(ReadSourceLocation(Record, Idx));
361 }
362 
363 void ASTStmtReader::VisitImaginaryLiteral(ImaginaryLiteral *E) {
364   VisitExpr(E);
365   E->setSubExpr(Reader.ReadSubExpr());
366 }
367 
368 void ASTStmtReader::VisitStringLiteral(StringLiteral *E) {
369   VisitExpr(E);
370   unsigned Len = Record[Idx++];
371   assert(Record[Idx] == E->getNumConcatenated() &&
372          "Wrong number of concatenated tokens!");
373   ++Idx;
374   E->Kind = static_cast<StringLiteral::StringKind>(Record[Idx++]);
375   E->IsPascal = Record[Idx++];
376 
377   // Read string data
378   llvm::SmallString<16> Str(&Record[Idx], &Record[Idx] + Len);
379   E->setString(Reader.getContext(), Str.str());
380   Idx += Len;
381 
382   // Read source locations
383   for (unsigned I = 0, N = E->getNumConcatenated(); I != N; ++I)
384     E->setStrTokenLoc(I, ReadSourceLocation(Record, Idx));
385 }
386 
387 void ASTStmtReader::VisitCharacterLiteral(CharacterLiteral *E) {
388   VisitExpr(E);
389   E->setValue(Record[Idx++]);
390   E->setLocation(ReadSourceLocation(Record, Idx));
391   E->setKind(static_cast<CharacterLiteral::CharacterKind>(Record[Idx++]));
392 }
393 
394 void ASTStmtReader::VisitParenExpr(ParenExpr *E) {
395   VisitExpr(E);
396   E->setLParen(ReadSourceLocation(Record, Idx));
397   E->setRParen(ReadSourceLocation(Record, Idx));
398   E->setSubExpr(Reader.ReadSubExpr());
399 }
400 
401 void ASTStmtReader::VisitParenListExpr(ParenListExpr *E) {
402   VisitExpr(E);
403   unsigned NumExprs = Record[Idx++];
404   E->Exprs = new (Reader.getContext()) Stmt*[NumExprs];
405   for (unsigned i = 0; i != NumExprs; ++i)
406     E->Exprs[i] = Reader.ReadSubStmt();
407   E->NumExprs = NumExprs;
408   E->LParenLoc = ReadSourceLocation(Record, Idx);
409   E->RParenLoc = ReadSourceLocation(Record, Idx);
410 }
411 
412 void ASTStmtReader::VisitUnaryOperator(UnaryOperator *E) {
413   VisitExpr(E);
414   E->setSubExpr(Reader.ReadSubExpr());
415   E->setOpcode((UnaryOperator::Opcode)Record[Idx++]);
416   E->setOperatorLoc(ReadSourceLocation(Record, Idx));
417 }
418 
419 void ASTStmtReader::VisitOffsetOfExpr(OffsetOfExpr *E) {
420   typedef OffsetOfExpr::OffsetOfNode Node;
421   VisitExpr(E);
422   assert(E->getNumComponents() == Record[Idx]);
423   ++Idx;
424   assert(E->getNumExpressions() == Record[Idx]);
425   ++Idx;
426   E->setOperatorLoc(ReadSourceLocation(Record, Idx));
427   E->setRParenLoc(ReadSourceLocation(Record, Idx));
428   E->setTypeSourceInfo(GetTypeSourceInfo(Record, Idx));
429   for (unsigned I = 0, N = E->getNumComponents(); I != N; ++I) {
430     Node::Kind Kind = static_cast<Node::Kind>(Record[Idx++]);
431     SourceLocation Start = ReadSourceLocation(Record, Idx);
432     SourceLocation End = ReadSourceLocation(Record, Idx);
433     switch (Kind) {
434     case Node::Array:
435       E->setComponent(I, Node(Start, Record[Idx++], End));
436       break;
437 
438     case Node::Field:
439       E->setComponent(I, Node(Start, ReadDeclAs<FieldDecl>(Record, Idx), End));
440       break;
441 
442     case Node::Identifier:
443       E->setComponent(I,
444                       Node(Start,
445                            Reader.GetIdentifierInfo(F, Record, Idx),
446                            End));
447       break;
448 
449     case Node::Base: {
450       CXXBaseSpecifier *Base = new (Reader.getContext()) CXXBaseSpecifier();
451       *Base = Reader.ReadCXXBaseSpecifier(F, Record, Idx);
452       E->setComponent(I, Node(Base));
453       break;
454     }
455     }
456   }
457 
458   for (unsigned I = 0, N = E->getNumExpressions(); I != N; ++I)
459     E->setIndexExpr(I, Reader.ReadSubExpr());
460 }
461 
462 void ASTStmtReader::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E) {
463   VisitExpr(E);
464   E->setKind(static_cast<UnaryExprOrTypeTrait>(Record[Idx++]));
465   if (Record[Idx] == 0) {
466     E->setArgument(Reader.ReadSubExpr());
467     ++Idx;
468   } else {
469     E->setArgument(GetTypeSourceInfo(Record, Idx));
470   }
471   E->setOperatorLoc(ReadSourceLocation(Record, Idx));
472   E->setRParenLoc(ReadSourceLocation(Record, Idx));
473 }
474 
475 void ASTStmtReader::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
476   VisitExpr(E);
477   E->setLHS(Reader.ReadSubExpr());
478   E->setRHS(Reader.ReadSubExpr());
479   E->setRBracketLoc(ReadSourceLocation(Record, Idx));
480 }
481 
482 void ASTStmtReader::VisitCallExpr(CallExpr *E) {
483   VisitExpr(E);
484   E->setNumArgs(Reader.getContext(), Record[Idx++]);
485   E->setRParenLoc(ReadSourceLocation(Record, Idx));
486   E->setCallee(Reader.ReadSubExpr());
487   for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
488     E->setArg(I, Reader.ReadSubExpr());
489 }
490 
491 void ASTStmtReader::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
492   VisitCallExpr(E);
493 }
494 
495 void ASTStmtReader::VisitMemberExpr(MemberExpr *E) {
496   // Don't call VisitExpr, this is fully initialized at creation.
497   assert(E->getStmtClass() == Stmt::MemberExprClass &&
498          "It's a subclass, we must advance Idx!");
499 }
500 
501 void ASTStmtReader::VisitObjCIsaExpr(ObjCIsaExpr *E) {
502   VisitExpr(E);
503   E->setBase(Reader.ReadSubExpr());
504   E->setIsaMemberLoc(ReadSourceLocation(Record, Idx));
505   E->setArrow(Record[Idx++]);
506 }
507 
508 void ASTStmtReader::
509 VisitObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *E) {
510   VisitExpr(E);
511   E->Operand = Reader.ReadSubExpr();
512   E->setShouldCopy(Record[Idx++]);
513 }
514 
515 void ASTStmtReader::VisitObjCBridgedCastExpr(ObjCBridgedCastExpr *E) {
516   VisitExplicitCastExpr(E);
517   E->LParenLoc = ReadSourceLocation(Record, Idx);
518   E->BridgeKeywordLoc = ReadSourceLocation(Record, Idx);
519   E->Kind = Record[Idx++];
520 }
521 
522 void ASTStmtReader::VisitCastExpr(CastExpr *E) {
523   VisitExpr(E);
524   unsigned NumBaseSpecs = Record[Idx++];
525   assert(NumBaseSpecs == E->path_size());
526   E->setSubExpr(Reader.ReadSubExpr());
527   E->setCastKind((CastExpr::CastKind)Record[Idx++]);
528   CastExpr::path_iterator BaseI = E->path_begin();
529   while (NumBaseSpecs--) {
530     CXXBaseSpecifier *BaseSpec = new (Reader.getContext()) CXXBaseSpecifier;
531     *BaseSpec = Reader.ReadCXXBaseSpecifier(F, Record, Idx);
532     *BaseI++ = BaseSpec;
533   }
534 }
535 
536 void ASTStmtReader::VisitBinaryOperator(BinaryOperator *E) {
537   VisitExpr(E);
538   E->setLHS(Reader.ReadSubExpr());
539   E->setRHS(Reader.ReadSubExpr());
540   E->setOpcode((BinaryOperator::Opcode)Record[Idx++]);
541   E->setOperatorLoc(ReadSourceLocation(Record, Idx));
542 }
543 
544 void ASTStmtReader::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
545   VisitBinaryOperator(E);
546   E->setComputationLHSType(Reader.readType(F, Record, Idx));
547   E->setComputationResultType(Reader.readType(F, Record, Idx));
548 }
549 
550 void ASTStmtReader::VisitConditionalOperator(ConditionalOperator *E) {
551   VisitExpr(E);
552   E->SubExprs[ConditionalOperator::COND] = Reader.ReadSubExpr();
553   E->SubExprs[ConditionalOperator::LHS] = Reader.ReadSubExpr();
554   E->SubExprs[ConditionalOperator::RHS] = Reader.ReadSubExpr();
555   E->QuestionLoc = ReadSourceLocation(Record, Idx);
556   E->ColonLoc = ReadSourceLocation(Record, Idx);
557 }
558 
559 void
560 ASTStmtReader::VisitBinaryConditionalOperator(BinaryConditionalOperator *E) {
561   VisitExpr(E);
562   E->OpaqueValue = cast<OpaqueValueExpr>(Reader.ReadSubExpr());
563   E->SubExprs[BinaryConditionalOperator::COMMON] = Reader.ReadSubExpr();
564   E->SubExprs[BinaryConditionalOperator::COND] = Reader.ReadSubExpr();
565   E->SubExprs[BinaryConditionalOperator::LHS] = Reader.ReadSubExpr();
566   E->SubExprs[BinaryConditionalOperator::RHS] = Reader.ReadSubExpr();
567   E->QuestionLoc = ReadSourceLocation(Record, Idx);
568   E->ColonLoc = ReadSourceLocation(Record, Idx);
569 
570   E->getOpaqueValue()->setSourceExpr(E->getCommon());
571 }
572 
573 void ASTStmtReader::VisitImplicitCastExpr(ImplicitCastExpr *E) {
574   VisitCastExpr(E);
575 }
576 
577 void ASTStmtReader::VisitExplicitCastExpr(ExplicitCastExpr *E) {
578   VisitCastExpr(E);
579   E->setTypeInfoAsWritten(GetTypeSourceInfo(Record, Idx));
580 }
581 
582 void ASTStmtReader::VisitCStyleCastExpr(CStyleCastExpr *E) {
583   VisitExplicitCastExpr(E);
584   E->setLParenLoc(ReadSourceLocation(Record, Idx));
585   E->setRParenLoc(ReadSourceLocation(Record, Idx));
586 }
587 
588 void ASTStmtReader::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
589   VisitExpr(E);
590   E->setLParenLoc(ReadSourceLocation(Record, Idx));
591   E->setTypeSourceInfo(GetTypeSourceInfo(Record, Idx));
592   E->setInitializer(Reader.ReadSubExpr());
593   E->setFileScope(Record[Idx++]);
594 }
595 
596 void ASTStmtReader::VisitExtVectorElementExpr(ExtVectorElementExpr *E) {
597   VisitExpr(E);
598   E->setBase(Reader.ReadSubExpr());
599   E->setAccessor(Reader.GetIdentifierInfo(F, Record, Idx));
600   E->setAccessorLoc(ReadSourceLocation(Record, Idx));
601 }
602 
603 void ASTStmtReader::VisitInitListExpr(InitListExpr *E) {
604   VisitExpr(E);
605   E->setSyntacticForm(cast_or_null<InitListExpr>(Reader.ReadSubStmt()));
606   E->setLBraceLoc(ReadSourceLocation(Record, Idx));
607   E->setRBraceLoc(ReadSourceLocation(Record, Idx));
608   bool isArrayFiller = Record[Idx++];
609   Expr *filler = 0;
610   if (isArrayFiller) {
611     filler = Reader.ReadSubExpr();
612     E->ArrayFillerOrUnionFieldInit = filler;
613   } else
614     E->ArrayFillerOrUnionFieldInit = ReadDeclAs<FieldDecl>(Record, Idx);
615   E->sawArrayRangeDesignator(Record[Idx++]);
616   unsigned NumInits = Record[Idx++];
617   E->reserveInits(Reader.getContext(), NumInits);
618   if (isArrayFiller) {
619     for (unsigned I = 0; I != NumInits; ++I) {
620       Expr *init = Reader.ReadSubExpr();
621       E->updateInit(Reader.getContext(), I, init ? init : filler);
622     }
623   } else {
624     for (unsigned I = 0; I != NumInits; ++I)
625       E->updateInit(Reader.getContext(), I, Reader.ReadSubExpr());
626   }
627 }
628 
629 void ASTStmtReader::VisitDesignatedInitExpr(DesignatedInitExpr *E) {
630   typedef DesignatedInitExpr::Designator Designator;
631 
632   VisitExpr(E);
633   unsigned NumSubExprs = Record[Idx++];
634   assert(NumSubExprs == E->getNumSubExprs() && "Wrong number of subexprs");
635   for (unsigned I = 0; I != NumSubExprs; ++I)
636     E->setSubExpr(I, Reader.ReadSubExpr());
637   E->setEqualOrColonLoc(ReadSourceLocation(Record, Idx));
638   E->setGNUSyntax(Record[Idx++]);
639 
640   SmallVector<Designator, 4> Designators;
641   while (Idx < Record.size()) {
642     switch ((DesignatorTypes)Record[Idx++]) {
643     case DESIG_FIELD_DECL: {
644       FieldDecl *Field = ReadDeclAs<FieldDecl>(Record, Idx);
645       SourceLocation DotLoc
646         = ReadSourceLocation(Record, Idx);
647       SourceLocation FieldLoc
648         = ReadSourceLocation(Record, Idx);
649       Designators.push_back(Designator(Field->getIdentifier(), DotLoc,
650                                        FieldLoc));
651       Designators.back().setField(Field);
652       break;
653     }
654 
655     case DESIG_FIELD_NAME: {
656       const IdentifierInfo *Name = Reader.GetIdentifierInfo(F, Record, Idx);
657       SourceLocation DotLoc
658         = ReadSourceLocation(Record, Idx);
659       SourceLocation FieldLoc
660         = ReadSourceLocation(Record, Idx);
661       Designators.push_back(Designator(Name, DotLoc, FieldLoc));
662       break;
663     }
664 
665     case DESIG_ARRAY: {
666       unsigned Index = Record[Idx++];
667       SourceLocation LBracketLoc
668         = ReadSourceLocation(Record, Idx);
669       SourceLocation RBracketLoc
670         = ReadSourceLocation(Record, Idx);
671       Designators.push_back(Designator(Index, LBracketLoc, RBracketLoc));
672       break;
673     }
674 
675     case DESIG_ARRAY_RANGE: {
676       unsigned Index = Record[Idx++];
677       SourceLocation LBracketLoc
678         = ReadSourceLocation(Record, Idx);
679       SourceLocation EllipsisLoc
680         = ReadSourceLocation(Record, Idx);
681       SourceLocation RBracketLoc
682         = ReadSourceLocation(Record, Idx);
683       Designators.push_back(Designator(Index, LBracketLoc, EllipsisLoc,
684                                        RBracketLoc));
685       break;
686     }
687     }
688   }
689   E->setDesignators(Reader.getContext(),
690                     Designators.data(), Designators.size());
691 }
692 
693 void ASTStmtReader::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
694   VisitExpr(E);
695 }
696 
697 void ASTStmtReader::VisitVAArgExpr(VAArgExpr *E) {
698   VisitExpr(E);
699   E->setSubExpr(Reader.ReadSubExpr());
700   E->setWrittenTypeInfo(GetTypeSourceInfo(Record, Idx));
701   E->setBuiltinLoc(ReadSourceLocation(Record, Idx));
702   E->setRParenLoc(ReadSourceLocation(Record, Idx));
703 }
704 
705 void ASTStmtReader::VisitAddrLabelExpr(AddrLabelExpr *E) {
706   VisitExpr(E);
707   E->setAmpAmpLoc(ReadSourceLocation(Record, Idx));
708   E->setLabelLoc(ReadSourceLocation(Record, Idx));
709   E->setLabel(ReadDeclAs<LabelDecl>(Record, Idx));
710 }
711 
712 void ASTStmtReader::VisitStmtExpr(StmtExpr *E) {
713   VisitExpr(E);
714   E->setLParenLoc(ReadSourceLocation(Record, Idx));
715   E->setRParenLoc(ReadSourceLocation(Record, Idx));
716   E->setSubStmt(cast_or_null<CompoundStmt>(Reader.ReadSubStmt()));
717 }
718 
719 void ASTStmtReader::VisitChooseExpr(ChooseExpr *E) {
720   VisitExpr(E);
721   E->setCond(Reader.ReadSubExpr());
722   E->setLHS(Reader.ReadSubExpr());
723   E->setRHS(Reader.ReadSubExpr());
724   E->setBuiltinLoc(ReadSourceLocation(Record, Idx));
725   E->setRParenLoc(ReadSourceLocation(Record, Idx));
726 }
727 
728 void ASTStmtReader::VisitGNUNullExpr(GNUNullExpr *E) {
729   VisitExpr(E);
730   E->setTokenLocation(ReadSourceLocation(Record, Idx));
731 }
732 
733 void ASTStmtReader::VisitShuffleVectorExpr(ShuffleVectorExpr *E) {
734   VisitExpr(E);
735   SmallVector<Expr *, 16> Exprs;
736   unsigned NumExprs = Record[Idx++];
737   while (NumExprs--)
738     Exprs.push_back(Reader.ReadSubExpr());
739   E->setExprs(Reader.getContext(), Exprs.data(), Exprs.size());
740   E->setBuiltinLoc(ReadSourceLocation(Record, Idx));
741   E->setRParenLoc(ReadSourceLocation(Record, Idx));
742 }
743 
744 void ASTStmtReader::VisitBlockExpr(BlockExpr *E) {
745   VisitExpr(E);
746   E->setBlockDecl(ReadDeclAs<BlockDecl>(Record, Idx));
747 }
748 
749 void ASTStmtReader::VisitBlockDeclRefExpr(BlockDeclRefExpr *E) {
750   VisitExpr(E);
751   E->setDecl(ReadDeclAs<VarDecl>(Record, Idx));
752   E->setLocation(ReadSourceLocation(Record, Idx));
753   E->setByRef(Record[Idx++]);
754   E->setConstQualAdded(Record[Idx++]);
755 }
756 
757 void ASTStmtReader::VisitGenericSelectionExpr(GenericSelectionExpr *E) {
758   VisitExpr(E);
759   E->NumAssocs = Record[Idx++];
760   E->AssocTypes = new (Reader.getContext()) TypeSourceInfo*[E->NumAssocs];
761   E->SubExprs =
762    new(Reader.getContext()) Stmt*[GenericSelectionExpr::END_EXPR+E->NumAssocs];
763 
764   E->SubExprs[GenericSelectionExpr::CONTROLLING] = Reader.ReadSubExpr();
765   for (unsigned I = 0, N = E->getNumAssocs(); I != N; ++I) {
766     E->AssocTypes[I] = GetTypeSourceInfo(Record, Idx);
767     E->SubExprs[GenericSelectionExpr::END_EXPR+I] = Reader.ReadSubExpr();
768   }
769   E->ResultIndex = Record[Idx++];
770 
771   E->GenericLoc = ReadSourceLocation(Record, Idx);
772   E->DefaultLoc = ReadSourceLocation(Record, Idx);
773   E->RParenLoc = ReadSourceLocation(Record, Idx);
774 }
775 
776 //===----------------------------------------------------------------------===//
777 // Objective-C Expressions and Statements
778 
779 void ASTStmtReader::VisitObjCStringLiteral(ObjCStringLiteral *E) {
780   VisitExpr(E);
781   E->setString(cast<StringLiteral>(Reader.ReadSubStmt()));
782   E->setAtLoc(ReadSourceLocation(Record, Idx));
783 }
784 
785 void ASTStmtReader::VisitObjCEncodeExpr(ObjCEncodeExpr *E) {
786   VisitExpr(E);
787   E->setEncodedTypeSourceInfo(GetTypeSourceInfo(Record, Idx));
788   E->setAtLoc(ReadSourceLocation(Record, Idx));
789   E->setRParenLoc(ReadSourceLocation(Record, Idx));
790 }
791 
792 void ASTStmtReader::VisitObjCSelectorExpr(ObjCSelectorExpr *E) {
793   VisitExpr(E);
794   E->setSelector(Reader.ReadSelector(F, Record, Idx));
795   E->setAtLoc(ReadSourceLocation(Record, Idx));
796   E->setRParenLoc(ReadSourceLocation(Record, Idx));
797 }
798 
799 void ASTStmtReader::VisitObjCProtocolExpr(ObjCProtocolExpr *E) {
800   VisitExpr(E);
801   E->setProtocol(ReadDeclAs<ObjCProtocolDecl>(Record, Idx));
802   E->setAtLoc(ReadSourceLocation(Record, Idx));
803   E->setRParenLoc(ReadSourceLocation(Record, Idx));
804 }
805 
806 void ASTStmtReader::VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
807   VisitExpr(E);
808   E->setDecl(ReadDeclAs<ObjCIvarDecl>(Record, Idx));
809   E->setLocation(ReadSourceLocation(Record, Idx));
810   E->setBase(Reader.ReadSubExpr());
811   E->setIsArrow(Record[Idx++]);
812   E->setIsFreeIvar(Record[Idx++]);
813 }
814 
815 void ASTStmtReader::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
816   VisitExpr(E);
817   bool Implicit = Record[Idx++] != 0;
818   if (Implicit) {
819     ObjCMethodDecl *Getter = ReadDeclAs<ObjCMethodDecl>(Record, Idx);
820     ObjCMethodDecl *Setter = ReadDeclAs<ObjCMethodDecl>(Record, Idx);
821     E->setImplicitProperty(Getter, Setter);
822   } else {
823     E->setExplicitProperty(ReadDeclAs<ObjCPropertyDecl>(Record, Idx));
824   }
825   E->setLocation(ReadSourceLocation(Record, Idx));
826   E->setReceiverLocation(ReadSourceLocation(Record, Idx));
827   switch (Record[Idx++]) {
828   case 0:
829     E->setBase(Reader.ReadSubExpr());
830     break;
831   case 1:
832     E->setSuperReceiver(Reader.readType(F, Record, Idx));
833     break;
834   case 2:
835     E->setClassReceiver(ReadDeclAs<ObjCInterfaceDecl>(Record, Idx));
836     break;
837   }
838 }
839 
840 void ASTStmtReader::VisitObjCMessageExpr(ObjCMessageExpr *E) {
841   VisitExpr(E);
842   assert(Record[Idx] == E->getNumArgs());
843   ++Idx;
844   E->setDelegateInitCall(Record[Idx++]);
845   ObjCMessageExpr::ReceiverKind Kind
846     = static_cast<ObjCMessageExpr::ReceiverKind>(Record[Idx++]);
847   switch (Kind) {
848   case ObjCMessageExpr::Instance:
849     E->setInstanceReceiver(Reader.ReadSubExpr());
850     break;
851 
852   case ObjCMessageExpr::Class:
853     E->setClassReceiver(GetTypeSourceInfo(Record, Idx));
854     break;
855 
856   case ObjCMessageExpr::SuperClass:
857   case ObjCMessageExpr::SuperInstance: {
858     QualType T = Reader.readType(F, Record, Idx);
859     SourceLocation SuperLoc = ReadSourceLocation(Record, Idx);
860     E->setSuper(SuperLoc, T, Kind == ObjCMessageExpr::SuperInstance);
861     break;
862   }
863   }
864 
865   assert(Kind == E->getReceiverKind());
866 
867   if (Record[Idx++])
868     E->setMethodDecl(ReadDeclAs<ObjCMethodDecl>(Record, Idx));
869   else
870     E->setSelector(Reader.ReadSelector(F, Record, Idx));
871 
872   E->LBracLoc = ReadSourceLocation(Record, Idx);
873   E->RBracLoc = ReadSourceLocation(Record, Idx);
874   E->SelectorLoc = ReadSourceLocation(Record, Idx);
875 
876   for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
877     E->setArg(I, Reader.ReadSubExpr());
878 }
879 
880 void ASTStmtReader::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) {
881   VisitStmt(S);
882   S->setElement(Reader.ReadSubStmt());
883   S->setCollection(Reader.ReadSubExpr());
884   S->setBody(Reader.ReadSubStmt());
885   S->setForLoc(ReadSourceLocation(Record, Idx));
886   S->setRParenLoc(ReadSourceLocation(Record, Idx));
887 }
888 
889 void ASTStmtReader::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) {
890   VisitStmt(S);
891   S->setCatchBody(Reader.ReadSubStmt());
892   S->setCatchParamDecl(ReadDeclAs<VarDecl>(Record, Idx));
893   S->setAtCatchLoc(ReadSourceLocation(Record, Idx));
894   S->setRParenLoc(ReadSourceLocation(Record, Idx));
895 }
896 
897 void ASTStmtReader::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
898   VisitStmt(S);
899   S->setFinallyBody(Reader.ReadSubStmt());
900   S->setAtFinallyLoc(ReadSourceLocation(Record, Idx));
901 }
902 
903 void ASTStmtReader::VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S) {
904   VisitStmt(S);
905   S->setSubStmt(Reader.ReadSubStmt());
906   S->setAtLoc(ReadSourceLocation(Record, Idx));
907 }
908 
909 void ASTStmtReader::VisitObjCAtTryStmt(ObjCAtTryStmt *S) {
910   VisitStmt(S);
911   assert(Record[Idx] == S->getNumCatchStmts());
912   ++Idx;
913   bool HasFinally = Record[Idx++];
914   S->setTryBody(Reader.ReadSubStmt());
915   for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I)
916     S->setCatchStmt(I, cast_or_null<ObjCAtCatchStmt>(Reader.ReadSubStmt()));
917 
918   if (HasFinally)
919     S->setFinallyStmt(Reader.ReadSubStmt());
920   S->setAtTryLoc(ReadSourceLocation(Record, Idx));
921 }
922 
923 void ASTStmtReader::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S) {
924   VisitStmt(S);
925   S->setSynchExpr(Reader.ReadSubStmt());
926   S->setSynchBody(Reader.ReadSubStmt());
927   S->setAtSynchronizedLoc(ReadSourceLocation(Record, Idx));
928 }
929 
930 void ASTStmtReader::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) {
931   VisitStmt(S);
932   S->setThrowExpr(Reader.ReadSubStmt());
933   S->setThrowLoc(ReadSourceLocation(Record, Idx));
934 }
935 
936 //===----------------------------------------------------------------------===//
937 // C++ Expressions and Statements
938 //===----------------------------------------------------------------------===//
939 
940 void ASTStmtReader::VisitCXXCatchStmt(CXXCatchStmt *S) {
941   VisitStmt(S);
942   S->CatchLoc = ReadSourceLocation(Record, Idx);
943   S->ExceptionDecl = ReadDeclAs<VarDecl>(Record, Idx);
944   S->HandlerBlock = Reader.ReadSubStmt();
945 }
946 
947 void ASTStmtReader::VisitCXXTryStmt(CXXTryStmt *S) {
948   VisitStmt(S);
949   assert(Record[Idx] == S->getNumHandlers() && "NumStmtFields is wrong ?");
950   ++Idx;
951   S->TryLoc = ReadSourceLocation(Record, Idx);
952   S->getStmts()[0] = Reader.ReadSubStmt();
953   for (unsigned i = 0, e = S->getNumHandlers(); i != e; ++i)
954     S->getStmts()[i + 1] = Reader.ReadSubStmt();
955 }
956 
957 void ASTStmtReader::VisitCXXForRangeStmt(CXXForRangeStmt *S) {
958   VisitStmt(S);
959   S->setForLoc(ReadSourceLocation(Record, Idx));
960   S->setColonLoc(ReadSourceLocation(Record, Idx));
961   S->setRParenLoc(ReadSourceLocation(Record, Idx));
962   S->setRangeStmt(Reader.ReadSubStmt());
963   S->setBeginEndStmt(Reader.ReadSubStmt());
964   S->setCond(Reader.ReadSubExpr());
965   S->setInc(Reader.ReadSubExpr());
966   S->setLoopVarStmt(Reader.ReadSubStmt());
967   S->setBody(Reader.ReadSubStmt());
968 }
969 
970 void ASTStmtReader::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
971   VisitCallExpr(E);
972   E->setOperator((OverloadedOperatorKind)Record[Idx++]);
973 }
974 
975 void ASTStmtReader::VisitCXXConstructExpr(CXXConstructExpr *E) {
976   VisitExpr(E);
977   E->NumArgs = Record[Idx++];
978   if (E->NumArgs)
979     E->Args = new (Reader.getContext()) Stmt*[E->NumArgs];
980   for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
981     E->setArg(I, Reader.ReadSubExpr());
982   E->setConstructor(ReadDeclAs<CXXConstructorDecl>(Record, Idx));
983   E->setLocation(ReadSourceLocation(Record, Idx));
984   E->setElidable(Record[Idx++]);
985   E->setRequiresZeroInitialization(Record[Idx++]);
986   E->setConstructionKind((CXXConstructExpr::ConstructionKind)Record[Idx++]);
987   E->ParenRange = ReadSourceRange(Record, Idx);
988 }
989 
990 void ASTStmtReader::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E) {
991   VisitCXXConstructExpr(E);
992   E->Type = GetTypeSourceInfo(Record, Idx);
993 }
994 
995 void ASTStmtReader::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) {
996   VisitExplicitCastExpr(E);
997   SourceRange R = ReadSourceRange(Record, Idx);
998   E->Loc = R.getBegin();
999   E->RParenLoc = R.getEnd();
1000 }
1001 
1002 void ASTStmtReader::VisitCXXStaticCastExpr(CXXStaticCastExpr *E) {
1003   return VisitCXXNamedCastExpr(E);
1004 }
1005 
1006 void ASTStmtReader::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *E) {
1007   return VisitCXXNamedCastExpr(E);
1008 }
1009 
1010 void ASTStmtReader::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *E) {
1011   return VisitCXXNamedCastExpr(E);
1012 }
1013 
1014 void ASTStmtReader::VisitCXXConstCastExpr(CXXConstCastExpr *E) {
1015   return VisitCXXNamedCastExpr(E);
1016 }
1017 
1018 void ASTStmtReader::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E) {
1019   VisitExplicitCastExpr(E);
1020   E->setTypeBeginLoc(ReadSourceLocation(Record, Idx));
1021   E->setRParenLoc(ReadSourceLocation(Record, Idx));
1022 }
1023 
1024 void ASTStmtReader::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
1025   VisitExpr(E);
1026   E->setValue(Record[Idx++]);
1027   E->setLocation(ReadSourceLocation(Record, Idx));
1028 }
1029 
1030 void ASTStmtReader::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) {
1031   VisitExpr(E);
1032   E->setLocation(ReadSourceLocation(Record, Idx));
1033 }
1034 
1035 void ASTStmtReader::VisitCXXTypeidExpr(CXXTypeidExpr *E) {
1036   VisitExpr(E);
1037   E->setSourceRange(ReadSourceRange(Record, Idx));
1038   if (E->isTypeOperand()) { // typeid(int)
1039     E->setTypeOperandSourceInfo(
1040         GetTypeSourceInfo(Record, Idx));
1041     return;
1042   }
1043 
1044   // typeid(42+2)
1045   E->setExprOperand(Reader.ReadSubExpr());
1046 }
1047 
1048 void ASTStmtReader::VisitCXXThisExpr(CXXThisExpr *E) {
1049   VisitExpr(E);
1050   E->setLocation(ReadSourceLocation(Record, Idx));
1051   E->setImplicit(Record[Idx++]);
1052 }
1053 
1054 void ASTStmtReader::VisitCXXThrowExpr(CXXThrowExpr *E) {
1055   VisitExpr(E);
1056   E->ThrowLoc = ReadSourceLocation(Record, Idx);
1057   E->Op = Reader.ReadSubExpr();
1058   E->IsThrownVariableInScope = Record[Idx++];
1059 }
1060 
1061 void ASTStmtReader::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
1062   VisitExpr(E);
1063 
1064   assert(Record[Idx] == E->Param.getInt() && "We messed up at creation ?");
1065   ++Idx; // HasOtherExprStored and SubExpr was handled during creation.
1066   E->Param.setPointer(ReadDeclAs<ParmVarDecl>(Record, Idx));
1067   E->Loc = ReadSourceLocation(Record, Idx);
1068 }
1069 
1070 void ASTStmtReader::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
1071   VisitExpr(E);
1072   E->setTemporary(Reader.ReadCXXTemporary(F, Record, Idx));
1073   E->setSubExpr(Reader.ReadSubExpr());
1074 }
1075 
1076 void ASTStmtReader::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
1077   VisitExpr(E);
1078   E->TypeInfo = GetTypeSourceInfo(Record, Idx);
1079   E->RParenLoc = ReadSourceLocation(Record, Idx);
1080 }
1081 
1082 void ASTStmtReader::VisitCXXNewExpr(CXXNewExpr *E) {
1083   VisitExpr(E);
1084   E->GlobalNew = Record[Idx++];
1085   E->Initializer = Record[Idx++];
1086   E->UsualArrayDeleteWantsSize = Record[Idx++];
1087   bool isArray = Record[Idx++];
1088   unsigned NumPlacementArgs = Record[Idx++];
1089   unsigned NumCtorArgs = Record[Idx++];
1090   E->setOperatorNew(ReadDeclAs<FunctionDecl>(Record, Idx));
1091   E->setOperatorDelete(ReadDeclAs<FunctionDecl>(Record, Idx));
1092   E->setConstructor(ReadDeclAs<CXXConstructorDecl>(Record, Idx));
1093   E->AllocatedTypeInfo = GetTypeSourceInfo(Record, Idx);
1094   SourceRange TypeIdParens;
1095   TypeIdParens.setBegin(ReadSourceLocation(Record, Idx));
1096   TypeIdParens.setEnd(ReadSourceLocation(Record, Idx));
1097   E->TypeIdParens = TypeIdParens;
1098   E->StartLoc = ReadSourceLocation(Record, Idx);
1099   E->EndLoc = ReadSourceLocation(Record, Idx);
1100   E->ConstructorLParen = ReadSourceLocation(Record, Idx);
1101   E->ConstructorRParen = ReadSourceLocation(Record, Idx);
1102 
1103   E->AllocateArgsArray(Reader.getContext(), isArray, NumPlacementArgs,
1104                        NumCtorArgs);
1105 
1106   // Install all the subexpressions.
1107   for (CXXNewExpr::raw_arg_iterator I = E->raw_arg_begin(),e = E->raw_arg_end();
1108        I != e; ++I)
1109     *I = Reader.ReadSubStmt();
1110 }
1111 
1112 void ASTStmtReader::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
1113   VisitExpr(E);
1114   E->GlobalDelete = Record[Idx++];
1115   E->ArrayForm = Record[Idx++];
1116   E->ArrayFormAsWritten = Record[Idx++];
1117   E->UsualArrayDeleteWantsSize = Record[Idx++];
1118   E->OperatorDelete = ReadDeclAs<FunctionDecl>(Record, Idx);
1119   E->Argument = Reader.ReadSubExpr();
1120   E->Loc = ReadSourceLocation(Record, Idx);
1121 }
1122 
1123 void ASTStmtReader::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) {
1124   VisitExpr(E);
1125 
1126   E->Base = Reader.ReadSubExpr();
1127   E->IsArrow = Record[Idx++];
1128   E->OperatorLoc = ReadSourceLocation(Record, Idx);
1129   E->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1130   E->ScopeType = GetTypeSourceInfo(Record, Idx);
1131   E->ColonColonLoc = ReadSourceLocation(Record, Idx);
1132   E->TildeLoc = ReadSourceLocation(Record, Idx);
1133 
1134   IdentifierInfo *II = Reader.GetIdentifierInfo(F, Record, Idx);
1135   if (II)
1136     E->setDestroyedType(II, ReadSourceLocation(Record, Idx));
1137   else
1138     E->setDestroyedType(GetTypeSourceInfo(Record, Idx));
1139 }
1140 
1141 void ASTStmtReader::VisitExprWithCleanups(ExprWithCleanups *E) {
1142   VisitExpr(E);
1143   unsigned NumTemps = Record[Idx++];
1144   if (NumTemps) {
1145     E->setNumTemporaries(Reader.getContext(), NumTemps);
1146     for (unsigned i = 0; i != NumTemps; ++i)
1147       E->setTemporary(i, Reader.ReadCXXTemporary(F, Record, Idx));
1148   }
1149   E->setSubExpr(Reader.ReadSubExpr());
1150 }
1151 
1152 void
1153 ASTStmtReader::VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E){
1154   VisitExpr(E);
1155 
1156   if (Record[Idx++])
1157     ReadExplicitTemplateArgumentList(E->getExplicitTemplateArgs(),
1158                                      Record[Idx++]);
1159 
1160   E->Base = Reader.ReadSubExpr();
1161   E->BaseType = Reader.readType(F, Record, Idx);
1162   E->IsArrow = Record[Idx++];
1163   E->OperatorLoc = ReadSourceLocation(Record, Idx);
1164   E->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1165   E->FirstQualifierFoundInScope = ReadDeclAs<NamedDecl>(Record, Idx);
1166   ReadDeclarationNameInfo(E->MemberNameInfo, Record, Idx);
1167 }
1168 
1169 void
1170 ASTStmtReader::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) {
1171   VisitExpr(E);
1172 
1173   if (Record[Idx++])
1174     ReadExplicitTemplateArgumentList(E->getExplicitTemplateArgs(),
1175                                      Record[Idx++]);
1176 
1177   E->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1178   ReadDeclarationNameInfo(E->NameInfo, Record, Idx);
1179 }
1180 
1181 void
1182 ASTStmtReader::VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E) {
1183   VisitExpr(E);
1184   assert(Record[Idx] == E->arg_size() && "Read wrong record during creation ?");
1185   ++Idx; // NumArgs;
1186   for (unsigned I = 0, N = E->arg_size(); I != N; ++I)
1187     E->setArg(I, Reader.ReadSubExpr());
1188   E->Type = GetTypeSourceInfo(Record, Idx);
1189   E->setLParenLoc(ReadSourceLocation(Record, Idx));
1190   E->setRParenLoc(ReadSourceLocation(Record, Idx));
1191 }
1192 
1193 void ASTStmtReader::VisitOverloadExpr(OverloadExpr *E) {
1194   VisitExpr(E);
1195 
1196   // Read the explicit template argument list, if available.
1197   if (Record[Idx++])
1198     ReadExplicitTemplateArgumentList(E->getExplicitTemplateArgs(),
1199                                      Record[Idx++]);
1200 
1201   unsigned NumDecls = Record[Idx++];
1202   UnresolvedSet<8> Decls;
1203   for (unsigned i = 0; i != NumDecls; ++i) {
1204     NamedDecl *D = ReadDeclAs<NamedDecl>(Record, Idx);
1205     AccessSpecifier AS = (AccessSpecifier)Record[Idx++];
1206     Decls.addDecl(D, AS);
1207   }
1208   E->initializeResults(Reader.getContext(), Decls.begin(), Decls.end());
1209 
1210   ReadDeclarationNameInfo(E->NameInfo, Record, Idx);
1211   E->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1212 }
1213 
1214 void ASTStmtReader::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) {
1215   VisitOverloadExpr(E);
1216   E->IsArrow = Record[Idx++];
1217   E->HasUnresolvedUsing = Record[Idx++];
1218   E->Base = Reader.ReadSubExpr();
1219   E->BaseType = Reader.readType(F, Record, Idx);
1220   E->OperatorLoc = ReadSourceLocation(Record, Idx);
1221 }
1222 
1223 void ASTStmtReader::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) {
1224   VisitOverloadExpr(E);
1225   E->RequiresADL = Record[Idx++];
1226   if (E->RequiresADL)
1227     E->StdIsAssociatedNamespace = Record[Idx++];
1228   E->Overloaded = Record[Idx++];
1229   E->NamingClass = ReadDeclAs<CXXRecordDecl>(Record, Idx);
1230 }
1231 
1232 void ASTStmtReader::VisitUnaryTypeTraitExpr(UnaryTypeTraitExpr *E) {
1233   VisitExpr(E);
1234   E->UTT = (UnaryTypeTrait)Record[Idx++];
1235   E->Value = (bool)Record[Idx++];
1236   SourceRange Range = ReadSourceRange(Record, Idx);
1237   E->Loc = Range.getBegin();
1238   E->RParen = Range.getEnd();
1239   E->QueriedType = GetTypeSourceInfo(Record, Idx);
1240 }
1241 
1242 void ASTStmtReader::VisitBinaryTypeTraitExpr(BinaryTypeTraitExpr *E) {
1243   VisitExpr(E);
1244   E->BTT = (BinaryTypeTrait)Record[Idx++];
1245   E->Value = (bool)Record[Idx++];
1246   SourceRange Range = ReadSourceRange(Record, Idx);
1247   E->Loc = Range.getBegin();
1248   E->RParen = Range.getEnd();
1249   E->LhsType = GetTypeSourceInfo(Record, Idx);
1250   E->RhsType = GetTypeSourceInfo(Record, Idx);
1251 }
1252 
1253 void ASTStmtReader::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
1254   VisitExpr(E);
1255   E->ATT = (ArrayTypeTrait)Record[Idx++];
1256   E->Value = (unsigned int)Record[Idx++];
1257   SourceRange Range = ReadSourceRange(Record, Idx);
1258   E->Loc = Range.getBegin();
1259   E->RParen = Range.getEnd();
1260   E->QueriedType = GetTypeSourceInfo(Record, Idx);
1261 }
1262 
1263 void ASTStmtReader::VisitExpressionTraitExpr(ExpressionTraitExpr *E) {
1264   VisitExpr(E);
1265   E->ET = (ExpressionTrait)Record[Idx++];
1266   E->Value = (bool)Record[Idx++];
1267   SourceRange Range = ReadSourceRange(Record, Idx);
1268   E->QueriedExpression = Reader.ReadSubExpr();
1269   E->Loc = Range.getBegin();
1270   E->RParen = Range.getEnd();
1271 }
1272 
1273 void ASTStmtReader::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) {
1274   VisitExpr(E);
1275   E->Value = (bool)Record[Idx++];
1276   E->Range = ReadSourceRange(Record, Idx);
1277   E->Operand = Reader.ReadSubExpr();
1278 }
1279 
1280 void ASTStmtReader::VisitPackExpansionExpr(PackExpansionExpr *E) {
1281   VisitExpr(E);
1282   E->EllipsisLoc = ReadSourceLocation(Record, Idx);
1283   E->NumExpansions = Record[Idx++];
1284   E->Pattern = Reader.ReadSubExpr();
1285 }
1286 
1287 void ASTStmtReader::VisitSizeOfPackExpr(SizeOfPackExpr *E) {
1288   VisitExpr(E);
1289   E->OperatorLoc = ReadSourceLocation(Record, Idx);
1290   E->PackLoc = ReadSourceLocation(Record, Idx);
1291   E->RParenLoc = ReadSourceLocation(Record, Idx);
1292   E->Length = Record[Idx++];
1293   E->Pack = ReadDeclAs<NamedDecl>(Record, Idx);
1294 }
1295 
1296 void ASTStmtReader::VisitSubstNonTypeTemplateParmExpr(
1297                                               SubstNonTypeTemplateParmExpr *E) {
1298   VisitExpr(E);
1299   E->Param = ReadDeclAs<NonTypeTemplateParmDecl>(Record, Idx);
1300   E->NameLoc = ReadSourceLocation(Record, Idx);
1301   E->Replacement = Reader.ReadSubExpr();
1302 }
1303 
1304 void ASTStmtReader::VisitSubstNonTypeTemplateParmPackExpr(
1305                                           SubstNonTypeTemplateParmPackExpr *E) {
1306   VisitExpr(E);
1307   E->Param = ReadDeclAs<NonTypeTemplateParmDecl>(Record, Idx);
1308   TemplateArgument ArgPack = Reader.ReadTemplateArgument(F, Record, Idx);
1309   if (ArgPack.getKind() != TemplateArgument::Pack)
1310     return;
1311 
1312   E->Arguments = ArgPack.pack_begin();
1313   E->NumArguments = ArgPack.pack_size();
1314   E->NameLoc = ReadSourceLocation(Record, Idx);
1315 }
1316 
1317 void ASTStmtReader::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) {
1318   VisitExpr(E);
1319   E->Temporary = Reader.ReadSubExpr();
1320 }
1321 
1322 void ASTStmtReader::VisitOpaqueValueExpr(OpaqueValueExpr *E) {
1323   VisitExpr(E);
1324   Idx++; // skip ID
1325   E->Loc = ReadSourceLocation(Record, Idx);
1326 }
1327 
1328 //===----------------------------------------------------------------------===//
1329 // Microsoft Expressions and Statements
1330 //===----------------------------------------------------------------------===//
1331 void ASTStmtReader::VisitCXXUuidofExpr(CXXUuidofExpr *E) {
1332   VisitExpr(E);
1333   E->setSourceRange(ReadSourceRange(Record, Idx));
1334   if (E->isTypeOperand()) { // __uuidof(ComType)
1335     E->setTypeOperandSourceInfo(
1336         GetTypeSourceInfo(Record, Idx));
1337     return;
1338   }
1339 
1340   // __uuidof(expr)
1341   E->setExprOperand(Reader.ReadSubExpr());
1342 }
1343 
1344 void ASTStmtReader::VisitSEHExceptStmt(SEHExceptStmt *S) {
1345   VisitStmt(S);
1346   S->Loc = ReadSourceLocation(Record, Idx);
1347   S->Children[SEHExceptStmt::FILTER_EXPR] = Reader.ReadSubStmt();
1348   S->Children[SEHExceptStmt::BLOCK] = Reader.ReadSubStmt();
1349 }
1350 
1351 void ASTStmtReader::VisitSEHFinallyStmt(SEHFinallyStmt *S) {
1352   VisitStmt(S);
1353   S->Loc = ReadSourceLocation(Record, Idx);
1354   S->Block = Reader.ReadSubStmt();
1355 }
1356 
1357 void ASTStmtReader::VisitSEHTryStmt(SEHTryStmt *S) {
1358   VisitStmt(S);
1359   S->IsCXXTry = Record[Idx++];
1360   S->TryLoc = ReadSourceLocation(Record, Idx);
1361   S->Children[SEHTryStmt::TRY] = Reader.ReadSubStmt();
1362   S->Children[SEHTryStmt::HANDLER] = Reader.ReadSubStmt();
1363 }
1364 
1365 //===----------------------------------------------------------------------===//
1366 // CUDA Expressions and Statements
1367 //===----------------------------------------------------------------------===//
1368 
1369 void ASTStmtReader::VisitCUDAKernelCallExpr(CUDAKernelCallExpr *E) {
1370   VisitCallExpr(E);
1371   E->setConfig(cast<CallExpr>(Reader.ReadSubExpr()));
1372 }
1373 
1374 //===----------------------------------------------------------------------===//
1375 // OpenCL Expressions and Statements.
1376 //===----------------------------------------------------------------------===//
1377 void ASTStmtReader::VisitAsTypeExpr(AsTypeExpr *E) {
1378   VisitExpr(E);
1379   E->BuiltinLoc = ReadSourceLocation(Record, Idx);
1380   E->RParenLoc = ReadSourceLocation(Record, Idx);
1381   E->SrcExpr = Reader.ReadSubExpr();
1382 }
1383 
1384 //===----------------------------------------------------------------------===//
1385 // ASTReader Implementation
1386 //===----------------------------------------------------------------------===//
1387 
1388 Stmt *ASTReader::ReadStmt(Module &F) {
1389   switch (ReadingKind) {
1390   case Read_Decl:
1391   case Read_Type:
1392     return ReadStmtFromStream(F);
1393   case Read_Stmt:
1394     return ReadSubStmt();
1395   }
1396 
1397   llvm_unreachable("ReadingKind not set ?");
1398   return 0;
1399 }
1400 
1401 Expr *ASTReader::ReadExpr(Module &F) {
1402   return cast_or_null<Expr>(ReadStmt(F));
1403 }
1404 
1405 Expr *ASTReader::ReadSubExpr() {
1406   return cast_or_null<Expr>(ReadSubStmt());
1407 }
1408 
1409 // Within the bitstream, expressions are stored in Reverse Polish
1410 // Notation, with each of the subexpressions preceding the
1411 // expression they are stored in. Subexpressions are stored from last to first.
1412 // To evaluate expressions, we continue reading expressions and placing them on
1413 // the stack, with expressions having operands removing those operands from the
1414 // stack. Evaluation terminates when we see a STMT_STOP record, and
1415 // the single remaining expression on the stack is our result.
1416 Stmt *ASTReader::ReadStmtFromStream(Module &F) {
1417 
1418   ReadingKindTracker ReadingKind(Read_Stmt, *this);
1419   llvm::BitstreamCursor &Cursor = F.DeclsCursor;
1420 
1421 #ifndef NDEBUG
1422   unsigned PrevNumStmts = StmtStack.size();
1423 #endif
1424 
1425   RecordData Record;
1426   unsigned Idx;
1427   ASTStmtReader Reader(*this, F, Cursor, Record, Idx);
1428   Stmt::EmptyShell Empty;
1429 
1430   while (true) {
1431     unsigned Code = Cursor.ReadCode();
1432     if (Code == llvm::bitc::END_BLOCK) {
1433       if (Cursor.ReadBlockEnd()) {
1434         Error("error at end of block in AST file");
1435         return 0;
1436       }
1437       break;
1438     }
1439 
1440     if (Code == llvm::bitc::ENTER_SUBBLOCK) {
1441       // No known subblocks, always skip them.
1442       Cursor.ReadSubBlockID();
1443       if (Cursor.SkipBlock()) {
1444         Error("malformed block record in AST file");
1445         return 0;
1446       }
1447       continue;
1448     }
1449 
1450     if (Code == llvm::bitc::DEFINE_ABBREV) {
1451       Cursor.ReadAbbrevRecord();
1452       continue;
1453     }
1454 
1455     Stmt *S = 0;
1456     Idx = 0;
1457     Record.clear();
1458     bool Finished = false;
1459     switch ((StmtCode)Cursor.ReadRecord(Code, Record)) {
1460     case STMT_STOP:
1461       Finished = true;
1462       break;
1463 
1464     case STMT_NULL_PTR:
1465       S = 0;
1466       break;
1467 
1468     case STMT_NULL:
1469       S = new (Context) NullStmt(Empty);
1470       break;
1471 
1472     case STMT_COMPOUND:
1473       S = new (Context) CompoundStmt(Empty);
1474       break;
1475 
1476     case STMT_CASE:
1477       S = new (Context) CaseStmt(Empty);
1478       break;
1479 
1480     case STMT_DEFAULT:
1481       S = new (Context) DefaultStmt(Empty);
1482       break;
1483 
1484     case STMT_LABEL:
1485       S = new (Context) LabelStmt(Empty);
1486       break;
1487 
1488     case STMT_IF:
1489       S = new (Context) IfStmt(Empty);
1490       break;
1491 
1492     case STMT_SWITCH:
1493       S = new (Context) SwitchStmt(Empty);
1494       break;
1495 
1496     case STMT_WHILE:
1497       S = new (Context) WhileStmt(Empty);
1498       break;
1499 
1500     case STMT_DO:
1501       S = new (Context) DoStmt(Empty);
1502       break;
1503 
1504     case STMT_FOR:
1505       S = new (Context) ForStmt(Empty);
1506       break;
1507 
1508     case STMT_GOTO:
1509       S = new (Context) GotoStmt(Empty);
1510       break;
1511 
1512     case STMT_INDIRECT_GOTO:
1513       S = new (Context) IndirectGotoStmt(Empty);
1514       break;
1515 
1516     case STMT_CONTINUE:
1517       S = new (Context) ContinueStmt(Empty);
1518       break;
1519 
1520     case STMT_BREAK:
1521       S = new (Context) BreakStmt(Empty);
1522       break;
1523 
1524     case STMT_RETURN:
1525       S = new (Context) ReturnStmt(Empty);
1526       break;
1527 
1528     case STMT_DECL:
1529       S = new (Context) DeclStmt(Empty);
1530       break;
1531 
1532     case STMT_ASM:
1533       S = new (Context) AsmStmt(Empty);
1534       break;
1535 
1536     case EXPR_PREDEFINED:
1537       S = new (Context) PredefinedExpr(Empty);
1538       break;
1539 
1540     case EXPR_DECL_REF:
1541       S = DeclRefExpr::CreateEmpty(
1542         Context,
1543         /*HasQualifier=*/Record[ASTStmtReader::NumExprFields],
1544         /*HasFoundDecl=*/Record[ASTStmtReader::NumExprFields + 1],
1545         /*HasExplicitTemplateArgs=*/Record[ASTStmtReader::NumExprFields + 2],
1546         /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields + 2] ?
1547           Record[ASTStmtReader::NumExprFields + 3] : 0);
1548       break;
1549 
1550     case EXPR_INTEGER_LITERAL:
1551       S = IntegerLiteral::Create(Context, Empty);
1552       break;
1553 
1554     case EXPR_FLOATING_LITERAL:
1555       S = FloatingLiteral::Create(Context, Empty);
1556       break;
1557 
1558     case EXPR_IMAGINARY_LITERAL:
1559       S = new (Context) ImaginaryLiteral(Empty);
1560       break;
1561 
1562     case EXPR_STRING_LITERAL:
1563       S = StringLiteral::CreateEmpty(Context,
1564                                      Record[ASTStmtReader::NumExprFields + 1]);
1565       break;
1566 
1567     case EXPR_CHARACTER_LITERAL:
1568       S = new (Context) CharacterLiteral(Empty);
1569       break;
1570 
1571     case EXPR_PAREN:
1572       S = new (Context) ParenExpr(Empty);
1573       break;
1574 
1575     case EXPR_PAREN_LIST:
1576       S = new (Context) ParenListExpr(Empty);
1577       break;
1578 
1579     case EXPR_UNARY_OPERATOR:
1580       S = new (Context) UnaryOperator(Empty);
1581       break;
1582 
1583     case EXPR_OFFSETOF:
1584       S = OffsetOfExpr::CreateEmpty(Context,
1585                                     Record[ASTStmtReader::NumExprFields],
1586                                     Record[ASTStmtReader::NumExprFields + 1]);
1587       break;
1588 
1589     case EXPR_SIZEOF_ALIGN_OF:
1590       S = new (Context) UnaryExprOrTypeTraitExpr(Empty);
1591       break;
1592 
1593     case EXPR_ARRAY_SUBSCRIPT:
1594       S = new (Context) ArraySubscriptExpr(Empty);
1595       break;
1596 
1597     case EXPR_CALL:
1598       S = new (Context) CallExpr(Context, Stmt::CallExprClass, Empty);
1599       break;
1600 
1601     case EXPR_MEMBER: {
1602       // We load everything here and fully initialize it at creation.
1603       // That way we can use MemberExpr::Create and don't have to duplicate its
1604       // logic with a MemberExpr::CreateEmpty.
1605 
1606       assert(Idx == 0);
1607       NestedNameSpecifierLoc QualifierLoc;
1608       if (Record[Idx++]) { // HasQualifier.
1609         QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, Idx);
1610       }
1611 
1612       TemplateArgumentListInfo ArgInfo;
1613       bool HasExplicitTemplateArgs = Record[Idx++];
1614       if (HasExplicitTemplateArgs) {
1615         unsigned NumTemplateArgs = Record[Idx++];
1616         ArgInfo.setLAngleLoc(ReadSourceLocation(F, Record, Idx));
1617         ArgInfo.setRAngleLoc(ReadSourceLocation(F, Record, Idx));
1618         for (unsigned i = 0; i != NumTemplateArgs; ++i)
1619           ArgInfo.addArgument(ReadTemplateArgumentLoc(F, Record, Idx));
1620       }
1621 
1622       NamedDecl *FoundD = ReadDeclAs<NamedDecl>(F, Record, Idx);
1623       AccessSpecifier AS = (AccessSpecifier)Record[Idx++];
1624       DeclAccessPair FoundDecl = DeclAccessPair::make(FoundD, AS);
1625 
1626       QualType T = readType(F, Record, Idx);
1627       ExprValueKind VK = static_cast<ExprValueKind>(Record[Idx++]);
1628       ExprObjectKind OK = static_cast<ExprObjectKind>(Record[Idx++]);
1629       Expr *Base = ReadSubExpr();
1630       ValueDecl *MemberD = ReadDeclAs<ValueDecl>(F, Record, Idx);
1631       SourceLocation MemberLoc = ReadSourceLocation(F, Record, Idx);
1632       DeclarationNameInfo MemberNameInfo(MemberD->getDeclName(), MemberLoc);
1633       bool IsArrow = Record[Idx++];
1634 
1635       S = MemberExpr::Create(Context, Base, IsArrow, QualifierLoc,
1636                              MemberD, FoundDecl, MemberNameInfo,
1637                              HasExplicitTemplateArgs ? &ArgInfo : 0, T, VK, OK);
1638       ReadDeclarationNameLoc(F, cast<MemberExpr>(S)->MemberDNLoc,
1639                              MemberD->getDeclName(), Record, Idx);
1640       break;
1641     }
1642 
1643     case EXPR_BINARY_OPERATOR:
1644       S = new (Context) BinaryOperator(Empty);
1645       break;
1646 
1647     case EXPR_COMPOUND_ASSIGN_OPERATOR:
1648       S = new (Context) CompoundAssignOperator(Empty);
1649       break;
1650 
1651     case EXPR_CONDITIONAL_OPERATOR:
1652       S = new (Context) ConditionalOperator(Empty);
1653       break;
1654 
1655     case EXPR_BINARY_CONDITIONAL_OPERATOR:
1656       S = new (Context) BinaryConditionalOperator(Empty);
1657       break;
1658 
1659     case EXPR_IMPLICIT_CAST:
1660       S = ImplicitCastExpr::CreateEmpty(Context,
1661                        /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
1662       break;
1663 
1664     case EXPR_CSTYLE_CAST:
1665       S = CStyleCastExpr::CreateEmpty(Context,
1666                        /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
1667       break;
1668 
1669     case EXPR_COMPOUND_LITERAL:
1670       S = new (Context) CompoundLiteralExpr(Empty);
1671       break;
1672 
1673     case EXPR_EXT_VECTOR_ELEMENT:
1674       S = new (Context) ExtVectorElementExpr(Empty);
1675       break;
1676 
1677     case EXPR_INIT_LIST:
1678       S = new (Context) InitListExpr(getContext(), Empty);
1679       break;
1680 
1681     case EXPR_DESIGNATED_INIT:
1682       S = DesignatedInitExpr::CreateEmpty(Context,
1683                                      Record[ASTStmtReader::NumExprFields] - 1);
1684 
1685       break;
1686 
1687     case EXPR_IMPLICIT_VALUE_INIT:
1688       S = new (Context) ImplicitValueInitExpr(Empty);
1689       break;
1690 
1691     case EXPR_VA_ARG:
1692       S = new (Context) VAArgExpr(Empty);
1693       break;
1694 
1695     case EXPR_ADDR_LABEL:
1696       S = new (Context) AddrLabelExpr(Empty);
1697       break;
1698 
1699     case EXPR_STMT:
1700       S = new (Context) StmtExpr(Empty);
1701       break;
1702 
1703     case EXPR_CHOOSE:
1704       S = new (Context) ChooseExpr(Empty);
1705       break;
1706 
1707     case EXPR_GNU_NULL:
1708       S = new (Context) GNUNullExpr(Empty);
1709       break;
1710 
1711     case EXPR_SHUFFLE_VECTOR:
1712       S = new (Context) ShuffleVectorExpr(Empty);
1713       break;
1714 
1715     case EXPR_BLOCK:
1716       S = new (Context) BlockExpr(Empty);
1717       break;
1718 
1719     case EXPR_BLOCK_DECL_REF:
1720       S = new (Context) BlockDeclRefExpr(Empty);
1721       break;
1722 
1723     case EXPR_GENERIC_SELECTION:
1724       S = new (Context) GenericSelectionExpr(Empty);
1725       break;
1726 
1727     case EXPR_OBJC_STRING_LITERAL:
1728       S = new (Context) ObjCStringLiteral(Empty);
1729       break;
1730     case EXPR_OBJC_ENCODE:
1731       S = new (Context) ObjCEncodeExpr(Empty);
1732       break;
1733     case EXPR_OBJC_SELECTOR_EXPR:
1734       S = new (Context) ObjCSelectorExpr(Empty);
1735       break;
1736     case EXPR_OBJC_PROTOCOL_EXPR:
1737       S = new (Context) ObjCProtocolExpr(Empty);
1738       break;
1739     case EXPR_OBJC_IVAR_REF_EXPR:
1740       S = new (Context) ObjCIvarRefExpr(Empty);
1741       break;
1742     case EXPR_OBJC_PROPERTY_REF_EXPR:
1743       S = new (Context) ObjCPropertyRefExpr(Empty);
1744       break;
1745     case EXPR_OBJC_KVC_REF_EXPR:
1746       llvm_unreachable("mismatching AST file");
1747       break;
1748     case EXPR_OBJC_MESSAGE_EXPR:
1749       S = ObjCMessageExpr::CreateEmpty(Context,
1750                                      Record[ASTStmtReader::NumExprFields]);
1751       break;
1752     case EXPR_OBJC_ISA:
1753       S = new (Context) ObjCIsaExpr(Empty);
1754       break;
1755     case EXPR_OBJC_INDIRECT_COPY_RESTORE:
1756       S = new (Context) ObjCIndirectCopyRestoreExpr(Empty);
1757       break;
1758     case EXPR_OBJC_BRIDGED_CAST:
1759       S = new (Context) ObjCBridgedCastExpr(Empty);
1760       break;
1761     case STMT_OBJC_FOR_COLLECTION:
1762       S = new (Context) ObjCForCollectionStmt(Empty);
1763       break;
1764     case STMT_OBJC_CATCH:
1765       S = new (Context) ObjCAtCatchStmt(Empty);
1766       break;
1767     case STMT_OBJC_FINALLY:
1768       S = new (Context) ObjCAtFinallyStmt(Empty);
1769       break;
1770     case STMT_OBJC_AT_TRY:
1771       S = ObjCAtTryStmt::CreateEmpty(Context,
1772                                      Record[ASTStmtReader::NumStmtFields],
1773                                      Record[ASTStmtReader::NumStmtFields + 1]);
1774       break;
1775     case STMT_OBJC_AT_SYNCHRONIZED:
1776       S = new (Context) ObjCAtSynchronizedStmt(Empty);
1777       break;
1778     case STMT_OBJC_AT_THROW:
1779       S = new (Context) ObjCAtThrowStmt(Empty);
1780       break;
1781     case STMT_OBJC_AUTORELEASE_POOL:
1782       S = new (Context) ObjCAutoreleasePoolStmt(Empty);
1783       break;
1784     case STMT_SEH_EXCEPT:
1785       S = new (Context) SEHExceptStmt(Empty);
1786       break;
1787     case STMT_SEH_FINALLY:
1788       S = new (Context) SEHFinallyStmt(Empty);
1789       break;
1790     case STMT_SEH_TRY:
1791       S = new (Context) SEHTryStmt(Empty);
1792       break;
1793     case STMT_CXX_CATCH:
1794       S = new (Context) CXXCatchStmt(Empty);
1795       break;
1796 
1797     case STMT_CXX_TRY:
1798       S = CXXTryStmt::Create(Context, Empty,
1799              /*NumHandlers=*/Record[ASTStmtReader::NumStmtFields]);
1800       break;
1801 
1802     case STMT_CXX_FOR_RANGE:
1803       S = new (Context) CXXForRangeStmt(Empty);
1804       break;
1805 
1806     case EXPR_CXX_OPERATOR_CALL:
1807       S = new (Context) CXXOperatorCallExpr(Context, Empty);
1808       break;
1809 
1810     case EXPR_CXX_MEMBER_CALL:
1811       S = new (Context) CXXMemberCallExpr(Context, Empty);
1812       break;
1813 
1814     case EXPR_CXX_CONSTRUCT:
1815       S = new (Context) CXXConstructExpr(Empty);
1816       break;
1817 
1818     case EXPR_CXX_TEMPORARY_OBJECT:
1819       S = new (Context) CXXTemporaryObjectExpr(Empty);
1820       break;
1821 
1822     case EXPR_CXX_STATIC_CAST:
1823       S = CXXStaticCastExpr::CreateEmpty(Context,
1824                        /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
1825       break;
1826 
1827     case EXPR_CXX_DYNAMIC_CAST:
1828       S = CXXDynamicCastExpr::CreateEmpty(Context,
1829                        /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
1830       break;
1831 
1832     case EXPR_CXX_REINTERPRET_CAST:
1833       S = CXXReinterpretCastExpr::CreateEmpty(Context,
1834                        /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
1835       break;
1836 
1837     case EXPR_CXX_CONST_CAST:
1838       S = CXXConstCastExpr::CreateEmpty(Context);
1839       break;
1840 
1841     case EXPR_CXX_FUNCTIONAL_CAST:
1842       S = CXXFunctionalCastExpr::CreateEmpty(Context,
1843                        /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
1844       break;
1845 
1846     case EXPR_CXX_BOOL_LITERAL:
1847       S = new (Context) CXXBoolLiteralExpr(Empty);
1848       break;
1849 
1850     case EXPR_CXX_NULL_PTR_LITERAL:
1851       S = new (Context) CXXNullPtrLiteralExpr(Empty);
1852       break;
1853     case EXPR_CXX_TYPEID_EXPR:
1854       S = new (Context) CXXTypeidExpr(Empty, true);
1855       break;
1856     case EXPR_CXX_TYPEID_TYPE:
1857       S = new (Context) CXXTypeidExpr(Empty, false);
1858       break;
1859     case EXPR_CXX_UUIDOF_EXPR:
1860       S = new (Context) CXXUuidofExpr(Empty, true);
1861       break;
1862     case EXPR_CXX_UUIDOF_TYPE:
1863       S = new (Context) CXXUuidofExpr(Empty, false);
1864       break;
1865     case EXPR_CXX_THIS:
1866       S = new (Context) CXXThisExpr(Empty);
1867       break;
1868     case EXPR_CXX_THROW:
1869       S = new (Context) CXXThrowExpr(Empty);
1870       break;
1871     case EXPR_CXX_DEFAULT_ARG: {
1872       bool HasOtherExprStored = Record[ASTStmtReader::NumExprFields];
1873       if (HasOtherExprStored) {
1874         Expr *SubExpr = ReadSubExpr();
1875         S = CXXDefaultArgExpr::Create(Context, SourceLocation(), 0, SubExpr);
1876       } else
1877         S = new (Context) CXXDefaultArgExpr(Empty);
1878       break;
1879     }
1880     case EXPR_CXX_BIND_TEMPORARY:
1881       S = new (Context) CXXBindTemporaryExpr(Empty);
1882       break;
1883 
1884     case EXPR_CXX_SCALAR_VALUE_INIT:
1885       S = new (Context) CXXScalarValueInitExpr(Empty);
1886       break;
1887     case EXPR_CXX_NEW:
1888       S = new (Context) CXXNewExpr(Empty);
1889       break;
1890     case EXPR_CXX_DELETE:
1891       S = new (Context) CXXDeleteExpr(Empty);
1892       break;
1893     case EXPR_CXX_PSEUDO_DESTRUCTOR:
1894       S = new (Context) CXXPseudoDestructorExpr(Empty);
1895       break;
1896 
1897     case EXPR_EXPR_WITH_CLEANUPS:
1898       S = new (Context) ExprWithCleanups(Empty);
1899       break;
1900 
1901     case EXPR_CXX_DEPENDENT_SCOPE_MEMBER:
1902       S = CXXDependentScopeMemberExpr::CreateEmpty(Context,
1903           /*HasExplicitTemplateArgs=*/Record[ASTStmtReader::NumExprFields],
1904                   /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]
1905                                    ? Record[ASTStmtReader::NumExprFields + 1]
1906                                    : 0);
1907       break;
1908 
1909     case EXPR_CXX_DEPENDENT_SCOPE_DECL_REF:
1910       S = DependentScopeDeclRefExpr::CreateEmpty(Context,
1911           /*HasExplicitTemplateArgs=*/Record[ASTStmtReader::NumExprFields],
1912                   /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]
1913                                    ? Record[ASTStmtReader::NumExprFields + 1]
1914                                    : 0);
1915       break;
1916 
1917     case EXPR_CXX_UNRESOLVED_CONSTRUCT:
1918       S = CXXUnresolvedConstructExpr::CreateEmpty(Context,
1919                               /*NumArgs=*/Record[ASTStmtReader::NumExprFields]);
1920       break;
1921 
1922     case EXPR_CXX_UNRESOLVED_MEMBER:
1923       S = UnresolvedMemberExpr::CreateEmpty(Context,
1924           /*HasExplicitTemplateArgs=*/Record[ASTStmtReader::NumExprFields],
1925                   /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]
1926                                    ? Record[ASTStmtReader::NumExprFields + 1]
1927                                    : 0);
1928       break;
1929 
1930     case EXPR_CXX_UNRESOLVED_LOOKUP:
1931       S = UnresolvedLookupExpr::CreateEmpty(Context,
1932           /*HasExplicitTemplateArgs=*/Record[ASTStmtReader::NumExprFields],
1933                   /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]
1934                                    ? Record[ASTStmtReader::NumExprFields + 1]
1935                                    : 0);
1936       break;
1937 
1938     case EXPR_CXX_UNARY_TYPE_TRAIT:
1939       S = new (Context) UnaryTypeTraitExpr(Empty);
1940       break;
1941 
1942     case EXPR_BINARY_TYPE_TRAIT:
1943       S = new (Context) BinaryTypeTraitExpr(Empty);
1944       break;
1945 
1946     case EXPR_ARRAY_TYPE_TRAIT:
1947       S = new (Context) ArrayTypeTraitExpr(Empty);
1948       break;
1949 
1950     case EXPR_CXX_EXPRESSION_TRAIT:
1951       S = new (Context) ExpressionTraitExpr(Empty);
1952       break;
1953 
1954     case EXPR_CXX_NOEXCEPT:
1955       S = new (Context) CXXNoexceptExpr(Empty);
1956       break;
1957 
1958     case EXPR_PACK_EXPANSION:
1959       S = new (Context) PackExpansionExpr(Empty);
1960       break;
1961 
1962     case EXPR_SIZEOF_PACK:
1963       S = new (Context) SizeOfPackExpr(Empty);
1964       break;
1965 
1966     case EXPR_SUBST_NON_TYPE_TEMPLATE_PARM:
1967       S = new (Context) SubstNonTypeTemplateParmExpr(Empty);
1968       break;
1969 
1970     case EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK:
1971       S = new (Context) SubstNonTypeTemplateParmPackExpr(Empty);
1972       break;
1973 
1974     case EXPR_MATERIALIZE_TEMPORARY:
1975       S = new (Context) MaterializeTemporaryExpr(Empty);
1976       break;
1977 
1978     case EXPR_OPAQUE_VALUE: {
1979       unsigned key = Record[ASTStmtReader::NumExprFields];
1980       OpaqueValueExpr *&expr = OpaqueValueExprs[key];
1981 
1982       // If we already have an entry for this opaque value expression,
1983       // don't bother reading it again.
1984       if (expr) {
1985         StmtStack.push_back(expr);
1986         continue;
1987       }
1988 
1989       S = expr = new (Context) OpaqueValueExpr(Empty);
1990       break;
1991     }
1992 
1993     case EXPR_CUDA_KERNEL_CALL:
1994       S = new (Context) CUDAKernelCallExpr(Context, Empty);
1995       break;
1996 
1997     case EXPR_ASTYPE:
1998       S = new (Context) AsTypeExpr(Empty);
1999       break;
2000     }
2001 
2002     // We hit a STMT_STOP, so we're done with this expression.
2003     if (Finished)
2004       break;
2005 
2006     ++NumStatementsRead;
2007 
2008     if (S)
2009       Reader.Visit(S);
2010 
2011     assert(Idx == Record.size() && "Invalid deserialization of statement");
2012     StmtStack.push_back(S);
2013   }
2014 
2015 #ifndef NDEBUG
2016   assert(StmtStack.size() > PrevNumStmts && "Read too many sub stmts!");
2017   assert(StmtStack.size() == PrevNumStmts + 1 && "Extra expressions on stack!");
2018 #endif
2019 
2020   return StmtStack.pop_back_val();
2021 }
2022