1 //===--- ASTWriterStmt.cpp - Statement and Expression Serialization -------===//
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 //  This file implements serialization for Statements and Expressions.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "clang/Serialization/ASTWriter.h"
15 #include "clang/AST/DeclCXX.h"
16 #include "clang/AST/DeclObjC.h"
17 #include "clang/AST/DeclTemplate.h"
18 #include "clang/AST/StmtVisitor.h"
19 #include "llvm/Bitcode/BitstreamWriter.h"
20 using namespace clang;
21 
22 //===----------------------------------------------------------------------===//
23 // Statement/expression serialization
24 //===----------------------------------------------------------------------===//
25 
26 namespace clang {
27   class ASTStmtWriter : public StmtVisitor<ASTStmtWriter, void> {
28     ASTWriter &Writer;
29     ASTWriter::RecordData &Record;
30 
31   public:
32     serialization::StmtCode Code;
33 
34     ASTStmtWriter(ASTWriter &Writer, ASTWriter::RecordData &Record)
35       : Writer(Writer), Record(Record) { }
36 
37     void
38     AddExplicitTemplateArgumentList(const ExplicitTemplateArgumentList &Args);
39 
40     void VisitStmt(Stmt *S);
41     void VisitNullStmt(NullStmt *S);
42     void VisitCompoundStmt(CompoundStmt *S);
43     void VisitSwitchCase(SwitchCase *S);
44     void VisitCaseStmt(CaseStmt *S);
45     void VisitDefaultStmt(DefaultStmt *S);
46     void VisitLabelStmt(LabelStmt *S);
47     void VisitIfStmt(IfStmt *S);
48     void VisitSwitchStmt(SwitchStmt *S);
49     void VisitWhileStmt(WhileStmt *S);
50     void VisitDoStmt(DoStmt *S);
51     void VisitForStmt(ForStmt *S);
52     void VisitGotoStmt(GotoStmt *S);
53     void VisitIndirectGotoStmt(IndirectGotoStmt *S);
54     void VisitContinueStmt(ContinueStmt *S);
55     void VisitBreakStmt(BreakStmt *S);
56     void VisitReturnStmt(ReturnStmt *S);
57     void VisitDeclStmt(DeclStmt *S);
58     void VisitAsmStmt(AsmStmt *S);
59     void VisitExpr(Expr *E);
60     void VisitPredefinedExpr(PredefinedExpr *E);
61     void VisitDeclRefExpr(DeclRefExpr *E);
62     void VisitIntegerLiteral(IntegerLiteral *E);
63     void VisitFloatingLiteral(FloatingLiteral *E);
64     void VisitImaginaryLiteral(ImaginaryLiteral *E);
65     void VisitStringLiteral(StringLiteral *E);
66     void VisitCharacterLiteral(CharacterLiteral *E);
67     void VisitParenExpr(ParenExpr *E);
68     void VisitParenListExpr(ParenListExpr *E);
69     void VisitUnaryOperator(UnaryOperator *E);
70     void VisitOffsetOfExpr(OffsetOfExpr *E);
71     void VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E);
72     void VisitArraySubscriptExpr(ArraySubscriptExpr *E);
73     void VisitCallExpr(CallExpr *E);
74     void VisitMemberExpr(MemberExpr *E);
75     void VisitCastExpr(CastExpr *E);
76     void VisitBinaryOperator(BinaryOperator *E);
77     void VisitCompoundAssignOperator(CompoundAssignOperator *E);
78     void VisitConditionalOperator(ConditionalOperator *E);
79     void VisitBinaryConditionalOperator(BinaryConditionalOperator *E);
80     void VisitImplicitCastExpr(ImplicitCastExpr *E);
81     void VisitExplicitCastExpr(ExplicitCastExpr *E);
82     void VisitCStyleCastExpr(CStyleCastExpr *E);
83     void VisitCompoundLiteralExpr(CompoundLiteralExpr *E);
84     void VisitExtVectorElementExpr(ExtVectorElementExpr *E);
85     void VisitInitListExpr(InitListExpr *E);
86     void VisitDesignatedInitExpr(DesignatedInitExpr *E);
87     void VisitImplicitValueInitExpr(ImplicitValueInitExpr *E);
88     void VisitVAArgExpr(VAArgExpr *E);
89     void VisitAddrLabelExpr(AddrLabelExpr *E);
90     void VisitStmtExpr(StmtExpr *E);
91     void VisitChooseExpr(ChooseExpr *E);
92     void VisitGNUNullExpr(GNUNullExpr *E);
93     void VisitShuffleVectorExpr(ShuffleVectorExpr *E);
94     void VisitBlockExpr(BlockExpr *E);
95     void VisitBlockDeclRefExpr(BlockDeclRefExpr *E);
96     void VisitGenericSelectionExpr(GenericSelectionExpr *E);
97 
98     // Objective-C Expressions
99     void VisitObjCStringLiteral(ObjCStringLiteral *E);
100     void VisitObjCEncodeExpr(ObjCEncodeExpr *E);
101     void VisitObjCSelectorExpr(ObjCSelectorExpr *E);
102     void VisitObjCProtocolExpr(ObjCProtocolExpr *E);
103     void VisitObjCIvarRefExpr(ObjCIvarRefExpr *E);
104     void VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E);
105     void VisitObjCMessageExpr(ObjCMessageExpr *E);
106     void VisitObjCIsaExpr(ObjCIsaExpr *E);
107 
108     // Objective-C Statements
109     void VisitObjCForCollectionStmt(ObjCForCollectionStmt *);
110     void VisitObjCAtCatchStmt(ObjCAtCatchStmt *);
111     void VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *);
112     void VisitObjCAtTryStmt(ObjCAtTryStmt *);
113     void VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *);
114     void VisitObjCAtThrowStmt(ObjCAtThrowStmt *);
115 
116     // C++ Statements
117     void VisitCXXCatchStmt(CXXCatchStmt *S);
118     void VisitCXXTryStmt(CXXTryStmt *S);
119     void VisitCXXForRangeStmt(CXXForRangeStmt *);
120 
121     void VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E);
122     void VisitCXXMemberCallExpr(CXXMemberCallExpr *E);
123     void VisitCXXConstructExpr(CXXConstructExpr *E);
124     void VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E);
125     void VisitCXXNamedCastExpr(CXXNamedCastExpr *E);
126     void VisitCXXStaticCastExpr(CXXStaticCastExpr *E);
127     void VisitCXXDynamicCastExpr(CXXDynamicCastExpr *E);
128     void VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *E);
129     void VisitCXXConstCastExpr(CXXConstCastExpr *E);
130     void VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E);
131     void VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E);
132     void VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E);
133     void VisitCXXTypeidExpr(CXXTypeidExpr *E);
134     void VisitCXXUuidofExpr(CXXUuidofExpr *E);
135     void VisitCXXThisExpr(CXXThisExpr *E);
136     void VisitCXXThrowExpr(CXXThrowExpr *E);
137     void VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E);
138     void VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E);
139 
140     void VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E);
141     void VisitCXXNewExpr(CXXNewExpr *E);
142     void VisitCXXDeleteExpr(CXXDeleteExpr *E);
143     void VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E);
144 
145     void VisitExprWithCleanups(ExprWithCleanups *E);
146     void VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E);
147     void VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E);
148     void VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E);
149 
150     void VisitOverloadExpr(OverloadExpr *E);
151     void VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E);
152     void VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E);
153 
154     void VisitUnaryTypeTraitExpr(UnaryTypeTraitExpr *E);
155     void VisitBinaryTypeTraitExpr(BinaryTypeTraitExpr *E);
156     void VisitCXXNoexceptExpr(CXXNoexceptExpr *E);
157     void VisitPackExpansionExpr(PackExpansionExpr *E);
158     void VisitSizeOfPackExpr(SizeOfPackExpr *E);
159     void VisitSubstNonTypeTemplateParmPackExpr(
160                                            SubstNonTypeTemplateParmPackExpr *E);
161     void VisitOpaqueValueExpr(OpaqueValueExpr *E);
162 
163     // CUDA Expressions
164     void VisitCUDAKernelCallExpr(CUDAKernelCallExpr *E);
165   };
166 }
167 
168 void ASTStmtWriter::
169 AddExplicitTemplateArgumentList(const ExplicitTemplateArgumentList &Args) {
170   Writer.AddSourceLocation(Args.LAngleLoc, Record);
171   Writer.AddSourceLocation(Args.RAngleLoc, Record);
172   for (unsigned i=0; i != Args.NumTemplateArgs; ++i)
173     Writer.AddTemplateArgumentLoc(Args.getTemplateArgs()[i], Record);
174 }
175 
176 void ASTStmtWriter::VisitStmt(Stmt *S) {
177 }
178 
179 void ASTStmtWriter::VisitNullStmt(NullStmt *S) {
180   VisitStmt(S);
181   Writer.AddSourceLocation(S->getSemiLoc(), Record);
182   Record.push_back(S->LeadingEmptyMacro);
183   Code = serialization::STMT_NULL;
184 }
185 
186 void ASTStmtWriter::VisitCompoundStmt(CompoundStmt *S) {
187   VisitStmt(S);
188   Record.push_back(S->size());
189   for (CompoundStmt::body_iterator CS = S->body_begin(), CSEnd = S->body_end();
190        CS != CSEnd; ++CS)
191     Writer.AddStmt(*CS);
192   Writer.AddSourceLocation(S->getLBracLoc(), Record);
193   Writer.AddSourceLocation(S->getRBracLoc(), Record);
194   Code = serialization::STMT_COMPOUND;
195 }
196 
197 void ASTStmtWriter::VisitSwitchCase(SwitchCase *S) {
198   VisitStmt(S);
199   Record.push_back(Writer.getSwitchCaseID(S));
200 }
201 
202 void ASTStmtWriter::VisitCaseStmt(CaseStmt *S) {
203   VisitSwitchCase(S);
204   Writer.AddStmt(S->getLHS());
205   Writer.AddStmt(S->getRHS());
206   Writer.AddStmt(S->getSubStmt());
207   Writer.AddSourceLocation(S->getCaseLoc(), Record);
208   Writer.AddSourceLocation(S->getEllipsisLoc(), Record);
209   Writer.AddSourceLocation(S->getColonLoc(), Record);
210   Code = serialization::STMT_CASE;
211 }
212 
213 void ASTStmtWriter::VisitDefaultStmt(DefaultStmt *S) {
214   VisitSwitchCase(S);
215   Writer.AddStmt(S->getSubStmt());
216   Writer.AddSourceLocation(S->getDefaultLoc(), Record);
217   Writer.AddSourceLocation(S->getColonLoc(), Record);
218   Code = serialization::STMT_DEFAULT;
219 }
220 
221 void ASTStmtWriter::VisitLabelStmt(LabelStmt *S) {
222   VisitStmt(S);
223   Writer.AddDeclRef(S->getDecl(), Record);
224   Writer.AddStmt(S->getSubStmt());
225   Writer.AddSourceLocation(S->getIdentLoc(), Record);
226   Code = serialization::STMT_LABEL;
227 }
228 
229 void ASTStmtWriter::VisitIfStmt(IfStmt *S) {
230   VisitStmt(S);
231   Writer.AddDeclRef(S->getConditionVariable(), Record);
232   Writer.AddStmt(S->getCond());
233   Writer.AddStmt(S->getThen());
234   Writer.AddStmt(S->getElse());
235   Writer.AddSourceLocation(S->getIfLoc(), Record);
236   Writer.AddSourceLocation(S->getElseLoc(), Record);
237   Code = serialization::STMT_IF;
238 }
239 
240 void ASTStmtWriter::VisitSwitchStmt(SwitchStmt *S) {
241   VisitStmt(S);
242   Writer.AddDeclRef(S->getConditionVariable(), Record);
243   Writer.AddStmt(S->getCond());
244   Writer.AddStmt(S->getBody());
245   Writer.AddSourceLocation(S->getSwitchLoc(), Record);
246   Record.push_back(S->isAllEnumCasesCovered());
247   for (SwitchCase *SC = S->getSwitchCaseList(); SC;
248        SC = SC->getNextSwitchCase())
249     Record.push_back(Writer.RecordSwitchCaseID(SC));
250   Code = serialization::STMT_SWITCH;
251 }
252 
253 void ASTStmtWriter::VisitWhileStmt(WhileStmt *S) {
254   VisitStmt(S);
255   Writer.AddDeclRef(S->getConditionVariable(), Record);
256   Writer.AddStmt(S->getCond());
257   Writer.AddStmt(S->getBody());
258   Writer.AddSourceLocation(S->getWhileLoc(), Record);
259   Code = serialization::STMT_WHILE;
260 }
261 
262 void ASTStmtWriter::VisitDoStmt(DoStmt *S) {
263   VisitStmt(S);
264   Writer.AddStmt(S->getCond());
265   Writer.AddStmt(S->getBody());
266   Writer.AddSourceLocation(S->getDoLoc(), Record);
267   Writer.AddSourceLocation(S->getWhileLoc(), Record);
268   Writer.AddSourceLocation(S->getRParenLoc(), Record);
269   Code = serialization::STMT_DO;
270 }
271 
272 void ASTStmtWriter::VisitForStmt(ForStmt *S) {
273   VisitStmt(S);
274   Writer.AddStmt(S->getInit());
275   Writer.AddStmt(S->getCond());
276   Writer.AddDeclRef(S->getConditionVariable(), Record);
277   Writer.AddStmt(S->getInc());
278   Writer.AddStmt(S->getBody());
279   Writer.AddSourceLocation(S->getForLoc(), Record);
280   Writer.AddSourceLocation(S->getLParenLoc(), Record);
281   Writer.AddSourceLocation(S->getRParenLoc(), Record);
282   Code = serialization::STMT_FOR;
283 }
284 
285 void ASTStmtWriter::VisitGotoStmt(GotoStmt *S) {
286   VisitStmt(S);
287   Writer.AddDeclRef(S->getLabel(), Record);
288   Writer.AddSourceLocation(S->getGotoLoc(), Record);
289   Writer.AddSourceLocation(S->getLabelLoc(), Record);
290   Code = serialization::STMT_GOTO;
291 }
292 
293 void ASTStmtWriter::VisitIndirectGotoStmt(IndirectGotoStmt *S) {
294   VisitStmt(S);
295   Writer.AddSourceLocation(S->getGotoLoc(), Record);
296   Writer.AddSourceLocation(S->getStarLoc(), Record);
297   Writer.AddStmt(S->getTarget());
298   Code = serialization::STMT_INDIRECT_GOTO;
299 }
300 
301 void ASTStmtWriter::VisitContinueStmt(ContinueStmt *S) {
302   VisitStmt(S);
303   Writer.AddSourceLocation(S->getContinueLoc(), Record);
304   Code = serialization::STMT_CONTINUE;
305 }
306 
307 void ASTStmtWriter::VisitBreakStmt(BreakStmt *S) {
308   VisitStmt(S);
309   Writer.AddSourceLocation(S->getBreakLoc(), Record);
310   Code = serialization::STMT_BREAK;
311 }
312 
313 void ASTStmtWriter::VisitReturnStmt(ReturnStmt *S) {
314   VisitStmt(S);
315   Writer.AddStmt(S->getRetValue());
316   Writer.AddSourceLocation(S->getReturnLoc(), Record);
317   Writer.AddDeclRef(S->getNRVOCandidate(), Record);
318   Code = serialization::STMT_RETURN;
319 }
320 
321 void ASTStmtWriter::VisitDeclStmt(DeclStmt *S) {
322   VisitStmt(S);
323   Writer.AddSourceLocation(S->getStartLoc(), Record);
324   Writer.AddSourceLocation(S->getEndLoc(), Record);
325   DeclGroupRef DG = S->getDeclGroup();
326   for (DeclGroupRef::iterator D = DG.begin(), DEnd = DG.end(); D != DEnd; ++D)
327     Writer.AddDeclRef(*D, Record);
328   Code = serialization::STMT_DECL;
329 }
330 
331 void ASTStmtWriter::VisitAsmStmt(AsmStmt *S) {
332   VisitStmt(S);
333   Record.push_back(S->getNumOutputs());
334   Record.push_back(S->getNumInputs());
335   Record.push_back(S->getNumClobbers());
336   Writer.AddSourceLocation(S->getAsmLoc(), Record);
337   Writer.AddSourceLocation(S->getRParenLoc(), Record);
338   Record.push_back(S->isVolatile());
339   Record.push_back(S->isSimple());
340   Record.push_back(S->isMSAsm());
341   Writer.AddStmt(S->getAsmString());
342 
343   // Outputs
344   for (unsigned I = 0, N = S->getNumOutputs(); I != N; ++I) {
345     Writer.AddIdentifierRef(S->getOutputIdentifier(I), Record);
346     Writer.AddStmt(S->getOutputConstraintLiteral(I));
347     Writer.AddStmt(S->getOutputExpr(I));
348   }
349 
350   // Inputs
351   for (unsigned I = 0, N = S->getNumInputs(); I != N; ++I) {
352     Writer.AddIdentifierRef(S->getInputIdentifier(I), Record);
353     Writer.AddStmt(S->getInputConstraintLiteral(I));
354     Writer.AddStmt(S->getInputExpr(I));
355   }
356 
357   // Clobbers
358   for (unsigned I = 0, N = S->getNumClobbers(); I != N; ++I)
359     Writer.AddStmt(S->getClobber(I));
360 
361   Code = serialization::STMT_ASM;
362 }
363 
364 void ASTStmtWriter::VisitExpr(Expr *E) {
365   VisitStmt(E);
366   Writer.AddTypeRef(E->getType(), Record);
367   Record.push_back(E->isTypeDependent());
368   Record.push_back(E->isValueDependent());
369   Record.push_back(E->containsUnexpandedParameterPack());
370   Record.push_back(E->getValueKind());
371   Record.push_back(E->getObjectKind());
372 }
373 
374 void ASTStmtWriter::VisitPredefinedExpr(PredefinedExpr *E) {
375   VisitExpr(E);
376   Writer.AddSourceLocation(E->getLocation(), Record);
377   Record.push_back(E->getIdentType()); // FIXME: stable encoding
378   Code = serialization::EXPR_PREDEFINED;
379 }
380 
381 void ASTStmtWriter::VisitDeclRefExpr(DeclRefExpr *E) {
382   VisitExpr(E);
383 
384   Record.push_back(E->hasQualifier());
385   Record.push_back(E->hasExplicitTemplateArgs());
386 
387   if (E->hasExplicitTemplateArgs()) {
388     unsigned NumTemplateArgs = E->getNumTemplateArgs();
389     Record.push_back(NumTemplateArgs);
390   }
391 
392   if (E->hasQualifier())
393     Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record);
394 
395   if (E->hasExplicitTemplateArgs())
396     AddExplicitTemplateArgumentList(E->getExplicitTemplateArgs());
397 
398   Writer.AddDeclRef(E->getDecl(), Record);
399   Writer.AddSourceLocation(E->getLocation(), Record);
400   Writer.AddDeclarationNameLoc(E->DNLoc, E->getDecl()->getDeclName(), Record);
401   Code = serialization::EXPR_DECL_REF;
402 }
403 
404 void ASTStmtWriter::VisitIntegerLiteral(IntegerLiteral *E) {
405   VisitExpr(E);
406   Writer.AddSourceLocation(E->getLocation(), Record);
407   Writer.AddAPInt(E->getValue(), Record);
408   Code = serialization::EXPR_INTEGER_LITERAL;
409 }
410 
411 void ASTStmtWriter::VisitFloatingLiteral(FloatingLiteral *E) {
412   VisitExpr(E);
413   Writer.AddAPFloat(E->getValue(), Record);
414   Record.push_back(E->isExact());
415   Writer.AddSourceLocation(E->getLocation(), Record);
416   Code = serialization::EXPR_FLOATING_LITERAL;
417 }
418 
419 void ASTStmtWriter::VisitImaginaryLiteral(ImaginaryLiteral *E) {
420   VisitExpr(E);
421   Writer.AddStmt(E->getSubExpr());
422   Code = serialization::EXPR_IMAGINARY_LITERAL;
423 }
424 
425 void ASTStmtWriter::VisitStringLiteral(StringLiteral *E) {
426   VisitExpr(E);
427   Record.push_back(E->getByteLength());
428   Record.push_back(E->getNumConcatenated());
429   Record.push_back(E->isWide());
430   Record.push_back(E->isPascal());
431   // FIXME: String data should be stored as a blob at the end of the
432   // StringLiteral. However, we can't do so now because we have no
433   // provision for coping with abbreviations when we're jumping around
434   // the AST file during deserialization.
435   Record.append(E->getString().begin(), E->getString().end());
436   for (unsigned I = 0, N = E->getNumConcatenated(); I != N; ++I)
437     Writer.AddSourceLocation(E->getStrTokenLoc(I), Record);
438   Code = serialization::EXPR_STRING_LITERAL;
439 }
440 
441 void ASTStmtWriter::VisitCharacterLiteral(CharacterLiteral *E) {
442   VisitExpr(E);
443   Record.push_back(E->getValue());
444   Writer.AddSourceLocation(E->getLocation(), Record);
445   Record.push_back(E->isWide());
446   Code = serialization::EXPR_CHARACTER_LITERAL;
447 }
448 
449 void ASTStmtWriter::VisitParenExpr(ParenExpr *E) {
450   VisitExpr(E);
451   Writer.AddSourceLocation(E->getLParen(), Record);
452   Writer.AddSourceLocation(E->getRParen(), Record);
453   Writer.AddStmt(E->getSubExpr());
454   Code = serialization::EXPR_PAREN;
455 }
456 
457 void ASTStmtWriter::VisitParenListExpr(ParenListExpr *E) {
458   VisitExpr(E);
459   Record.push_back(E->NumExprs);
460   for (unsigned i=0; i != E->NumExprs; ++i)
461     Writer.AddStmt(E->Exprs[i]);
462   Writer.AddSourceLocation(E->LParenLoc, Record);
463   Writer.AddSourceLocation(E->RParenLoc, Record);
464   Code = serialization::EXPR_PAREN_LIST;
465 }
466 
467 void ASTStmtWriter::VisitUnaryOperator(UnaryOperator *E) {
468   VisitExpr(E);
469   Writer.AddStmt(E->getSubExpr());
470   Record.push_back(E->getOpcode()); // FIXME: stable encoding
471   Writer.AddSourceLocation(E->getOperatorLoc(), Record);
472   Code = serialization::EXPR_UNARY_OPERATOR;
473 }
474 
475 void ASTStmtWriter::VisitOffsetOfExpr(OffsetOfExpr *E) {
476   VisitExpr(E);
477   Record.push_back(E->getNumComponents());
478   Record.push_back(E->getNumExpressions());
479   Writer.AddSourceLocation(E->getOperatorLoc(), Record);
480   Writer.AddSourceLocation(E->getRParenLoc(), Record);
481   Writer.AddTypeSourceInfo(E->getTypeSourceInfo(), Record);
482   for (unsigned I = 0, N = E->getNumComponents(); I != N; ++I) {
483     const OffsetOfExpr::OffsetOfNode &ON = E->getComponent(I);
484     Record.push_back(ON.getKind()); // FIXME: Stable encoding
485     Writer.AddSourceLocation(ON.getSourceRange().getBegin(), Record);
486     Writer.AddSourceLocation(ON.getSourceRange().getEnd(), Record);
487     switch (ON.getKind()) {
488     case OffsetOfExpr::OffsetOfNode::Array:
489       Record.push_back(ON.getArrayExprIndex());
490       break;
491 
492     case OffsetOfExpr::OffsetOfNode::Field:
493       Writer.AddDeclRef(ON.getField(), Record);
494       break;
495 
496     case OffsetOfExpr::OffsetOfNode::Identifier:
497       Writer.AddIdentifierRef(ON.getFieldName(), Record);
498       break;
499 
500     case OffsetOfExpr::OffsetOfNode::Base:
501       Writer.AddCXXBaseSpecifier(*ON.getBase(), Record);
502       break;
503     }
504   }
505   for (unsigned I = 0, N = E->getNumExpressions(); I != N; ++I)
506     Writer.AddStmt(E->getIndexExpr(I));
507   Code = serialization::EXPR_OFFSETOF;
508 }
509 
510 void ASTStmtWriter::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E) {
511   VisitExpr(E);
512   Record.push_back(E->getKind());
513   if (E->isArgumentType())
514     Writer.AddTypeSourceInfo(E->getArgumentTypeInfo(), Record);
515   else {
516     Record.push_back(0);
517     Writer.AddStmt(E->getArgumentExpr());
518   }
519   Writer.AddSourceLocation(E->getOperatorLoc(), Record);
520   Writer.AddSourceLocation(E->getRParenLoc(), Record);
521   Code = serialization::EXPR_SIZEOF_ALIGN_OF;
522 }
523 
524 void ASTStmtWriter::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
525   VisitExpr(E);
526   Writer.AddStmt(E->getLHS());
527   Writer.AddStmt(E->getRHS());
528   Writer.AddSourceLocation(E->getRBracketLoc(), Record);
529   Code = serialization::EXPR_ARRAY_SUBSCRIPT;
530 }
531 
532 void ASTStmtWriter::VisitCallExpr(CallExpr *E) {
533   VisitExpr(E);
534   Record.push_back(E->getNumArgs());
535   Writer.AddSourceLocation(E->getRParenLoc(), Record);
536   Writer.AddStmt(E->getCallee());
537   for (CallExpr::arg_iterator Arg = E->arg_begin(), ArgEnd = E->arg_end();
538        Arg != ArgEnd; ++Arg)
539     Writer.AddStmt(*Arg);
540   Code = serialization::EXPR_CALL;
541 }
542 
543 void ASTStmtWriter::VisitMemberExpr(MemberExpr *E) {
544   // Don't call VisitExpr, we'll write everything here.
545 
546   Record.push_back(E->hasQualifier());
547   if (E->hasQualifier())
548     Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record);
549 
550   Record.push_back(E->hasExplicitTemplateArgs());
551   if (E->hasExplicitTemplateArgs()) {
552     unsigned NumTemplateArgs = E->getNumTemplateArgs();
553     Record.push_back(NumTemplateArgs);
554     Writer.AddSourceLocation(E->getLAngleLoc(), Record);
555     Writer.AddSourceLocation(E->getRAngleLoc(), Record);
556     for (unsigned i=0; i != NumTemplateArgs; ++i)
557       Writer.AddTemplateArgumentLoc(E->getTemplateArgs()[i], Record);
558   }
559 
560   DeclAccessPair FoundDecl = E->getFoundDecl();
561   Writer.AddDeclRef(FoundDecl.getDecl(), Record);
562   Record.push_back(FoundDecl.getAccess());
563 
564   Writer.AddTypeRef(E->getType(), Record);
565   Record.push_back(E->getValueKind());
566   Record.push_back(E->getObjectKind());
567   Writer.AddStmt(E->getBase());
568   Writer.AddDeclRef(E->getMemberDecl(), Record);
569   Writer.AddSourceLocation(E->getMemberLoc(), Record);
570   Record.push_back(E->isArrow());
571   Writer.AddDeclarationNameLoc(E->MemberDNLoc,
572                                E->getMemberDecl()->getDeclName(), Record);
573   Code = serialization::EXPR_MEMBER;
574 }
575 
576 void ASTStmtWriter::VisitObjCIsaExpr(ObjCIsaExpr *E) {
577   VisitExpr(E);
578   Writer.AddStmt(E->getBase());
579   Writer.AddSourceLocation(E->getIsaMemberLoc(), Record);
580   Record.push_back(E->isArrow());
581   Code = serialization::EXPR_OBJC_ISA;
582 }
583 
584 void ASTStmtWriter::VisitCastExpr(CastExpr *E) {
585   VisitExpr(E);
586   Record.push_back(E->path_size());
587   Writer.AddStmt(E->getSubExpr());
588   Record.push_back(E->getCastKind()); // FIXME: stable encoding
589 
590   for (CastExpr::path_iterator
591          PI = E->path_begin(), PE = E->path_end(); PI != PE; ++PI)
592     Writer.AddCXXBaseSpecifier(**PI, Record);
593 }
594 
595 void ASTStmtWriter::VisitBinaryOperator(BinaryOperator *E) {
596   VisitExpr(E);
597   Writer.AddStmt(E->getLHS());
598   Writer.AddStmt(E->getRHS());
599   Record.push_back(E->getOpcode()); // FIXME: stable encoding
600   Writer.AddSourceLocation(E->getOperatorLoc(), Record);
601   Code = serialization::EXPR_BINARY_OPERATOR;
602 }
603 
604 void ASTStmtWriter::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
605   VisitBinaryOperator(E);
606   Writer.AddTypeRef(E->getComputationLHSType(), Record);
607   Writer.AddTypeRef(E->getComputationResultType(), Record);
608   Code = serialization::EXPR_COMPOUND_ASSIGN_OPERATOR;
609 }
610 
611 void ASTStmtWriter::VisitConditionalOperator(ConditionalOperator *E) {
612   VisitExpr(E);
613   Writer.AddStmt(E->getCond());
614   Writer.AddStmt(E->getLHS());
615   Writer.AddStmt(E->getRHS());
616   Writer.AddSourceLocation(E->getQuestionLoc(), Record);
617   Writer.AddSourceLocation(E->getColonLoc(), Record);
618   Code = serialization::EXPR_CONDITIONAL_OPERATOR;
619 }
620 
621 void
622 ASTStmtWriter::VisitBinaryConditionalOperator(BinaryConditionalOperator *E) {
623   VisitExpr(E);
624   Writer.AddStmt(E->getOpaqueValue());
625   Writer.AddStmt(E->getCommon());
626   Writer.AddStmt(E->getCond());
627   Writer.AddStmt(E->getTrueExpr());
628   Writer.AddStmt(E->getFalseExpr());
629   Writer.AddSourceLocation(E->getQuestionLoc(), Record);
630   Writer.AddSourceLocation(E->getColonLoc(), Record);
631   Code = serialization::EXPR_BINARY_CONDITIONAL_OPERATOR;
632 }
633 
634 void ASTStmtWriter::VisitImplicitCastExpr(ImplicitCastExpr *E) {
635   VisitCastExpr(E);
636   Code = serialization::EXPR_IMPLICIT_CAST;
637 }
638 
639 void ASTStmtWriter::VisitExplicitCastExpr(ExplicitCastExpr *E) {
640   VisitCastExpr(E);
641   Writer.AddTypeSourceInfo(E->getTypeInfoAsWritten(), Record);
642 }
643 
644 void ASTStmtWriter::VisitCStyleCastExpr(CStyleCastExpr *E) {
645   VisitExplicitCastExpr(E);
646   Writer.AddSourceLocation(E->getLParenLoc(), Record);
647   Writer.AddSourceLocation(E->getRParenLoc(), Record);
648   Code = serialization::EXPR_CSTYLE_CAST;
649 }
650 
651 void ASTStmtWriter::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
652   VisitExpr(E);
653   Writer.AddSourceLocation(E->getLParenLoc(), Record);
654   Writer.AddTypeSourceInfo(E->getTypeSourceInfo(), Record);
655   Writer.AddStmt(E->getInitializer());
656   Record.push_back(E->isFileScope());
657   Code = serialization::EXPR_COMPOUND_LITERAL;
658 }
659 
660 void ASTStmtWriter::VisitExtVectorElementExpr(ExtVectorElementExpr *E) {
661   VisitExpr(E);
662   Writer.AddStmt(E->getBase());
663   Writer.AddIdentifierRef(&E->getAccessor(), Record);
664   Writer.AddSourceLocation(E->getAccessorLoc(), Record);
665   Code = serialization::EXPR_EXT_VECTOR_ELEMENT;
666 }
667 
668 void ASTStmtWriter::VisitInitListExpr(InitListExpr *E) {
669   VisitExpr(E);
670   Record.push_back(E->getNumInits());
671   for (unsigned I = 0, N = E->getNumInits(); I != N; ++I)
672     Writer.AddStmt(E->getInit(I));
673   Writer.AddStmt(E->getSyntacticForm());
674   Writer.AddSourceLocation(E->getLBraceLoc(), Record);
675   Writer.AddSourceLocation(E->getRBraceLoc(), Record);
676   Writer.AddDeclRef(E->getInitializedFieldInUnion(), Record);
677   Record.push_back(E->hadArrayRangeDesignator());
678   Code = serialization::EXPR_INIT_LIST;
679 }
680 
681 void ASTStmtWriter::VisitDesignatedInitExpr(DesignatedInitExpr *E) {
682   VisitExpr(E);
683   Record.push_back(E->getNumSubExprs());
684   for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I)
685     Writer.AddStmt(E->getSubExpr(I));
686   Writer.AddSourceLocation(E->getEqualOrColonLoc(), Record);
687   Record.push_back(E->usesGNUSyntax());
688   for (DesignatedInitExpr::designators_iterator D = E->designators_begin(),
689                                              DEnd = E->designators_end();
690        D != DEnd; ++D) {
691     if (D->isFieldDesignator()) {
692       if (FieldDecl *Field = D->getField()) {
693         Record.push_back(serialization::DESIG_FIELD_DECL);
694         Writer.AddDeclRef(Field, Record);
695       } else {
696         Record.push_back(serialization::DESIG_FIELD_NAME);
697         Writer.AddIdentifierRef(D->getFieldName(), Record);
698       }
699       Writer.AddSourceLocation(D->getDotLoc(), Record);
700       Writer.AddSourceLocation(D->getFieldLoc(), Record);
701     } else if (D->isArrayDesignator()) {
702       Record.push_back(serialization::DESIG_ARRAY);
703       Record.push_back(D->getFirstExprIndex());
704       Writer.AddSourceLocation(D->getLBracketLoc(), Record);
705       Writer.AddSourceLocation(D->getRBracketLoc(), Record);
706     } else {
707       assert(D->isArrayRangeDesignator() && "Unknown designator");
708       Record.push_back(serialization::DESIG_ARRAY_RANGE);
709       Record.push_back(D->getFirstExprIndex());
710       Writer.AddSourceLocation(D->getLBracketLoc(), Record);
711       Writer.AddSourceLocation(D->getEllipsisLoc(), Record);
712       Writer.AddSourceLocation(D->getRBracketLoc(), Record);
713     }
714   }
715   Code = serialization::EXPR_DESIGNATED_INIT;
716 }
717 
718 void ASTStmtWriter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
719   VisitExpr(E);
720   Code = serialization::EXPR_IMPLICIT_VALUE_INIT;
721 }
722 
723 void ASTStmtWriter::VisitVAArgExpr(VAArgExpr *E) {
724   VisitExpr(E);
725   Writer.AddStmt(E->getSubExpr());
726   Writer.AddTypeSourceInfo(E->getWrittenTypeInfo(), Record);
727   Writer.AddSourceLocation(E->getBuiltinLoc(), Record);
728   Writer.AddSourceLocation(E->getRParenLoc(), Record);
729   Code = serialization::EXPR_VA_ARG;
730 }
731 
732 void ASTStmtWriter::VisitAddrLabelExpr(AddrLabelExpr *E) {
733   VisitExpr(E);
734   Writer.AddSourceLocation(E->getAmpAmpLoc(), Record);
735   Writer.AddSourceLocation(E->getLabelLoc(), Record);
736   Writer.AddDeclRef(E->getLabel(), Record);
737   Code = serialization::EXPR_ADDR_LABEL;
738 }
739 
740 void ASTStmtWriter::VisitStmtExpr(StmtExpr *E) {
741   VisitExpr(E);
742   Writer.AddStmt(E->getSubStmt());
743   Writer.AddSourceLocation(E->getLParenLoc(), Record);
744   Writer.AddSourceLocation(E->getRParenLoc(), Record);
745   Code = serialization::EXPR_STMT;
746 }
747 
748 void ASTStmtWriter::VisitChooseExpr(ChooseExpr *E) {
749   VisitExpr(E);
750   Writer.AddStmt(E->getCond());
751   Writer.AddStmt(E->getLHS());
752   Writer.AddStmt(E->getRHS());
753   Writer.AddSourceLocation(E->getBuiltinLoc(), Record);
754   Writer.AddSourceLocation(E->getRParenLoc(), Record);
755   Code = serialization::EXPR_CHOOSE;
756 }
757 
758 void ASTStmtWriter::VisitGNUNullExpr(GNUNullExpr *E) {
759   VisitExpr(E);
760   Writer.AddSourceLocation(E->getTokenLocation(), Record);
761   Code = serialization::EXPR_GNU_NULL;
762 }
763 
764 void ASTStmtWriter::VisitShuffleVectorExpr(ShuffleVectorExpr *E) {
765   VisitExpr(E);
766   Record.push_back(E->getNumSubExprs());
767   for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I)
768     Writer.AddStmt(E->getExpr(I));
769   Writer.AddSourceLocation(E->getBuiltinLoc(), Record);
770   Writer.AddSourceLocation(E->getRParenLoc(), Record);
771   Code = serialization::EXPR_SHUFFLE_VECTOR;
772 }
773 
774 void ASTStmtWriter::VisitBlockExpr(BlockExpr *E) {
775   VisitExpr(E);
776   Writer.AddDeclRef(E->getBlockDecl(), Record);
777   Code = serialization::EXPR_BLOCK;
778 }
779 
780 void ASTStmtWriter::VisitBlockDeclRefExpr(BlockDeclRefExpr *E) {
781   VisitExpr(E);
782   Writer.AddDeclRef(E->getDecl(), Record);
783   Writer.AddSourceLocation(E->getLocation(), Record);
784   Record.push_back(E->isByRef());
785   Record.push_back(E->isConstQualAdded());
786   Code = serialization::EXPR_BLOCK_DECL_REF;
787 }
788 
789 void ASTStmtWriter::VisitGenericSelectionExpr(GenericSelectionExpr *E) {
790   VisitExpr(E);
791   Record.push_back(E->getNumAssocs());
792 
793   Writer.AddStmt(E->getControllingExpr());
794   for (unsigned I = 0, N = E->getNumAssocs(); I != N; ++I) {
795     Writer.AddTypeSourceInfo(E->getAssocTypeSourceInfo(I), Record);
796     Writer.AddStmt(E->getAssocExpr(I));
797   }
798   Record.push_back(E->isResultDependent() ? -1U : E->getResultIndex());
799 
800   Writer.AddSourceLocation(E->getGenericLoc(), Record);
801   Writer.AddSourceLocation(E->getDefaultLoc(), Record);
802   Writer.AddSourceLocation(E->getRParenLoc(), Record);
803   Code = serialization::EXPR_GENERIC_SELECTION;
804 }
805 
806 //===----------------------------------------------------------------------===//
807 // Objective-C Expressions and Statements.
808 //===----------------------------------------------------------------------===//
809 
810 void ASTStmtWriter::VisitObjCStringLiteral(ObjCStringLiteral *E) {
811   VisitExpr(E);
812   Writer.AddStmt(E->getString());
813   Writer.AddSourceLocation(E->getAtLoc(), Record);
814   Code = serialization::EXPR_OBJC_STRING_LITERAL;
815 }
816 
817 void ASTStmtWriter::VisitObjCEncodeExpr(ObjCEncodeExpr *E) {
818   VisitExpr(E);
819   Writer.AddTypeSourceInfo(E->getEncodedTypeSourceInfo(), Record);
820   Writer.AddSourceLocation(E->getAtLoc(), Record);
821   Writer.AddSourceLocation(E->getRParenLoc(), Record);
822   Code = serialization::EXPR_OBJC_ENCODE;
823 }
824 
825 void ASTStmtWriter::VisitObjCSelectorExpr(ObjCSelectorExpr *E) {
826   VisitExpr(E);
827   Writer.AddSelectorRef(E->getSelector(), Record);
828   Writer.AddSourceLocation(E->getAtLoc(), Record);
829   Writer.AddSourceLocation(E->getRParenLoc(), Record);
830   Code = serialization::EXPR_OBJC_SELECTOR_EXPR;
831 }
832 
833 void ASTStmtWriter::VisitObjCProtocolExpr(ObjCProtocolExpr *E) {
834   VisitExpr(E);
835   Writer.AddDeclRef(E->getProtocol(), Record);
836   Writer.AddSourceLocation(E->getAtLoc(), Record);
837   Writer.AddSourceLocation(E->getRParenLoc(), Record);
838   Code = serialization::EXPR_OBJC_PROTOCOL_EXPR;
839 }
840 
841 void ASTStmtWriter::VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
842   VisitExpr(E);
843   Writer.AddDeclRef(E->getDecl(), Record);
844   Writer.AddSourceLocation(E->getLocation(), Record);
845   Writer.AddStmt(E->getBase());
846   Record.push_back(E->isArrow());
847   Record.push_back(E->isFreeIvar());
848   Code = serialization::EXPR_OBJC_IVAR_REF_EXPR;
849 }
850 
851 void ASTStmtWriter::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
852   VisitExpr(E);
853   Record.push_back(E->isImplicitProperty());
854   if (E->isImplicitProperty()) {
855     Writer.AddDeclRef(E->getImplicitPropertyGetter(), Record);
856     Writer.AddDeclRef(E->getImplicitPropertySetter(), Record);
857   } else {
858     Writer.AddDeclRef(E->getExplicitProperty(), Record);
859   }
860   Writer.AddSourceLocation(E->getLocation(), Record);
861   Writer.AddSourceLocation(E->getReceiverLocation(), Record);
862   if (E->isObjectReceiver()) {
863     Record.push_back(0);
864     Writer.AddStmt(E->getBase());
865   } else if (E->isSuperReceiver()) {
866     Record.push_back(1);
867     Writer.AddTypeRef(E->getSuperReceiverType(), Record);
868   } else {
869     Record.push_back(2);
870     Writer.AddDeclRef(E->getClassReceiver(), Record);
871   }
872 
873   Code = serialization::EXPR_OBJC_PROPERTY_REF_EXPR;
874 }
875 
876 void ASTStmtWriter::VisitObjCMessageExpr(ObjCMessageExpr *E) {
877   VisitExpr(E);
878   Record.push_back(E->getNumArgs());
879   Record.push_back((unsigned)E->getReceiverKind()); // FIXME: stable encoding
880   switch (E->getReceiverKind()) {
881   case ObjCMessageExpr::Instance:
882     Writer.AddStmt(E->getInstanceReceiver());
883     break;
884 
885   case ObjCMessageExpr::Class:
886     Writer.AddTypeSourceInfo(E->getClassReceiverTypeInfo(), Record);
887     break;
888 
889   case ObjCMessageExpr::SuperClass:
890   case ObjCMessageExpr::SuperInstance:
891     Writer.AddTypeRef(E->getSuperType(), Record);
892     Writer.AddSourceLocation(E->getSuperLoc(), Record);
893     break;
894   }
895 
896   if (E->getMethodDecl()) {
897     Record.push_back(1);
898     Writer.AddDeclRef(E->getMethodDecl(), Record);
899   } else {
900     Record.push_back(0);
901     Writer.AddSelectorRef(E->getSelector(), Record);
902   }
903 
904   Writer.AddSourceLocation(E->getLeftLoc(), Record);
905   Writer.AddSourceLocation(E->getRightLoc(), Record);
906   Writer.AddSourceLocation(E->getSelectorLoc(), Record);
907 
908   for (CallExpr::arg_iterator Arg = E->arg_begin(), ArgEnd = E->arg_end();
909        Arg != ArgEnd; ++Arg)
910     Writer.AddStmt(*Arg);
911   Code = serialization::EXPR_OBJC_MESSAGE_EXPR;
912 }
913 
914 void ASTStmtWriter::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) {
915   VisitStmt(S);
916   Writer.AddStmt(S->getElement());
917   Writer.AddStmt(S->getCollection());
918   Writer.AddStmt(S->getBody());
919   Writer.AddSourceLocation(S->getForLoc(), Record);
920   Writer.AddSourceLocation(S->getRParenLoc(), Record);
921   Code = serialization::STMT_OBJC_FOR_COLLECTION;
922 }
923 
924 void ASTStmtWriter::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) {
925   Writer.AddStmt(S->getCatchBody());
926   Writer.AddDeclRef(S->getCatchParamDecl(), Record);
927   Writer.AddSourceLocation(S->getAtCatchLoc(), Record);
928   Writer.AddSourceLocation(S->getRParenLoc(), Record);
929   Code = serialization::STMT_OBJC_CATCH;
930 }
931 
932 void ASTStmtWriter::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
933   Writer.AddStmt(S->getFinallyBody());
934   Writer.AddSourceLocation(S->getAtFinallyLoc(), Record);
935   Code = serialization::STMT_OBJC_FINALLY;
936 }
937 
938 void ASTStmtWriter::VisitObjCAtTryStmt(ObjCAtTryStmt *S) {
939   Record.push_back(S->getNumCatchStmts());
940   Record.push_back(S->getFinallyStmt() != 0);
941   Writer.AddStmt(S->getTryBody());
942   for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I)
943     Writer.AddStmt(S->getCatchStmt(I));
944   if (S->getFinallyStmt())
945     Writer.AddStmt(S->getFinallyStmt());
946   Writer.AddSourceLocation(S->getAtTryLoc(), Record);
947   Code = serialization::STMT_OBJC_AT_TRY;
948 }
949 
950 void ASTStmtWriter::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S) {
951   Writer.AddStmt(S->getSynchExpr());
952   Writer.AddStmt(S->getSynchBody());
953   Writer.AddSourceLocation(S->getAtSynchronizedLoc(), Record);
954   Code = serialization::STMT_OBJC_AT_SYNCHRONIZED;
955 }
956 
957 void ASTStmtWriter::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) {
958   Writer.AddStmt(S->getThrowExpr());
959   Writer.AddSourceLocation(S->getThrowLoc(), Record);
960   Code = serialization::STMT_OBJC_AT_THROW;
961 }
962 
963 //===----------------------------------------------------------------------===//
964 // C++ Expressions and Statements.
965 //===----------------------------------------------------------------------===//
966 
967 void ASTStmtWriter::VisitCXXCatchStmt(CXXCatchStmt *S) {
968   VisitStmt(S);
969   Writer.AddSourceLocation(S->getCatchLoc(), Record);
970   Writer.AddDeclRef(S->getExceptionDecl(), Record);
971   Writer.AddStmt(S->getHandlerBlock());
972   Code = serialization::STMT_CXX_CATCH;
973 }
974 
975 void ASTStmtWriter::VisitCXXTryStmt(CXXTryStmt *S) {
976   VisitStmt(S);
977   Record.push_back(S->getNumHandlers());
978   Writer.AddSourceLocation(S->getTryLoc(), Record);
979   Writer.AddStmt(S->getTryBlock());
980   for (unsigned i = 0, e = S->getNumHandlers(); i != e; ++i)
981     Writer.AddStmt(S->getHandler(i));
982   Code = serialization::STMT_CXX_TRY;
983 }
984 
985 void ASTStmtWriter::VisitCXXForRangeStmt(CXXForRangeStmt *S) {
986   VisitStmt(S);
987   Writer.AddSourceLocation(S->getForLoc(), Record);
988   Writer.AddSourceLocation(S->getColonLoc(), Record);
989   Writer.AddSourceLocation(S->getRParenLoc(), Record);
990   Writer.AddStmt(S->getRangeStmt());
991   Writer.AddStmt(S->getBeginEndStmt());
992   Writer.AddStmt(S->getCond());
993   Writer.AddStmt(S->getInc());
994   Writer.AddStmt(S->getLoopVarStmt());
995   Writer.AddStmt(S->getBody());
996   Code = serialization::STMT_CXX_FOR_RANGE;
997 }
998 
999 void ASTStmtWriter::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
1000   VisitCallExpr(E);
1001   Record.push_back(E->getOperator());
1002   Code = serialization::EXPR_CXX_OPERATOR_CALL;
1003 }
1004 
1005 void ASTStmtWriter::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
1006   VisitCallExpr(E);
1007   Code = serialization::EXPR_CXX_MEMBER_CALL;
1008 }
1009 
1010 void ASTStmtWriter::VisitCXXConstructExpr(CXXConstructExpr *E) {
1011   VisitExpr(E);
1012   Record.push_back(E->getNumArgs());
1013   for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
1014     Writer.AddStmt(E->getArg(I));
1015   Writer.AddDeclRef(E->getConstructor(), Record);
1016   Writer.AddSourceLocation(E->getLocation(), Record);
1017   Record.push_back(E->isElidable());
1018   Record.push_back(E->requiresZeroInitialization());
1019   Record.push_back(E->getConstructionKind()); // FIXME: stable encoding
1020   Writer.AddSourceRange(E->getParenRange(), Record);
1021   Code = serialization::EXPR_CXX_CONSTRUCT;
1022 }
1023 
1024 void ASTStmtWriter::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E) {
1025   VisitCXXConstructExpr(E);
1026   Writer.AddTypeSourceInfo(E->getTypeSourceInfo(), Record);
1027   Code = serialization::EXPR_CXX_TEMPORARY_OBJECT;
1028 }
1029 
1030 void ASTStmtWriter::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) {
1031   VisitExplicitCastExpr(E);
1032   Writer.AddSourceRange(SourceRange(E->getOperatorLoc(), E->getRParenLoc()),
1033                         Record);
1034 }
1035 
1036 void ASTStmtWriter::VisitCXXStaticCastExpr(CXXStaticCastExpr *E) {
1037   VisitCXXNamedCastExpr(E);
1038   Code = serialization::EXPR_CXX_STATIC_CAST;
1039 }
1040 
1041 void ASTStmtWriter::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *E) {
1042   VisitCXXNamedCastExpr(E);
1043   Code = serialization::EXPR_CXX_DYNAMIC_CAST;
1044 }
1045 
1046 void ASTStmtWriter::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *E) {
1047   VisitCXXNamedCastExpr(E);
1048   Code = serialization::EXPR_CXX_REINTERPRET_CAST;
1049 }
1050 
1051 void ASTStmtWriter::VisitCXXConstCastExpr(CXXConstCastExpr *E) {
1052   VisitCXXNamedCastExpr(E);
1053   Code = serialization::EXPR_CXX_CONST_CAST;
1054 }
1055 
1056 void ASTStmtWriter::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E) {
1057   VisitExplicitCastExpr(E);
1058   Writer.AddSourceLocation(E->getTypeBeginLoc(), Record);
1059   Writer.AddSourceLocation(E->getRParenLoc(), Record);
1060   Code = serialization::EXPR_CXX_FUNCTIONAL_CAST;
1061 }
1062 
1063 void ASTStmtWriter::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
1064   VisitExpr(E);
1065   Record.push_back(E->getValue());
1066   Writer.AddSourceLocation(E->getLocation(), Record);
1067   Code = serialization::EXPR_CXX_BOOL_LITERAL;
1068 }
1069 
1070 void ASTStmtWriter::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) {
1071   VisitExpr(E);
1072   Writer.AddSourceLocation(E->getLocation(), Record);
1073   Code = serialization::EXPR_CXX_NULL_PTR_LITERAL;
1074 }
1075 
1076 void ASTStmtWriter::VisitCXXTypeidExpr(CXXTypeidExpr *E) {
1077   VisitExpr(E);
1078   Writer.AddSourceRange(E->getSourceRange(), Record);
1079   if (E->isTypeOperand()) {
1080     Writer.AddTypeSourceInfo(E->getTypeOperandSourceInfo(), Record);
1081     Code = serialization::EXPR_CXX_TYPEID_TYPE;
1082   } else {
1083     Writer.AddStmt(E->getExprOperand());
1084     Code = serialization::EXPR_CXX_TYPEID_EXPR;
1085   }
1086 }
1087 
1088 void ASTStmtWriter::VisitCXXUuidofExpr(CXXUuidofExpr *E) {
1089   VisitExpr(E);
1090   Writer.AddSourceRange(E->getSourceRange(), Record);
1091   if (E->isTypeOperand()) {
1092     Writer.AddTypeSourceInfo(E->getTypeOperandSourceInfo(), Record);
1093     Code = serialization::EXPR_CXX_UUIDOF_TYPE;
1094   } else {
1095     Writer.AddStmt(E->getExprOperand());
1096     Code = serialization::EXPR_CXX_UUIDOF_EXPR;
1097   }
1098 }
1099 
1100 void ASTStmtWriter::VisitCXXThisExpr(CXXThisExpr *E) {
1101   VisitExpr(E);
1102   Writer.AddSourceLocation(E->getLocation(), Record);
1103   Record.push_back(E->isImplicit());
1104   Code = serialization::EXPR_CXX_THIS;
1105 }
1106 
1107 void ASTStmtWriter::VisitCXXThrowExpr(CXXThrowExpr *E) {
1108   VisitExpr(E);
1109   Writer.AddSourceLocation(E->getThrowLoc(), Record);
1110   Writer.AddStmt(E->getSubExpr());
1111   Code = serialization::EXPR_CXX_THROW;
1112 }
1113 
1114 void ASTStmtWriter::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
1115   VisitExpr(E);
1116 
1117   bool HasOtherExprStored = E->Param.getInt();
1118   // Store these first, the reader reads them before creation.
1119   Record.push_back(HasOtherExprStored);
1120   if (HasOtherExprStored)
1121     Writer.AddStmt(E->getExpr());
1122   Writer.AddDeclRef(E->getParam(), Record);
1123   Writer.AddSourceLocation(E->getUsedLocation(), Record);
1124 
1125   Code = serialization::EXPR_CXX_DEFAULT_ARG;
1126 }
1127 
1128 void ASTStmtWriter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
1129   VisitExpr(E);
1130   Writer.AddCXXTemporary(E->getTemporary(), Record);
1131   Writer.AddStmt(E->getSubExpr());
1132   Code = serialization::EXPR_CXX_BIND_TEMPORARY;
1133 }
1134 
1135 void ASTStmtWriter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
1136   VisitExpr(E);
1137   Writer.AddTypeSourceInfo(E->getTypeSourceInfo(), Record);
1138   Writer.AddSourceLocation(E->getRParenLoc(), Record);
1139   Code = serialization::EXPR_CXX_SCALAR_VALUE_INIT;
1140 }
1141 
1142 void ASTStmtWriter::VisitCXXNewExpr(CXXNewExpr *E) {
1143   VisitExpr(E);
1144   Record.push_back(E->isGlobalNew());
1145   Record.push_back(E->hasInitializer());
1146   Record.push_back(E->doesUsualArrayDeleteWantSize());
1147   Record.push_back(E->isArray());
1148   Record.push_back(E->getNumPlacementArgs());
1149   Record.push_back(E->getNumConstructorArgs());
1150   Writer.AddDeclRef(E->getOperatorNew(), Record);
1151   Writer.AddDeclRef(E->getOperatorDelete(), Record);
1152   Writer.AddDeclRef(E->getConstructor(), Record);
1153   Writer.AddTypeSourceInfo(E->getAllocatedTypeSourceInfo(), Record);
1154   Writer.AddSourceRange(E->getTypeIdParens(), Record);
1155   Writer.AddSourceLocation(E->getStartLoc(), Record);
1156   Writer.AddSourceLocation(E->getEndLoc(), Record);
1157   Writer.AddSourceLocation(E->getConstructorLParen(), Record);
1158   Writer.AddSourceLocation(E->getConstructorRParen(), Record);
1159   for (CXXNewExpr::arg_iterator I = E->raw_arg_begin(), e = E->raw_arg_end();
1160        I != e; ++I)
1161     Writer.AddStmt(*I);
1162 
1163   Code = serialization::EXPR_CXX_NEW;
1164 }
1165 
1166 void ASTStmtWriter::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
1167   VisitExpr(E);
1168   Record.push_back(E->isGlobalDelete());
1169   Record.push_back(E->isArrayForm());
1170   Record.push_back(E->isArrayFormAsWritten());
1171   Record.push_back(E->doesUsualArrayDeleteWantSize());
1172   Writer.AddDeclRef(E->getOperatorDelete(), Record);
1173   Writer.AddStmt(E->getArgument());
1174   Writer.AddSourceLocation(E->getSourceRange().getBegin(), Record);
1175 
1176   Code = serialization::EXPR_CXX_DELETE;
1177 }
1178 
1179 void ASTStmtWriter::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) {
1180   VisitExpr(E);
1181 
1182   Writer.AddStmt(E->getBase());
1183   Record.push_back(E->isArrow());
1184   Writer.AddSourceLocation(E->getOperatorLoc(), Record);
1185   Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record);
1186   Writer.AddTypeSourceInfo(E->getScopeTypeInfo(), Record);
1187   Writer.AddSourceLocation(E->getColonColonLoc(), Record);
1188   Writer.AddSourceLocation(E->getTildeLoc(), Record);
1189 
1190   // PseudoDestructorTypeStorage.
1191   Writer.AddIdentifierRef(E->getDestroyedTypeIdentifier(), Record);
1192   if (E->getDestroyedTypeIdentifier())
1193     Writer.AddSourceLocation(E->getDestroyedTypeLoc(), Record);
1194   else
1195     Writer.AddTypeSourceInfo(E->getDestroyedTypeInfo(), Record);
1196 
1197   Code = serialization::EXPR_CXX_PSEUDO_DESTRUCTOR;
1198 }
1199 
1200 void ASTStmtWriter::VisitExprWithCleanups(ExprWithCleanups *E) {
1201   VisitExpr(E);
1202   Record.push_back(E->getNumTemporaries());
1203   for (unsigned i = 0, e = E->getNumTemporaries(); i != e; ++i)
1204     Writer.AddCXXTemporary(E->getTemporary(i), Record);
1205 
1206   Writer.AddStmt(E->getSubExpr());
1207   Code = serialization::EXPR_EXPR_WITH_CLEANUPS;
1208 }
1209 
1210 void
1211 ASTStmtWriter::VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E){
1212   VisitExpr(E);
1213 
1214   // Don't emit anything here, hasExplicitTemplateArgs() must be
1215   // emitted first.
1216 
1217   Record.push_back(E->hasExplicitTemplateArgs());
1218   if (E->hasExplicitTemplateArgs()) {
1219     const ExplicitTemplateArgumentList &Args = E->getExplicitTemplateArgs();
1220     Record.push_back(Args.NumTemplateArgs);
1221     AddExplicitTemplateArgumentList(Args);
1222   }
1223 
1224   if (!E->isImplicitAccess())
1225     Writer.AddStmt(E->getBase());
1226   else
1227     Writer.AddStmt(0);
1228   Writer.AddTypeRef(E->getBaseType(), Record);
1229   Record.push_back(E->isArrow());
1230   Writer.AddSourceLocation(E->getOperatorLoc(), Record);
1231   Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record);
1232   Writer.AddDeclRef(E->getFirstQualifierFoundInScope(), Record);
1233   Writer.AddDeclarationNameInfo(E->MemberNameInfo, Record);
1234   Code = serialization::EXPR_CXX_DEPENDENT_SCOPE_MEMBER;
1235 }
1236 
1237 void
1238 ASTStmtWriter::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) {
1239   VisitExpr(E);
1240 
1241   // Don't emit anything here, hasExplicitTemplateArgs() must be
1242   // emitted first.
1243   Record.push_back(E->hasExplicitTemplateArgs());
1244   if (E->hasExplicitTemplateArgs()) {
1245     const ExplicitTemplateArgumentList &Args = E->getExplicitTemplateArgs();
1246     Record.push_back(Args.NumTemplateArgs);
1247     AddExplicitTemplateArgumentList(Args);
1248   }
1249 
1250   Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record);
1251   Writer.AddDeclarationNameInfo(E->NameInfo, Record);
1252   Code = serialization::EXPR_CXX_DEPENDENT_SCOPE_DECL_REF;
1253 }
1254 
1255 void
1256 ASTStmtWriter::VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E) {
1257   VisitExpr(E);
1258   Record.push_back(E->arg_size());
1259   for (CXXUnresolvedConstructExpr::arg_iterator
1260          ArgI = E->arg_begin(), ArgE = E->arg_end(); ArgI != ArgE; ++ArgI)
1261     Writer.AddStmt(*ArgI);
1262   Writer.AddTypeSourceInfo(E->getTypeSourceInfo(), Record);
1263   Writer.AddSourceLocation(E->getLParenLoc(), Record);
1264   Writer.AddSourceLocation(E->getRParenLoc(), Record);
1265   Code = serialization::EXPR_CXX_UNRESOLVED_CONSTRUCT;
1266 }
1267 
1268 void ASTStmtWriter::VisitOverloadExpr(OverloadExpr *E) {
1269   VisitExpr(E);
1270 
1271   // Don't emit anything here, hasExplicitTemplateArgs() must be emitted first.
1272   Record.push_back(E->hasExplicitTemplateArgs());
1273   if (E->hasExplicitTemplateArgs()) {
1274     const ExplicitTemplateArgumentList &Args = E->getExplicitTemplateArgs();
1275     Record.push_back(Args.NumTemplateArgs);
1276     AddExplicitTemplateArgumentList(Args);
1277   }
1278 
1279   Record.push_back(E->getNumDecls());
1280   for (OverloadExpr::decls_iterator
1281          OvI = E->decls_begin(), OvE = E->decls_end(); OvI != OvE; ++OvI) {
1282     Writer.AddDeclRef(OvI.getDecl(), Record);
1283     Record.push_back(OvI.getAccess());
1284   }
1285 
1286   Writer.AddDeclarationNameInfo(E->NameInfo, Record);
1287   Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record);
1288 }
1289 
1290 void ASTStmtWriter::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) {
1291   VisitOverloadExpr(E);
1292   Record.push_back(E->isArrow());
1293   Record.push_back(E->hasUnresolvedUsing());
1294   Writer.AddStmt(!E->isImplicitAccess() ? E->getBase() : 0);
1295   Writer.AddTypeRef(E->getBaseType(), Record);
1296   Writer.AddSourceLocation(E->getOperatorLoc(), Record);
1297   Code = serialization::EXPR_CXX_UNRESOLVED_MEMBER;
1298 }
1299 
1300 void ASTStmtWriter::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) {
1301   VisitOverloadExpr(E);
1302   Record.push_back(E->requiresADL());
1303   if (E->requiresADL())
1304     Record.push_back(E->isStdAssociatedNamespace());
1305   Record.push_back(E->isOverloaded());
1306   Writer.AddDeclRef(E->getNamingClass(), Record);
1307   Code = serialization::EXPR_CXX_UNRESOLVED_LOOKUP;
1308 }
1309 
1310 void ASTStmtWriter::VisitUnaryTypeTraitExpr(UnaryTypeTraitExpr *E) {
1311   VisitExpr(E);
1312   Record.push_back(E->getTrait());
1313   Record.push_back(E->getValue());
1314   Writer.AddSourceRange(E->getSourceRange(), Record);
1315   Writer.AddTypeSourceInfo(E->getQueriedTypeSourceInfo(), Record);
1316   Code = serialization::EXPR_CXX_UNARY_TYPE_TRAIT;
1317 }
1318 
1319 void ASTStmtWriter::VisitBinaryTypeTraitExpr(BinaryTypeTraitExpr *E) {
1320   VisitExpr(E);
1321   Record.push_back(E->getTrait());
1322   Record.push_back(E->getValue());
1323   Writer.AddSourceRange(E->getSourceRange(), Record);
1324   Writer.AddTypeSourceInfo(E->getLhsTypeSourceInfo(), Record);
1325   Writer.AddTypeSourceInfo(E->getRhsTypeSourceInfo(), Record);
1326   Code = serialization::EXPR_BINARY_TYPE_TRAIT;
1327 }
1328 
1329 void ASTStmtWriter::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) {
1330   VisitExpr(E);
1331   Record.push_back(E->getValue());
1332   Writer.AddSourceRange(E->getSourceRange(), Record);
1333   Writer.AddStmt(E->getOperand());
1334   Code = serialization::EXPR_CXX_NOEXCEPT;
1335 }
1336 
1337 void ASTStmtWriter::VisitPackExpansionExpr(PackExpansionExpr *E) {
1338   VisitExpr(E);
1339   Writer.AddSourceLocation(E->getEllipsisLoc(), Record);
1340   Record.push_back(E->NumExpansions);
1341   Writer.AddStmt(E->getPattern());
1342   Code = serialization::EXPR_PACK_EXPANSION;
1343 }
1344 
1345 void ASTStmtWriter::VisitSizeOfPackExpr(SizeOfPackExpr *E) {
1346   VisitExpr(E);
1347   Writer.AddSourceLocation(E->OperatorLoc, Record);
1348   Writer.AddSourceLocation(E->PackLoc, Record);
1349   Writer.AddSourceLocation(E->RParenLoc, Record);
1350   Record.push_back(E->Length);
1351   Writer.AddDeclRef(E->Pack, Record);
1352   Code = serialization::EXPR_SIZEOF_PACK;
1353 }
1354 
1355 void ASTStmtWriter::VisitSubstNonTypeTemplateParmPackExpr(
1356                                           SubstNonTypeTemplateParmPackExpr *E) {
1357   VisitExpr(E);
1358   Writer.AddDeclRef(E->Param, Record);
1359   Writer.AddTemplateArgument(E->getArgumentPack(), Record);
1360   Writer.AddSourceLocation(E->NameLoc, Record);
1361   Code = serialization::EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK;
1362 }
1363 
1364 void ASTStmtWriter::VisitOpaqueValueExpr(OpaqueValueExpr *E) {
1365   VisitExpr(E);
1366   Record.push_back(Writer.getOpaqueValueID(E));
1367   Writer.AddSourceLocation(E->getLocation(), Record);
1368   Code = serialization::EXPR_OPAQUE_VALUE;
1369 }
1370 
1371 //===----------------------------------------------------------------------===//
1372 // CUDA Expressions and Statements.
1373 //===----------------------------------------------------------------------===//
1374 
1375 void ASTStmtWriter::VisitCUDAKernelCallExpr(CUDAKernelCallExpr *E) {
1376   VisitCallExpr(E);
1377   Writer.AddStmt(E->getConfig());
1378   Code = serialization::EXPR_CUDA_KERNEL_CALL;
1379 }
1380 
1381 //===----------------------------------------------------------------------===//
1382 // ASTWriter Implementation
1383 //===----------------------------------------------------------------------===//
1384 
1385 unsigned ASTWriter::RecordSwitchCaseID(SwitchCase *S) {
1386   assert(SwitchCaseIDs.find(S) == SwitchCaseIDs.end() &&
1387          "SwitchCase recorded twice");
1388   unsigned NextID = SwitchCaseIDs.size();
1389   SwitchCaseIDs[S] = NextID;
1390   return NextID;
1391 }
1392 
1393 unsigned ASTWriter::getSwitchCaseID(SwitchCase *S) {
1394   assert(SwitchCaseIDs.find(S) != SwitchCaseIDs.end() &&
1395          "SwitchCase hasn't been seen yet");
1396   return SwitchCaseIDs[S];
1397 }
1398 
1399 void ASTWriter::ClearSwitchCaseIDs() {
1400   SwitchCaseIDs.clear();
1401 }
1402 
1403 unsigned ASTWriter::getOpaqueValueID(OpaqueValueExpr *e) {
1404   unsigned &entry = OpaqueValues[e];
1405   if (!entry) entry = OpaqueValues.size();
1406   return entry;
1407 }
1408 
1409 /// \brief Write the given substatement or subexpression to the
1410 /// bitstream.
1411 void ASTWriter::WriteSubStmt(Stmt *S) {
1412   RecordData Record;
1413   ASTStmtWriter Writer(*this, Record);
1414   ++NumStatements;
1415 
1416   if (!S) {
1417     Stream.EmitRecord(serialization::STMT_NULL_PTR, Record);
1418     return;
1419   }
1420 
1421   // Redirect ASTWriter::AddStmt to collect sub stmts.
1422   llvm::SmallVector<Stmt *, 16> SubStmts;
1423   CollectedStmts = &SubStmts;
1424 
1425   Writer.Code = serialization::STMT_NULL_PTR;
1426   Writer.Visit(S);
1427 
1428 #ifndef NDEBUG
1429   if (Writer.Code == serialization::STMT_NULL_PTR) {
1430     SourceManager &SrcMgr
1431       = DeclIDs.begin()->first->getASTContext().getSourceManager();
1432     S->dump(SrcMgr);
1433     assert(0 && "Unhandled sub statement writing AST file");
1434   }
1435 #endif
1436 
1437   // Revert ASTWriter::AddStmt.
1438   CollectedStmts = &StmtsToEmit;
1439 
1440   // Write the sub stmts in reverse order, last to first. When reading them back
1441   // we will read them in correct order by "pop"ing them from the Stmts stack.
1442   // This simplifies reading and allows to store a variable number of sub stmts
1443   // without knowing it in advance.
1444   while (!SubStmts.empty())
1445     WriteSubStmt(SubStmts.pop_back_val());
1446 
1447   Stream.EmitRecord(Writer.Code, Record);
1448 }
1449 
1450 /// \brief Flush all of the statements that have been added to the
1451 /// queue via AddStmt().
1452 void ASTWriter::FlushStmts() {
1453   RecordData Record;
1454 
1455   for (unsigned I = 0, N = StmtsToEmit.size(); I != N; ++I) {
1456     WriteSubStmt(StmtsToEmit[I]);
1457 
1458     assert(N == StmtsToEmit.size() &&
1459            "Substatement written via AddStmt rather than WriteSubStmt!");
1460 
1461     // Note that we are at the end of a full expression. Any
1462     // expression records that follow this one are part of a different
1463     // expression.
1464     Stream.EmitRecord(serialization::STMT_STOP, Record);
1465   }
1466 
1467   StmtsToEmit.clear();
1468 }
1469