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