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