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