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