lib/Serialization/ASTWriterStmt.cpp

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