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