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