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