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