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