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