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 &ArgInfo,
  44                                   const TemplateArgumentLoc *Args);
  45
  46     void VisitStmt(Stmt *S);
  47 #define STMT(Type, Base) \
  48     void Visit##Type(Type *);
  49 #include "clang/AST/StmtNodes.inc"
  50   };
  51 }
  52
  53 void ASTStmtWriter::AddTemplateKWAndArgsInfo(
  54     const ASTTemplateKWAndArgsInfo &ArgInfo, const TemplateArgumentLoc *Args) {
  55   Writer.AddSourceLocation(ArgInfo.TemplateKWLoc, Record);
  56   Writer.AddSourceLocation(ArgInfo.LAngleLoc, Record);
  57   Writer.AddSourceLocation(ArgInfo.RAngleLoc, Record);
  58   for (unsigned i = 0; i != ArgInfo.NumTemplateArgs; ++i)
  59     Writer.AddTemplateArgumentLoc(Args[i], Record);
  60 }
  61
  62 void ASTStmtWriter::VisitStmt(Stmt *S) {
  63 }
  64
  65 void ASTStmtWriter::VisitNullStmt(NullStmt *S) {
  66   VisitStmt(S);
  67   Writer.AddSourceLocation(S->getSemiLoc(), Record);
  68   Record.push_back(S->HasLeadingEmptyMacro);
  69   Code = serialization::STMT_NULL;
  70 }
  71
  72 void ASTStmtWriter::VisitCompoundStmt(CompoundStmt *S) {
  73   VisitStmt(S);
  74   Record.push_back(S->size());
  75   for (auto *CS : S->body())
  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::VisitCoroutineBodyStmt(CoroutineBodyStmt *S) {
 292   // FIXME: Implement coroutine serialization.
 293   llvm_unreachable("unimplemented");
 294 }
 295
 296 void ASTStmtWriter::VisitCoreturnStmt(CoreturnStmt *S) {
 297   // FIXME: Implement coroutine serialization.
 298   llvm_unreachable("unimplemented");
 299 }
 300
 301 void ASTStmtWriter::VisitCoawaitExpr(CoawaitExpr *S) {
 302   // FIXME: Implement coroutine serialization.
 303   llvm_unreachable("unimplemented");
 304 }
 305
 306 void ASTStmtWriter::VisitCoyieldExpr(CoyieldExpr *S) {
 307   // FIXME: Implement coroutine serialization.
 308   llvm_unreachable("unimplemented");
 309 }
 310
 311 void ASTStmtWriter::VisitCapturedStmt(CapturedStmt *S) {
 312   VisitStmt(S);
 313   // NumCaptures
 314   Record.push_back(std::distance(S->capture_begin(), S->capture_end()));
 315
 316   // CapturedDecl and captured region kind
 317   Writer.AddDeclRef(S->getCapturedDecl(), Record);
 318   Record.push_back(S->getCapturedRegionKind());
 319
 320   Writer.AddDeclRef(S->getCapturedRecordDecl(), Record);
 321
 322   // Capture inits
 323   for (auto *I : S->capture_inits())
 324     Writer.AddStmt(I);
 325
 326   // Body
 327   Writer.AddStmt(S->getCapturedStmt());
 328
 329   // Captures
 330   for (const auto &I : S->captures()) {
 331     if (I.capturesThis() || I.capturesVariableArrayType())
 332       Writer.AddDeclRef(nullptr, Record);
 333     else
 334       Writer.AddDeclRef(I.getCapturedVar(), Record);
 335     Record.push_back(I.getCaptureKind());
 336     Writer.AddSourceLocation(I.getLocation(), Record);
 337   }
 338
 339   Code = serialization::STMT_CAPTURED;
 340 }
 341
 342 void ASTStmtWriter::VisitExpr(Expr *E) {
 343   VisitStmt(E);
 344   Writer.AddTypeRef(E->getType(), Record);
 345   Record.push_back(E->isTypeDependent());
 346   Record.push_back(E->isValueDependent());
 347   Record.push_back(E->isInstantiationDependent());
 348   Record.push_back(E->containsUnexpandedParameterPack());
 349   Record.push_back(E->getValueKind());
 350   Record.push_back(E->getObjectKind());
 351 }
 352
 353 void ASTStmtWriter::VisitPredefinedExpr(PredefinedExpr *E) {
 354   VisitExpr(E);
 355   Writer.AddSourceLocation(E->getLocation(), Record);
 356   Record.push_back(E->getIdentType()); // FIXME: stable encoding
 357   Writer.AddStmt(E->getFunctionName());
 358   Code = serialization::EXPR_PREDEFINED;
 359 }
 360
 361 void ASTStmtWriter::VisitDeclRefExpr(DeclRefExpr *E) {
 362   VisitExpr(E);
 363
 364   Record.push_back(E->hasQualifier());
 365   Record.push_back(E->getDecl() != E->getFoundDecl());
 366   Record.push_back(E->hasTemplateKWAndArgsInfo());
 367   Record.push_back(E->hadMultipleCandidates());
 368   Record.push_back(E->refersToEnclosingVariableOrCapture());
 369
 370   if (E->hasTemplateKWAndArgsInfo()) {
 371     unsigned NumTemplateArgs = E->getNumTemplateArgs();
 372     Record.push_back(NumTemplateArgs);
 373   }
 374
 375   DeclarationName::NameKind nk = (E->getDecl()->getDeclName().getNameKind());
 376
 377   if ((!E->hasTemplateKWAndArgsInfo()) && (!E->hasQualifier()) &&
 378       (E->getDecl() == E->getFoundDecl()) &&
 379       nk == DeclarationName::Identifier) {
 380     AbbrevToUse = Writer.getDeclRefExprAbbrev();
 381   }
 382
 383   if (E->hasQualifier())
 384     Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record);
 385
 386   if (E->getDecl() != E->getFoundDecl())
 387     Writer.AddDeclRef(E->getFoundDecl(), Record);
 388
 389   if (E->hasTemplateKWAndArgsInfo())
 390     AddTemplateKWAndArgsInfo(*E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(),
 391                              E->getTrailingObjects<TemplateArgumentLoc>());
 392
 393   Writer.AddDeclRef(E->getDecl(), Record);
 394   Writer.AddSourceLocation(E->getLocation(), Record);
 395   Writer.AddDeclarationNameLoc(E->DNLoc, E->getDecl()->getDeclName(), Record);
 396   Code = serialization::EXPR_DECL_REF;
 397 }
 398
 399 void ASTStmtWriter::VisitIntegerLiteral(IntegerLiteral *E) {
 400   VisitExpr(E);
 401   Writer.AddSourceLocation(E->getLocation(), Record);
 402   Writer.AddAPInt(E->getValue(), Record);
 403
 404   if (E->getValue().getBitWidth() == 32) {
 405     AbbrevToUse = Writer.getIntegerLiteralAbbrev();
 406   }
 407
 408   Code = serialization::EXPR_INTEGER_LITERAL;
 409 }
 410
 411 void ASTStmtWriter::VisitFloatingLiteral(FloatingLiteral *E) {
 412   VisitExpr(E);
 413   Record.push_back(E->getRawSemantics());
 414   Record.push_back(E->isExact());
 415   Writer.AddAPFloat(E->getValue(), Record);
 416   Writer.AddSourceLocation(E->getLocation(), Record);
 417   Code = serialization::EXPR_FLOATING_LITERAL;
 418 }
 419
 420 void ASTStmtWriter::VisitImaginaryLiteral(ImaginaryLiteral *E) {
 421   VisitExpr(E);
 422   Writer.AddStmt(E->getSubExpr());
 423   Code = serialization::EXPR_IMAGINARY_LITERAL;
 424 }
 425
 426 void ASTStmtWriter::VisitStringLiteral(StringLiteral *E) {
 427   VisitExpr(E);
 428   Record.push_back(E->getByteLength());
 429   Record.push_back(E->getNumConcatenated());
 430   Record.push_back(E->getKind());
 431   Record.push_back(E->isPascal());
 432   // FIXME: String data should be stored as a blob at the end of the
 433   // StringLiteral. However, we can't do so now because we have no
 434   // provision for coping with abbreviations when we're jumping around
 435   // the AST file during deserialization.
 436   Record.append(E->getBytes().begin(), E->getBytes().end());
 437   for (unsigned I = 0, N = E->getNumConcatenated(); I != N; ++I)
 438     Writer.AddSourceLocation(E->getStrTokenLoc(I), Record);
 439   Code = serialization::EXPR_STRING_LITERAL;
 440 }
 441
 442 void ASTStmtWriter::VisitCharacterLiteral(CharacterLiteral *E) {
 443   VisitExpr(E);
 444   Record.push_back(E->getValue());
 445   Writer.AddSourceLocation(E->getLocation(), Record);
 446   Record.push_back(E->getKind());
 447
 448   AbbrevToUse = Writer.getCharacterLiteralAbbrev();
 449
 450   Code = serialization::EXPR_CHARACTER_LITERAL;
 451 }
 452
 453 void ASTStmtWriter::VisitParenExpr(ParenExpr *E) {
 454   VisitExpr(E);
 455   Writer.AddSourceLocation(E->getLParen(), Record);
 456   Writer.AddSourceLocation(E->getRParen(), Record);
 457   Writer.AddStmt(E->getSubExpr());
 458   Code = serialization::EXPR_PAREN;
 459 }
 460
 461 void ASTStmtWriter::VisitParenListExpr(ParenListExpr *E) {
 462   VisitExpr(E);
 463   Record.push_back(E->NumExprs);
 464   for (unsigned i=0; i != E->NumExprs; ++i)
 465     Writer.AddStmt(E->Exprs[i]);
 466   Writer.AddSourceLocation(E->LParenLoc, Record);
 467   Writer.AddSourceLocation(E->RParenLoc, Record);
 468   Code = serialization::EXPR_PAREN_LIST;
 469 }
 470
 471 void ASTStmtWriter::VisitUnaryOperator(UnaryOperator *E) {
 472   VisitExpr(E);
 473   Writer.AddStmt(E->getSubExpr());
 474   Record.push_back(E->getOpcode()); // FIXME: stable encoding
 475   Writer.AddSourceLocation(E->getOperatorLoc(), Record);
 476   Code = serialization::EXPR_UNARY_OPERATOR;
 477 }
 478
 479 void ASTStmtWriter::VisitOffsetOfExpr(OffsetOfExpr *E) {
 480   VisitExpr(E);
 481   Record.push_back(E->getNumComponents());
 482   Record.push_back(E->getNumExpressions());
 483   Writer.AddSourceLocation(E->getOperatorLoc(), Record);
 484   Writer.AddSourceLocation(E->getRParenLoc(), Record);
 485   Writer.AddTypeSourceInfo(E->getTypeSourceInfo(), Record);
 486   for (unsigned I = 0, N = E->getNumComponents(); I != N; ++I) {
 487     const OffsetOfNode &ON = E->getComponent(I);
 488     Record.push_back(ON.getKind()); // FIXME: Stable encoding
 489     Writer.AddSourceLocation(ON.getSourceRange().getBegin(), Record);
 490     Writer.AddSourceLocation(ON.getSourceRange().getEnd(), Record);
 491     switch (ON.getKind()) {
 492     case OffsetOfNode::Array:
 493       Record.push_back(ON.getArrayExprIndex());
 494       break;
 495
 496     case OffsetOfNode::Field:
 497       Writer.AddDeclRef(ON.getField(), Record);
 498       break;
 499
 500     case OffsetOfNode::Identifier:
 501       Writer.AddIdentifierRef(ON.getFieldName(), Record);
 502       break;
 503
 504     case OffsetOfNode::Base:
 505       Writer.AddCXXBaseSpecifier(*ON.getBase(), Record);
 506       break;
 507     }
 508   }
 509   for (unsigned I = 0, N = E->getNumExpressions(); I != N; ++I)
 510     Writer.AddStmt(E->getIndexExpr(I));
 511   Code = serialization::EXPR_OFFSETOF;
 512 }
 513
 514 void ASTStmtWriter::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E) {
 515   VisitExpr(E);
 516   Record.push_back(E->getKind());
 517   if (E->isArgumentType())
 518     Writer.AddTypeSourceInfo(E->getArgumentTypeInfo(), Record);
 519   else {
 520     Record.push_back(0);
 521     Writer.AddStmt(E->getArgumentExpr());
 522   }
 523   Writer.AddSourceLocation(E->getOperatorLoc(), Record);
 524   Writer.AddSourceLocation(E->getRParenLoc(), Record);
 525   Code = serialization::EXPR_SIZEOF_ALIGN_OF;
 526 }
 527
 528 void ASTStmtWriter::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
 529   VisitExpr(E);
 530   Writer.AddStmt(E->getLHS());
 531   Writer.AddStmt(E->getRHS());
 532   Writer.AddSourceLocation(E->getRBracketLoc(), Record);
 533   Code = serialization::EXPR_ARRAY_SUBSCRIPT;
 534 }
 535
 536 void ASTStmtWriter::VisitOMPArraySectionExpr(OMPArraySectionExpr *E) {
 537   VisitExpr(E);
 538   Writer.AddStmt(E->getBase());
 539   Writer.AddStmt(E->getLowerBound());
 540   Writer.AddStmt(E->getLength());
 541   Writer.AddSourceLocation(E->getColonLoc(), Record);
 542   Writer.AddSourceLocation(E->getRBracketLoc(), Record);
 543   Code = serialization::EXPR_OMP_ARRAY_SECTION;
 544 }
 545
 546 void ASTStmtWriter::VisitCallExpr(CallExpr *E) {
 547   VisitExpr(E);
 548   Record.push_back(E->getNumArgs());
 549   Writer.AddSourceLocation(E->getRParenLoc(), Record);
 550   Writer.AddStmt(E->getCallee());
 551   for (CallExpr::arg_iterator Arg = E->arg_begin(), ArgEnd = E->arg_end();
 552        Arg != ArgEnd; ++Arg)
 553     Writer.AddStmt(*Arg);
 554   Code = serialization::EXPR_CALL;
 555 }
 556
 557 void ASTStmtWriter::VisitMemberExpr(MemberExpr *E) {
 558   // Don't call VisitExpr, we'll write everything here.
 559
 560   Record.push_back(E->hasQualifier());
 561   if (E->hasQualifier())
 562     Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record);
 563
 564   Record.push_back(E->HasTemplateKWAndArgsInfo);
 565   if (E->HasTemplateKWAndArgsInfo) {
 566     Writer.AddSourceLocation(E->getTemplateKeywordLoc(), Record);
 567     unsigned NumTemplateArgs = E->getNumTemplateArgs();
 568     Record.push_back(NumTemplateArgs);
 569     Writer.AddSourceLocation(E->getLAngleLoc(), Record);
 570     Writer.AddSourceLocation(E->getRAngleLoc(), Record);
 571     for (unsigned i=0; i != NumTemplateArgs; ++i)
 572       Writer.AddTemplateArgumentLoc(E->getTemplateArgs()[i], Record);
 573   }
 574
 575   Record.push_back(E->hadMultipleCandidates());
 576
 577   DeclAccessPair FoundDecl = E->getFoundDecl();
 578   Writer.AddDeclRef(FoundDecl.getDecl(), Record);
 579   Record.push_back(FoundDecl.getAccess());
 580
 581   Writer.AddTypeRef(E->getType(), Record);
 582   Record.push_back(E->getValueKind());
 583   Record.push_back(E->getObjectKind());
 584   Writer.AddStmt(E->getBase());
 585   Writer.AddDeclRef(E->getMemberDecl(), Record);
 586   Writer.AddSourceLocation(E->getMemberLoc(), Record);
 587   Record.push_back(E->isArrow());
 588   Writer.AddSourceLocation(E->getOperatorLoc(), Record);
 589   Writer.AddDeclarationNameLoc(E->MemberDNLoc,
 590                                E->getMemberDecl()->getDeclName(), Record);
 591   Code = serialization::EXPR_MEMBER;
 592 }
 593
 594 void ASTStmtWriter::VisitObjCIsaExpr(ObjCIsaExpr *E) {
 595   VisitExpr(E);
 596   Writer.AddStmt(E->getBase());
 597   Writer.AddSourceLocation(E->getIsaMemberLoc(), Record);
 598   Writer.AddSourceLocation(E->getOpLoc(), Record);
 599   Record.push_back(E->isArrow());
 600   Code = serialization::EXPR_OBJC_ISA;
 601 }
 602
 603 void ASTStmtWriter::
 604 VisitObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *E) {
 605   VisitExpr(E);
 606   Writer.AddStmt(E->getSubExpr());
 607   Record.push_back(E->shouldCopy());
 608   Code = serialization::EXPR_OBJC_INDIRECT_COPY_RESTORE;
 609 }
 610
 611 void ASTStmtWriter::VisitObjCBridgedCastExpr(ObjCBridgedCastExpr *E) {
 612   VisitExplicitCastExpr(E);
 613   Writer.AddSourceLocation(E->getLParenLoc(), Record);
 614   Writer.AddSourceLocation(E->getBridgeKeywordLoc(), Record);
 615   Record.push_back(E->getBridgeKind()); // FIXME: Stable encoding
 616   Code = serialization::EXPR_OBJC_BRIDGED_CAST;
 617 }
 618
 619 void ASTStmtWriter::VisitCastExpr(CastExpr *E) {
 620   VisitExpr(E);
 621   Record.push_back(E->path_size());
 622   Writer.AddStmt(E->getSubExpr());
 623   Record.push_back(E->getCastKind()); // FIXME: stable encoding
 624
 625   for (CastExpr::path_iterator
 626          PI = E->path_begin(), PE = E->path_end(); PI != PE; ++PI)
 627     Writer.AddCXXBaseSpecifier(**PI, Record);
 628 }
 629
 630 void ASTStmtWriter::VisitBinaryOperator(BinaryOperator *E) {
 631   VisitExpr(E);
 632   Writer.AddStmt(E->getLHS());
 633   Writer.AddStmt(E->getRHS());
 634   Record.push_back(E->getOpcode()); // FIXME: stable encoding
 635   Writer.AddSourceLocation(E->getOperatorLoc(), Record);
 636   Record.push_back(E->isFPContractable());
 637   Code = serialization::EXPR_BINARY_OPERATOR;
 638 }
 639
 640 void ASTStmtWriter::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
 641   VisitBinaryOperator(E);
 642   Writer.AddTypeRef(E->getComputationLHSType(), Record);
 643   Writer.AddTypeRef(E->getComputationResultType(), Record);
 644   Code = serialization::EXPR_COMPOUND_ASSIGN_OPERATOR;
 645 }
 646
 647 void ASTStmtWriter::VisitConditionalOperator(ConditionalOperator *E) {
 648   VisitExpr(E);
 649   Writer.AddStmt(E->getCond());
 650   Writer.AddStmt(E->getLHS());
 651   Writer.AddStmt(E->getRHS());
 652   Writer.AddSourceLocation(E->getQuestionLoc(), Record);
 653   Writer.AddSourceLocation(E->getColonLoc(), Record);
 654   Code = serialization::EXPR_CONDITIONAL_OPERATOR;
 655 }
 656
 657 void
 658 ASTStmtWriter::VisitBinaryConditionalOperator(BinaryConditionalOperator *E) {
 659   VisitExpr(E);
 660   Writer.AddStmt(E->getOpaqueValue());
 661   Writer.AddStmt(E->getCommon());
 662   Writer.AddStmt(E->getCond());
 663   Writer.AddStmt(E->getTrueExpr());
 664   Writer.AddStmt(E->getFalseExpr());
 665   Writer.AddSourceLocation(E->getQuestionLoc(), Record);
 666   Writer.AddSourceLocation(E->getColonLoc(), Record);
 667   Code = serialization::EXPR_BINARY_CONDITIONAL_OPERATOR;
 668 }
 669
 670 void ASTStmtWriter::VisitImplicitCastExpr(ImplicitCastExpr *E) {
 671   VisitCastExpr(E);
 672
 673   if (E->path_size() == 0)
 674     AbbrevToUse = Writer.getExprImplicitCastAbbrev();
 675
 676   Code = serialization::EXPR_IMPLICIT_CAST;
 677 }
 678
 679 void ASTStmtWriter::VisitExplicitCastExpr(ExplicitCastExpr *E) {
 680   VisitCastExpr(E);
 681   Writer.AddTypeSourceInfo(E->getTypeInfoAsWritten(), Record);
 682 }
 683
 684 void ASTStmtWriter::VisitCStyleCastExpr(CStyleCastExpr *E) {
 685   VisitExplicitCastExpr(E);
 686   Writer.AddSourceLocation(E->getLParenLoc(), Record);
 687   Writer.AddSourceLocation(E->getRParenLoc(), Record);
 688   Code = serialization::EXPR_CSTYLE_CAST;
 689 }
 690
 691 void ASTStmtWriter::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
 692   VisitExpr(E);
 693   Writer.AddSourceLocation(E->getLParenLoc(), Record);
 694   Writer.AddTypeSourceInfo(E->getTypeSourceInfo(), Record);
 695   Writer.AddStmt(E->getInitializer());
 696   Record.push_back(E->isFileScope());
 697   Code = serialization::EXPR_COMPOUND_LITERAL;
 698 }
 699
 700 void ASTStmtWriter::VisitExtVectorElementExpr(ExtVectorElementExpr *E) {
 701   VisitExpr(E);
 702   Writer.AddStmt(E->getBase());
 703   Writer.AddIdentifierRef(&E->getAccessor(), Record);
 704   Writer.AddSourceLocation(E->getAccessorLoc(), Record);
 705   Code = serialization::EXPR_EXT_VECTOR_ELEMENT;
 706 }
 707
 708 void ASTStmtWriter::VisitInitListExpr(InitListExpr *E) {
 709   VisitExpr(E);
 710   // NOTE: only add the (possibly null) syntactic form.
 711   // No need to serialize the isSemanticForm flag and the semantic form.
 712   Writer.AddStmt(E->getSyntacticForm());
 713   Writer.AddSourceLocation(E->getLBraceLoc(), Record);
 714   Writer.AddSourceLocation(E->getRBraceLoc(), Record);
 715   bool isArrayFiller = E->ArrayFillerOrUnionFieldInit.is<Expr*>();
 716   Record.push_back(isArrayFiller);
 717   if (isArrayFiller)
 718     Writer.AddStmt(E->getArrayFiller());
 719   else
 720     Writer.AddDeclRef(E->getInitializedFieldInUnion(), Record);
 721   Record.push_back(E->hadArrayRangeDesignator());
 722   Record.push_back(E->getNumInits());
 723   if (isArrayFiller) {
 724     // ArrayFiller may have filled "holes" due to designated initializer.
 725     // Replace them by 0 to indicate that the filler goes in that place.
 726     Expr *filler = E->getArrayFiller();
 727     for (unsigned I = 0, N = E->getNumInits(); I != N; ++I)
 728       Writer.AddStmt(E->getInit(I) != filler ? E->getInit(I) : nullptr);
 729   } else {
 730     for (unsigned I = 0, N = E->getNumInits(); I != N; ++I)
 731       Writer.AddStmt(E->getInit(I));
 732   }
 733   Code = serialization::EXPR_INIT_LIST;
 734 }
 735
 736 void ASTStmtWriter::VisitDesignatedInitExpr(DesignatedInitExpr *E) {
 737   VisitExpr(E);
 738   Record.push_back(E->getNumSubExprs());
 739   for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I)
 740     Writer.AddStmt(E->getSubExpr(I));
 741   Writer.AddSourceLocation(E->getEqualOrColonLoc(), Record);
 742   Record.push_back(E->usesGNUSyntax());
 743   for (DesignatedInitExpr::designators_iterator D = E->designators_begin(),
 744                                              DEnd = E->designators_end();
 745        D != DEnd; ++D) {
 746     if (D->isFieldDesignator()) {
 747       if (FieldDecl *Field = D->getField()) {
 748         Record.push_back(serialization::DESIG_FIELD_DECL);
 749         Writer.AddDeclRef(Field, Record);
 750       } else {
 751         Record.push_back(serialization::DESIG_FIELD_NAME);
 752         Writer.AddIdentifierRef(D->getFieldName(), Record);
 753       }
 754       Writer.AddSourceLocation(D->getDotLoc(), Record);
 755       Writer.AddSourceLocation(D->getFieldLoc(), Record);
 756     } else if (D->isArrayDesignator()) {
 757       Record.push_back(serialization::DESIG_ARRAY);
 758       Record.push_back(D->getFirstExprIndex());
 759       Writer.AddSourceLocation(D->getLBracketLoc(), Record);
 760       Writer.AddSourceLocation(D->getRBracketLoc(), Record);
 761     } else {
 762       assert(D->isArrayRangeDesignator() && "Unknown designator");
 763       Record.push_back(serialization::DESIG_ARRAY_RANGE);
 764       Record.push_back(D->getFirstExprIndex());
 765       Writer.AddSourceLocation(D->getLBracketLoc(), Record);
 766       Writer.AddSourceLocation(D->getEllipsisLoc(), Record);
 767       Writer.AddSourceLocation(D->getRBracketLoc(), Record);
 768     }
 769   }
 770   Code = serialization::EXPR_DESIGNATED_INIT;
 771 }
 772
 773 void ASTStmtWriter::VisitDesignatedInitUpdateExpr(DesignatedInitUpdateExpr *E) {
 774   VisitExpr(E);
 775   Writer.AddStmt(E->getBase());
 776   Writer.AddStmt(E->getUpdater());
 777   Code = serialization::EXPR_DESIGNATED_INIT_UPDATE;
 778 }
 779
 780 void ASTStmtWriter::VisitNoInitExpr(NoInitExpr *E) {
 781   VisitExpr(E);
 782   Code = serialization::EXPR_NO_INIT;
 783 }
 784
 785 void ASTStmtWriter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
 786   VisitExpr(E);
 787   Code = serialization::EXPR_IMPLICIT_VALUE_INIT;
 788 }
 789
 790 void ASTStmtWriter::VisitVAArgExpr(VAArgExpr *E) {
 791   VisitExpr(E);
 792   Writer.AddStmt(E->getSubExpr());
 793   Writer.AddTypeSourceInfo(E->getWrittenTypeInfo(), Record);
 794   Writer.AddSourceLocation(E->getBuiltinLoc(), Record);
 795   Writer.AddSourceLocation(E->getRParenLoc(), Record);
 796   Record.push_back(E->isMicrosoftABI());
 797   Code = serialization::EXPR_VA_ARG;
 798 }
 799
 800 void ASTStmtWriter::VisitAddrLabelExpr(AddrLabelExpr *E) {
 801   VisitExpr(E);
 802   Writer.AddSourceLocation(E->getAmpAmpLoc(), Record);
 803   Writer.AddSourceLocation(E->getLabelLoc(), Record);
 804   Writer.AddDeclRef(E->getLabel(), Record);
 805   Code = serialization::EXPR_ADDR_LABEL;
 806 }
 807
 808 void ASTStmtWriter::VisitStmtExpr(StmtExpr *E) {
 809   VisitExpr(E);
 810   Writer.AddStmt(E->getSubStmt());
 811   Writer.AddSourceLocation(E->getLParenLoc(), Record);
 812   Writer.AddSourceLocation(E->getRParenLoc(), Record);
 813   Code = serialization::EXPR_STMT;
 814 }
 815
 816 void ASTStmtWriter::VisitChooseExpr(ChooseExpr *E) {
 817   VisitExpr(E);
 818   Writer.AddStmt(E->getCond());
 819   Writer.AddStmt(E->getLHS());
 820   Writer.AddStmt(E->getRHS());
 821   Writer.AddSourceLocation(E->getBuiltinLoc(), Record);
 822   Writer.AddSourceLocation(E->getRParenLoc(), Record);
 823   Record.push_back(E->isConditionDependent() ? false : E->isConditionTrue());
 824   Code = serialization::EXPR_CHOOSE;
 825 }
 826
 827 void ASTStmtWriter::VisitGNUNullExpr(GNUNullExpr *E) {
 828   VisitExpr(E);
 829   Writer.AddSourceLocation(E->getTokenLocation(), Record);
 830   Code = serialization::EXPR_GNU_NULL;
 831 }
 832
 833 void ASTStmtWriter::VisitShuffleVectorExpr(ShuffleVectorExpr *E) {
 834   VisitExpr(E);
 835   Record.push_back(E->getNumSubExprs());
 836   for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I)
 837     Writer.AddStmt(E->getExpr(I));
 838   Writer.AddSourceLocation(E->getBuiltinLoc(), Record);
 839   Writer.AddSourceLocation(E->getRParenLoc(), Record);
 840   Code = serialization::EXPR_SHUFFLE_VECTOR;
 841 }
 842
 843 void ASTStmtWriter::VisitConvertVectorExpr(ConvertVectorExpr *E) {
 844   VisitExpr(E);
 845   Writer.AddSourceLocation(E->getBuiltinLoc(), Record);
 846   Writer.AddSourceLocation(E->getRParenLoc(), Record);
 847   Writer.AddTypeSourceInfo(E->getTypeSourceInfo(), Record);
 848   Writer.AddStmt(E->getSrcExpr());
 849   Code = serialization::EXPR_CONVERT_VECTOR;
 850 }
 851
 852 void ASTStmtWriter::VisitBlockExpr(BlockExpr *E) {
 853   VisitExpr(E);
 854   Writer.AddDeclRef(E->getBlockDecl(), Record);
 855   Code = serialization::EXPR_BLOCK;
 856 }
 857
 858 void ASTStmtWriter::VisitGenericSelectionExpr(GenericSelectionExpr *E) {
 859   VisitExpr(E);
 860   Record.push_back(E->getNumAssocs());
 861
 862   Writer.AddStmt(E->getControllingExpr());
 863   for (unsigned I = 0, N = E->getNumAssocs(); I != N; ++I) {
 864     Writer.AddTypeSourceInfo(E->getAssocTypeSourceInfo(I), Record);
 865     Writer.AddStmt(E->getAssocExpr(I));
 866   }
 867   Record.push_back(E->isResultDependent() ? -1U : E->getResultIndex());
 868
 869   Writer.AddSourceLocation(E->getGenericLoc(), Record);
 870   Writer.AddSourceLocation(E->getDefaultLoc(), Record);
 871   Writer.AddSourceLocation(E->getRParenLoc(), Record);
 872   Code = serialization::EXPR_GENERIC_SELECTION;
 873 }
 874
 875 void ASTStmtWriter::VisitPseudoObjectExpr(PseudoObjectExpr *E) {
 876   VisitExpr(E);
 877   Record.push_back(E->getNumSemanticExprs());
 878
 879   // Push the result index.  Currently, this needs to exactly match
 880   // the encoding used internally for ResultIndex.
 881   unsigned result = E->getResultExprIndex();
 882   result = (result == PseudoObjectExpr::NoResult ? 0 : result + 1);
 883   Record.push_back(result);
 884
 885   Writer.AddStmt(E->getSyntacticForm());
 886   for (PseudoObjectExpr::semantics_iterator
 887          i = E->semantics_begin(), e = E->semantics_end(); i != e; ++i) {
 888     Writer.AddStmt(*i);
 889   }
 890   Code = serialization::EXPR_PSEUDO_OBJECT;
 891 }
 892
 893 void ASTStmtWriter::VisitAtomicExpr(AtomicExpr *E) {
 894   VisitExpr(E);
 895   Record.push_back(E->getOp());
 896   for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I)
 897     Writer.AddStmt(E->getSubExprs()[I]);
 898   Writer.AddSourceLocation(E->getBuiltinLoc(), Record);
 899   Writer.AddSourceLocation(E->getRParenLoc(), Record);
 900   Code = serialization::EXPR_ATOMIC;
 901 }
 902
 903 //===----------------------------------------------------------------------===//
 904 // Objective-C Expressions and Statements.
 905 //===----------------------------------------------------------------------===//
 906
 907 void ASTStmtWriter::VisitObjCStringLiteral(ObjCStringLiteral *E) {
 908   VisitExpr(E);
 909   Writer.AddStmt(E->getString());
 910   Writer.AddSourceLocation(E->getAtLoc(), Record);
 911   Code = serialization::EXPR_OBJC_STRING_LITERAL;
 912 }
 913
 914 void ASTStmtWriter::VisitObjCBoxedExpr(ObjCBoxedExpr *E) {
 915   VisitExpr(E);
 916   Writer.AddStmt(E->getSubExpr());
 917   Writer.AddDeclRef(E->getBoxingMethod(), Record);
 918   Writer.AddSourceRange(E->getSourceRange(), Record);
 919   Code = serialization::EXPR_OBJC_BOXED_EXPRESSION;
 920 }
 921
 922 void ASTStmtWriter::VisitObjCArrayLiteral(ObjCArrayLiteral *E) {
 923   VisitExpr(E);
 924   Record.push_back(E->getNumElements());
 925   for (unsigned i = 0; i < E->getNumElements(); i++)
 926     Writer.AddStmt(E->getElement(i));
 927   Writer.AddDeclRef(E->getArrayWithObjectsMethod(), Record);
 928   Writer.AddSourceRange(E->getSourceRange(), Record);
 929   Code = serialization::EXPR_OBJC_ARRAY_LITERAL;
 930 }
 931
 932 void ASTStmtWriter::VisitObjCDictionaryLiteral(ObjCDictionaryLiteral *E) {
 933   VisitExpr(E);
 934   Record.push_back(E->getNumElements());
 935   Record.push_back(E->HasPackExpansions);
 936   for (unsigned i = 0; i < E->getNumElements(); i++) {
 937     ObjCDictionaryElement Element = E->getKeyValueElement(i);
 938     Writer.AddStmt(Element.Key);
 939     Writer.AddStmt(Element.Value);
 940     if (E->HasPackExpansions) {
 941       Writer.AddSourceLocation(Element.EllipsisLoc, Record);
 942       unsigned NumExpansions = 0;
 943       if (Element.NumExpansions)
 944         NumExpansions = *Element.NumExpansions + 1;
 945       Record.push_back(NumExpansions);
 946     }
 947   }
 948
 949   Writer.AddDeclRef(E->getDictWithObjectsMethod(), Record);
 950   Writer.AddSourceRange(E->getSourceRange(), Record);
 951   Code = serialization::EXPR_OBJC_DICTIONARY_LITERAL;
 952 }
 953
 954 void ASTStmtWriter::VisitObjCEncodeExpr(ObjCEncodeExpr *E) {
 955   VisitExpr(E);
 956   Writer.AddTypeSourceInfo(E->getEncodedTypeSourceInfo(), Record);
 957   Writer.AddSourceLocation(E->getAtLoc(), Record);
 958   Writer.AddSourceLocation(E->getRParenLoc(), Record);
 959   Code = serialization::EXPR_OBJC_ENCODE;
 960 }
 961
 962 void ASTStmtWriter::VisitObjCSelectorExpr(ObjCSelectorExpr *E) {
 963   VisitExpr(E);
 964   Writer.AddSelectorRef(E->getSelector(), Record);
 965   Writer.AddSourceLocation(E->getAtLoc(), Record);
 966   Writer.AddSourceLocation(E->getRParenLoc(), Record);
 967   Code = serialization::EXPR_OBJC_SELECTOR_EXPR;
 968 }
 969
 970 void ASTStmtWriter::VisitObjCProtocolExpr(ObjCProtocolExpr *E) {
 971   VisitExpr(E);
 972   Writer.AddDeclRef(E->getProtocol(), Record);
 973   Writer.AddSourceLocation(E->getAtLoc(), Record);
 974   Writer.AddSourceLocation(E->ProtoLoc, Record);
 975   Writer.AddSourceLocation(E->getRParenLoc(), Record);
 976   Code = serialization::EXPR_OBJC_PROTOCOL_EXPR;
 977 }
 978
 979 void ASTStmtWriter::VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
 980   VisitExpr(E);
 981   Writer.AddDeclRef(E->getDecl(), Record);
 982   Writer.AddSourceLocation(E->getLocation(), Record);
 983   Writer.AddSourceLocation(E->getOpLoc(), Record);
 984   Writer.AddStmt(E->getBase());
 985   Record.push_back(E->isArrow());
 986   Record.push_back(E->isFreeIvar());
 987   Code = serialization::EXPR_OBJC_IVAR_REF_EXPR;
 988 }
 989
 990 void ASTStmtWriter::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
 991   VisitExpr(E);
 992   Record.push_back(E->SetterAndMethodRefFlags.getInt());
 993   Record.push_back(E->isImplicitProperty());
 994   if (E->isImplicitProperty()) {
 995     Writer.AddDeclRef(E->getImplicitPropertyGetter(), Record);
 996     Writer.AddDeclRef(E->getImplicitPropertySetter(), Record);
 997   } else {
 998     Writer.AddDeclRef(E->getExplicitProperty(), Record);
 999   }
1000   Writer.AddSourceLocation(E->getLocation(), Record);
1001   Writer.AddSourceLocation(E->getReceiverLocation(), Record);
1002   if (E->isObjectReceiver()) {
1003     Record.push_back(0);
1004     Writer.AddStmt(E->getBase());
1005   } else if (E->isSuperReceiver()) {
1006     Record.push_back(1);
1007     Writer.AddTypeRef(E->getSuperReceiverType(), Record);
1008   } else {
1009     Record.push_back(2);
1010     Writer.AddDeclRef(E->getClassReceiver(), Record);
1011   }
1012
1013   Code = serialization::EXPR_OBJC_PROPERTY_REF_EXPR;
1014 }
1015
1016 void ASTStmtWriter::VisitObjCSubscriptRefExpr(ObjCSubscriptRefExpr *E) {
1017   VisitExpr(E);
1018   Writer.AddSourceLocation(E->getRBracket(), Record);
1019   Writer.AddStmt(E->getBaseExpr());
1020   Writer.AddStmt(E->getKeyExpr());
1021   Writer.AddDeclRef(E->getAtIndexMethodDecl(), Record);
1022   Writer.AddDeclRef(E->setAtIndexMethodDecl(), Record);
1023
1024   Code = serialization::EXPR_OBJC_SUBSCRIPT_REF_EXPR;
1025 }
1026
1027 void ASTStmtWriter::VisitObjCMessageExpr(ObjCMessageExpr *E) {
1028   VisitExpr(E);
1029   Record.push_back(E->getNumArgs());
1030   Record.push_back(E->getNumStoredSelLocs());
1031   Record.push_back(E->SelLocsKind);
1032   Record.push_back(E->isDelegateInitCall());
1033   Record.push_back(E->IsImplicit);
1034   Record.push_back((unsigned)E->getReceiverKind()); // FIXME: stable encoding
1035   switch (E->getReceiverKind()) {
1036   case ObjCMessageExpr::Instance:
1037     Writer.AddStmt(E->getInstanceReceiver());
1038     break;
1039
1040   case ObjCMessageExpr::Class:
1041     Writer.AddTypeSourceInfo(E->getClassReceiverTypeInfo(), Record);
1042     break;
1043
1044   case ObjCMessageExpr::SuperClass:
1045   case ObjCMessageExpr::SuperInstance:
1046     Writer.AddTypeRef(E->getSuperType(), Record);
1047     Writer.AddSourceLocation(E->getSuperLoc(), Record);
1048     break;
1049   }
1050
1051   if (E->getMethodDecl()) {
1052     Record.push_back(1);
1053     Writer.AddDeclRef(E->getMethodDecl(), Record);
1054   } else {
1055     Record.push_back(0);
1056     Writer.AddSelectorRef(E->getSelector(), Record);
1057   }
1058
1059   Writer.AddSourceLocation(E->getLeftLoc(), Record);
1060   Writer.AddSourceLocation(E->getRightLoc(), Record);
1061
1062   for (CallExpr::arg_iterator Arg = E->arg_begin(), ArgEnd = E->arg_end();
1063        Arg != ArgEnd; ++Arg)
1064     Writer.AddStmt(*Arg);
1065
1066   SourceLocation *Locs = E->getStoredSelLocs();
1067   for (unsigned i = 0, e = E->getNumStoredSelLocs(); i != e; ++i)
1068     Writer.AddSourceLocation(Locs[i], Record);
1069
1070   Code = serialization::EXPR_OBJC_MESSAGE_EXPR;
1071 }
1072
1073 void ASTStmtWriter::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) {
1074   VisitStmt(S);
1075   Writer.AddStmt(S->getElement());
1076   Writer.AddStmt(S->getCollection());
1077   Writer.AddStmt(S->getBody());
1078   Writer.AddSourceLocation(S->getForLoc(), Record);
1079   Writer.AddSourceLocation(S->getRParenLoc(), Record);
1080   Code = serialization::STMT_OBJC_FOR_COLLECTION;
1081 }
1082
1083 void ASTStmtWriter::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) {
1084   Writer.AddStmt(S->getCatchBody());
1085   Writer.AddDeclRef(S->getCatchParamDecl(), Record);
1086   Writer.AddSourceLocation(S->getAtCatchLoc(), Record);
1087   Writer.AddSourceLocation(S->getRParenLoc(), Record);
1088   Code = serialization::STMT_OBJC_CATCH;
1089 }
1090
1091 void ASTStmtWriter::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
1092   Writer.AddStmt(S->getFinallyBody());
1093   Writer.AddSourceLocation(S->getAtFinallyLoc(), Record);
1094   Code = serialization::STMT_OBJC_FINALLY;
1095 }
1096
1097 void ASTStmtWriter::VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S) {
1098   Writer.AddStmt(S->getSubStmt());
1099   Writer.AddSourceLocation(S->getAtLoc(), Record);
1100   Code = serialization::STMT_OBJC_AUTORELEASE_POOL;
1101 }
1102
1103 void ASTStmtWriter::VisitObjCAtTryStmt(ObjCAtTryStmt *S) {
1104   Record.push_back(S->getNumCatchStmts());
1105   Record.push_back(S->getFinallyStmt() != nullptr);
1106   Writer.AddStmt(S->getTryBody());
1107   for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I)
1108     Writer.AddStmt(S->getCatchStmt(I));
1109   if (S->getFinallyStmt())
1110     Writer.AddStmt(S->getFinallyStmt());
1111   Writer.AddSourceLocation(S->getAtTryLoc(), Record);
1112   Code = serialization::STMT_OBJC_AT_TRY;
1113 }
1114
1115 void ASTStmtWriter::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S) {
1116   Writer.AddStmt(S->getSynchExpr());
1117   Writer.AddStmt(S->getSynchBody());
1118   Writer.AddSourceLocation(S->getAtSynchronizedLoc(), Record);
1119   Code = serialization::STMT_OBJC_AT_SYNCHRONIZED;
1120 }
1121
1122 void ASTStmtWriter::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) {
1123   Writer.AddStmt(S->getThrowExpr());
1124   Writer.AddSourceLocation(S->getThrowLoc(), Record);
1125   Code = serialization::STMT_OBJC_AT_THROW;
1126 }
1127
1128 void ASTStmtWriter::VisitObjCBoolLiteralExpr(ObjCBoolLiteralExpr *E) {
1129   VisitExpr(E);
1130   Record.push_back(E->getValue());
1131   Writer.AddSourceLocation(E->getLocation(), Record);
1132   Code = serialization::EXPR_OBJC_BOOL_LITERAL;
1133 }
1134
1135 //===----------------------------------------------------------------------===//
1136 // C++ Expressions and Statements.
1137 //===----------------------------------------------------------------------===//
1138
1139 void ASTStmtWriter::VisitCXXCatchStmt(CXXCatchStmt *S) {
1140   VisitStmt(S);
1141   Writer.AddSourceLocation(S->getCatchLoc(), Record);
1142   Writer.AddDeclRef(S->getExceptionDecl(), Record);
1143   Writer.AddStmt(S->getHandlerBlock());
1144   Code = serialization::STMT_CXX_CATCH;
1145 }
1146
1147 void ASTStmtWriter::VisitCXXTryStmt(CXXTryStmt *S) {
1148   VisitStmt(S);
1149   Record.push_back(S->getNumHandlers());
1150   Writer.AddSourceLocation(S->getTryLoc(), Record);
1151   Writer.AddStmt(S->getTryBlock());
1152   for (unsigned i = 0, e = S->getNumHandlers(); i != e; ++i)
1153     Writer.AddStmt(S->getHandler(i));
1154   Code = serialization::STMT_CXX_TRY;
1155 }
1156
1157 void ASTStmtWriter::VisitCXXForRangeStmt(CXXForRangeStmt *S) {
1158   VisitStmt(S);
1159   Writer.AddSourceLocation(S->getForLoc(), Record);
1160   Writer.AddSourceLocation(S->getCoawaitLoc(), Record);
1161   Writer.AddSourceLocation(S->getColonLoc(), Record);
1162   Writer.AddSourceLocation(S->getRParenLoc(), Record);
1163   Writer.AddStmt(S->getRangeStmt());
1164   Writer.AddStmt(S->getBeginEndStmt());
1165   Writer.AddStmt(S->getCond());
1166   Writer.AddStmt(S->getInc());
1167   Writer.AddStmt(S->getLoopVarStmt());
1168   Writer.AddStmt(S->getBody());
1169   Code = serialization::STMT_CXX_FOR_RANGE;
1170 }
1171
1172 void ASTStmtWriter::VisitMSDependentExistsStmt(MSDependentExistsStmt *S) {
1173   VisitStmt(S);
1174   Writer.AddSourceLocation(S->getKeywordLoc(), Record);
1175   Record.push_back(S->isIfExists());
1176   Writer.AddNestedNameSpecifierLoc(S->getQualifierLoc(), Record);
1177   Writer.AddDeclarationNameInfo(S->getNameInfo(), Record);
1178   Writer.AddStmt(S->getSubStmt());
1179   Code = serialization::STMT_MS_DEPENDENT_EXISTS;
1180 }
1181
1182 void ASTStmtWriter::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
1183   VisitCallExpr(E);
1184   Record.push_back(E->getOperator());
1185   Writer.AddSourceRange(E->Range, Record);
1186   Record.push_back(E->isFPContractable());
1187   Code = serialization::EXPR_CXX_OPERATOR_CALL;
1188 }
1189
1190 void ASTStmtWriter::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
1191   VisitCallExpr(E);
1192   Code = serialization::EXPR_CXX_MEMBER_CALL;
1193 }
1194
1195 void ASTStmtWriter::VisitCXXConstructExpr(CXXConstructExpr *E) {
1196   VisitExpr(E);
1197   Record.push_back(E->getNumArgs());
1198   for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
1199     Writer.AddStmt(E->getArg(I));
1200   Writer.AddDeclRef(E->getConstructor(), Record);
1201   Writer.AddSourceLocation(E->getLocation(), Record);
1202   Record.push_back(E->isElidable());
1203   Record.push_back(E->hadMultipleCandidates());
1204   Record.push_back(E->isListInitialization());
1205   Record.push_back(E->isStdInitListInitialization());
1206   Record.push_back(E->requiresZeroInitialization());
1207   Record.push_back(E->getConstructionKind()); // FIXME: stable encoding
1208   Writer.AddSourceRange(E->getParenOrBraceRange(), Record);
1209   Code = serialization::EXPR_CXX_CONSTRUCT;
1210 }
1211
1212 void ASTStmtWriter::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E) {
1213   VisitCXXConstructExpr(E);
1214   Writer.AddTypeSourceInfo(E->getTypeSourceInfo(), Record);
1215   Code = serialization::EXPR_CXX_TEMPORARY_OBJECT;
1216 }
1217
1218 void ASTStmtWriter::VisitLambdaExpr(LambdaExpr *E) {
1219   VisitExpr(E);
1220   Record.push_back(E->NumCaptures);
1221   unsigned NumArrayIndexVars = 0;
1222   if (E->HasArrayIndexVars)
1223     NumArrayIndexVars = E->getArrayIndexStarts()[E->NumCaptures];
1224   Record.push_back(NumArrayIndexVars);
1225   Writer.AddSourceRange(E->IntroducerRange, Record);
1226   Record.push_back(E->CaptureDefault); // FIXME: stable encoding
1227   Writer.AddSourceLocation(E->CaptureDefaultLoc, Record);
1228   Record.push_back(E->ExplicitParams);
1229   Record.push_back(E->ExplicitResultType);
1230   Writer.AddSourceLocation(E->ClosingBrace, Record);
1231
1232   // Add capture initializers.
1233   for (LambdaExpr::capture_init_iterator C = E->capture_init_begin(),
1234                                       CEnd = E->capture_init_end();
1235        C != CEnd; ++C) {
1236     Writer.AddStmt(*C);
1237   }
1238
1239   // Add array index variables, if any.
1240   if (NumArrayIndexVars) {
1241     Record.append(E->getArrayIndexStarts(),
1242                   E->getArrayIndexStarts() + E->NumCaptures + 1);
1243     VarDecl **ArrayIndexVars = E->getArrayIndexVars();
1244     for (unsigned I = 0; I != NumArrayIndexVars; ++I)
1245       Writer.AddDeclRef(ArrayIndexVars[I], Record);
1246   }
1247
1248   Code = serialization::EXPR_LAMBDA;
1249 }
1250
1251 void ASTStmtWriter::VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E) {
1252   VisitExpr(E);
1253   Writer.AddStmt(E->getSubExpr());
1254   Code = serialization::EXPR_CXX_STD_INITIALIZER_LIST;
1255 }
1256
1257 void ASTStmtWriter::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) {
1258   VisitExplicitCastExpr(E);
1259   Writer.AddSourceRange(SourceRange(E->getOperatorLoc(), E->getRParenLoc()),
1260                         Record);
1261   Writer.AddSourceRange(E->getAngleBrackets(), Record);
1262 }
1263
1264 void ASTStmtWriter::VisitCXXStaticCastExpr(CXXStaticCastExpr *E) {
1265   VisitCXXNamedCastExpr(E);
1266   Code = serialization::EXPR_CXX_STATIC_CAST;
1267 }
1268
1269 void ASTStmtWriter::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *E) {
1270   VisitCXXNamedCastExpr(E);
1271   Code = serialization::EXPR_CXX_DYNAMIC_CAST;
1272 }
1273
1274 void ASTStmtWriter::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *E) {
1275   VisitCXXNamedCastExpr(E);
1276   Code = serialization::EXPR_CXX_REINTERPRET_CAST;
1277 }
1278
1279 void ASTStmtWriter::VisitCXXConstCastExpr(CXXConstCastExpr *E) {
1280   VisitCXXNamedCastExpr(E);
1281   Code = serialization::EXPR_CXX_CONST_CAST;
1282 }
1283
1284 void ASTStmtWriter::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E) {
1285   VisitExplicitCastExpr(E);
1286   Writer.AddSourceLocation(E->getLParenLoc(), Record);
1287   Writer.AddSourceLocation(E->getRParenLoc(), Record);
1288   Code = serialization::EXPR_CXX_FUNCTIONAL_CAST;
1289 }
1290
1291 void ASTStmtWriter::VisitUserDefinedLiteral(UserDefinedLiteral *E) {
1292   VisitCallExpr(E);
1293   Writer.AddSourceLocation(E->UDSuffixLoc, Record);
1294   Code = serialization::EXPR_USER_DEFINED_LITERAL;
1295 }
1296
1297 void ASTStmtWriter::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
1298   VisitExpr(E);
1299   Record.push_back(E->getValue());
1300   Writer.AddSourceLocation(E->getLocation(), Record);
1301   Code = serialization::EXPR_CXX_BOOL_LITERAL;
1302 }
1303
1304 void ASTStmtWriter::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) {
1305   VisitExpr(E);
1306   Writer.AddSourceLocation(E->getLocation(), Record);
1307   Code = serialization::EXPR_CXX_NULL_PTR_LITERAL;
1308 }
1309
1310 void ASTStmtWriter::VisitCXXTypeidExpr(CXXTypeidExpr *E) {
1311   VisitExpr(E);
1312   Writer.AddSourceRange(E->getSourceRange(), Record);
1313   if (E->isTypeOperand()) {
1314     Writer.AddTypeSourceInfo(E->getTypeOperandSourceInfo(), Record);
1315     Code = serialization::EXPR_CXX_TYPEID_TYPE;
1316   } else {
1317     Writer.AddStmt(E->getExprOperand());
1318     Code = serialization::EXPR_CXX_TYPEID_EXPR;
1319   }
1320 }
1321
1322 void ASTStmtWriter::VisitCXXThisExpr(CXXThisExpr *E) {
1323   VisitExpr(E);
1324   Writer.AddSourceLocation(E->getLocation(), Record);
1325   Record.push_back(E->isImplicit());
1326   Code = serialization::EXPR_CXX_THIS;
1327 }
1328
1329 void ASTStmtWriter::VisitCXXThrowExpr(CXXThrowExpr *E) {
1330   VisitExpr(E);
1331   Writer.AddSourceLocation(E->getThrowLoc(), Record);
1332   Writer.AddStmt(E->getSubExpr());
1333   Record.push_back(E->isThrownVariableInScope());
1334   Code = serialization::EXPR_CXX_THROW;
1335 }
1336
1337 void ASTStmtWriter::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
1338   VisitExpr(E);
1339   Writer.AddDeclRef(E->getParam(), Record);
1340   Writer.AddSourceLocation(E->getUsedLocation(), Record);
1341   Code = serialization::EXPR_CXX_DEFAULT_ARG;
1342 }
1343
1344 void ASTStmtWriter::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E) {
1345   VisitExpr(E);
1346   Writer.AddDeclRef(E->getField(), Record);
1347   Writer.AddSourceLocation(E->getExprLoc(), Record);
1348   Code = serialization::EXPR_CXX_DEFAULT_INIT;
1349 }
1350
1351 void ASTStmtWriter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
1352   VisitExpr(E);
1353   Writer.AddCXXTemporary(E->getTemporary(), Record);
1354   Writer.AddStmt(E->getSubExpr());
1355   Code = serialization::EXPR_CXX_BIND_TEMPORARY;
1356 }
1357
1358 void ASTStmtWriter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
1359   VisitExpr(E);
1360   Writer.AddTypeSourceInfo(E->getTypeSourceInfo(), Record);
1361   Writer.AddSourceLocation(E->getRParenLoc(), Record);
1362   Code = serialization::EXPR_CXX_SCALAR_VALUE_INIT;
1363 }
1364
1365 void ASTStmtWriter::VisitCXXNewExpr(CXXNewExpr *E) {
1366   VisitExpr(E);
1367   Record.push_back(E->isGlobalNew());
1368   Record.push_back(E->isArray());
1369   Record.push_back(E->doesUsualArrayDeleteWantSize());
1370   Record.push_back(E->getNumPlacementArgs());
1371   Record.push_back(E->StoredInitializationStyle);
1372   Writer.AddDeclRef(E->getOperatorNew(), Record);
1373   Writer.AddDeclRef(E->getOperatorDelete(), Record);
1374   Writer.AddTypeSourceInfo(E->getAllocatedTypeSourceInfo(), Record);
1375   Writer.AddSourceRange(E->getTypeIdParens(), Record);
1376   Writer.AddSourceRange(E->getSourceRange(), Record);
1377   Writer.AddSourceRange(E->getDirectInitRange(), Record);
1378   for (CXXNewExpr::arg_iterator I = E->raw_arg_begin(), e = E->raw_arg_end();
1379        I != e; ++I)
1380     Writer.AddStmt(*I);
1381
1382   Code = serialization::EXPR_CXX_NEW;
1383 }
1384
1385 void ASTStmtWriter::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
1386   VisitExpr(E);
1387   Record.push_back(E->isGlobalDelete());
1388   Record.push_back(E->isArrayForm());
1389   Record.push_back(E->isArrayFormAsWritten());
1390   Record.push_back(E->doesUsualArrayDeleteWantSize());
1391   Writer.AddDeclRef(E->getOperatorDelete(), Record);
1392   Writer.AddStmt(E->getArgument());
1393   Writer.AddSourceLocation(E->getSourceRange().getBegin(), Record);
1394
1395   Code = serialization::EXPR_CXX_DELETE;
1396 }
1397
1398 void ASTStmtWriter::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) {
1399   VisitExpr(E);
1400
1401   Writer.AddStmt(E->getBase());
1402   Record.push_back(E->isArrow());
1403   Writer.AddSourceLocation(E->getOperatorLoc(), Record);
1404   Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record);
1405   Writer.AddTypeSourceInfo(E->getScopeTypeInfo(), Record);
1406   Writer.AddSourceLocation(E->getColonColonLoc(), Record);
1407   Writer.AddSourceLocation(E->getTildeLoc(), Record);
1408
1409   // PseudoDestructorTypeStorage.
1410   Writer.AddIdentifierRef(E->getDestroyedTypeIdentifier(), Record);
1411   if (E->getDestroyedTypeIdentifier())
1412     Writer.AddSourceLocation(E->getDestroyedTypeLoc(), Record);
1413   else
1414     Writer.AddTypeSourceInfo(E->getDestroyedTypeInfo(), Record);
1415
1416   Code = serialization::EXPR_CXX_PSEUDO_DESTRUCTOR;
1417 }
1418
1419 void ASTStmtWriter::VisitExprWithCleanups(ExprWithCleanups *E) {
1420   VisitExpr(E);
1421   Record.push_back(E->getNumObjects());
1422   for (unsigned i = 0, e = E->getNumObjects(); i != e; ++i)
1423     Writer.AddDeclRef(E->getObject(i), Record);
1424
1425   Writer.AddStmt(E->getSubExpr());
1426   Code = serialization::EXPR_EXPR_WITH_CLEANUPS;
1427 }
1428
1429 void
1430 ASTStmtWriter::VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E){
1431   VisitExpr(E);
1432
1433   // Don't emit anything here, HasTemplateKWAndArgsInfo must be
1434   // emitted first.
1435
1436   Record.push_back(E->HasTemplateKWAndArgsInfo);
1437   if (E->HasTemplateKWAndArgsInfo) {
1438     const ASTTemplateKWAndArgsInfo &ArgInfo =
1439         *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>();
1440     Record.push_back(ArgInfo.NumTemplateArgs);
1441     AddTemplateKWAndArgsInfo(ArgInfo,
1442                              E->getTrailingObjects<TemplateArgumentLoc>());
1443   }
1444
1445   if (!E->isImplicitAccess())
1446     Writer.AddStmt(E->getBase());
1447   else
1448     Writer.AddStmt(nullptr);
1449   Writer.AddTypeRef(E->getBaseType(), Record);
1450   Record.push_back(E->isArrow());
1451   Writer.AddSourceLocation(E->getOperatorLoc(), Record);
1452   Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record);
1453   Writer.AddDeclRef(E->getFirstQualifierFoundInScope(), Record);
1454   Writer.AddDeclarationNameInfo(E->MemberNameInfo, Record);
1455   Code = serialization::EXPR_CXX_DEPENDENT_SCOPE_MEMBER;
1456 }
1457
1458 void
1459 ASTStmtWriter::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) {
1460   VisitExpr(E);
1461
1462   // Don't emit anything here, HasTemplateKWAndArgsInfo must be
1463   // emitted first.
1464
1465   Record.push_back(E->HasTemplateKWAndArgsInfo);
1466   if (E->HasTemplateKWAndArgsInfo) {
1467     const ASTTemplateKWAndArgsInfo &ArgInfo =
1468         *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>();
1469     Record.push_back(ArgInfo.NumTemplateArgs);
1470     AddTemplateKWAndArgsInfo(ArgInfo,
1471                              E->getTrailingObjects<TemplateArgumentLoc>());
1472   }
1473
1474   Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record);
1475   Writer.AddDeclarationNameInfo(E->NameInfo, Record);
1476   Code = serialization::EXPR_CXX_DEPENDENT_SCOPE_DECL_REF;
1477 }
1478
1479 void
1480 ASTStmtWriter::VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E) {
1481   VisitExpr(E);
1482   Record.push_back(E->arg_size());
1483   for (CXXUnresolvedConstructExpr::arg_iterator
1484          ArgI = E->arg_begin(), ArgE = E->arg_end(); ArgI != ArgE; ++ArgI)
1485     Writer.AddStmt(*ArgI);
1486   Writer.AddTypeSourceInfo(E->getTypeSourceInfo(), Record);
1487   Writer.AddSourceLocation(E->getLParenLoc(), Record);
1488   Writer.AddSourceLocation(E->getRParenLoc(), Record);
1489   Code = serialization::EXPR_CXX_UNRESOLVED_CONSTRUCT;
1490 }
1491
1492 void ASTStmtWriter::VisitOverloadExpr(OverloadExpr *E) {
1493   VisitExpr(E);
1494
1495   // Don't emit anything here, HasTemplateKWAndArgsInfo must be
1496   // emitted first.
1497
1498   Record.push_back(E->HasTemplateKWAndArgsInfo);
1499   if (E->HasTemplateKWAndArgsInfo) {
1500     const ASTTemplateKWAndArgsInfo &ArgInfo =
1501         *E->getTrailingASTTemplateKWAndArgsInfo();
1502     Record.push_back(ArgInfo.NumTemplateArgs);
1503     AddTemplateKWAndArgsInfo(ArgInfo, E->getTrailingTemplateArgumentLoc());
1504   }
1505
1506   Record.push_back(E->getNumDecls());
1507   for (OverloadExpr::decls_iterator
1508          OvI = E->decls_begin(), OvE = E->decls_end(); OvI != OvE; ++OvI) {
1509     Writer.AddDeclRef(OvI.getDecl(), Record);
1510     Record.push_back(OvI.getAccess());
1511   }
1512
1513   Writer.AddDeclarationNameInfo(E->NameInfo, Record);
1514   Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record);
1515 }
1516
1517 void ASTStmtWriter::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) {
1518   VisitOverloadExpr(E);
1519   Record.push_back(E->isArrow());
1520   Record.push_back(E->hasUnresolvedUsing());
1521   Writer.AddStmt(!E->isImplicitAccess() ? E->getBase() : nullptr);
1522   Writer.AddTypeRef(E->getBaseType(), Record);
1523   Writer.AddSourceLocation(E->getOperatorLoc(), Record);
1524   Code = serialization::EXPR_CXX_UNRESOLVED_MEMBER;
1525 }
1526
1527 void ASTStmtWriter::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) {
1528   VisitOverloadExpr(E);
1529   Record.push_back(E->requiresADL());
1530   Record.push_back(E->isOverloaded());
1531   Writer.AddDeclRef(E->getNamingClass(), Record);
1532   Code = serialization::EXPR_CXX_UNRESOLVED_LOOKUP;
1533 }
1534
1535 void ASTStmtWriter::VisitTypeTraitExpr(TypeTraitExpr *E) {
1536   VisitExpr(E);
1537   Record.push_back(E->TypeTraitExprBits.NumArgs);
1538   Record.push_back(E->TypeTraitExprBits.Kind); // FIXME: Stable encoding
1539   Record.push_back(E->TypeTraitExprBits.Value);
1540   Writer.AddSourceRange(E->getSourceRange(), Record);
1541   for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
1542     Writer.AddTypeSourceInfo(E->getArg(I), Record);
1543   Code = serialization::EXPR_TYPE_TRAIT;
1544 }
1545
1546 void ASTStmtWriter::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
1547   VisitExpr(E);
1548   Record.push_back(E->getTrait());
1549   Record.push_back(E->getValue());
1550   Writer.AddSourceRange(E->getSourceRange(), Record);
1551   Writer.AddTypeSourceInfo(E->getQueriedTypeSourceInfo(), Record);
1552   Code = serialization::EXPR_ARRAY_TYPE_TRAIT;
1553 }
1554
1555 void ASTStmtWriter::VisitExpressionTraitExpr(ExpressionTraitExpr *E) {
1556   VisitExpr(E);
1557   Record.push_back(E->getTrait());
1558   Record.push_back(E->getValue());
1559   Writer.AddSourceRange(E->getSourceRange(), Record);
1560   Writer.AddStmt(E->getQueriedExpression());
1561   Code = serialization::EXPR_CXX_EXPRESSION_TRAIT;
1562 }
1563
1564 void ASTStmtWriter::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) {
1565   VisitExpr(E);
1566   Record.push_back(E->getValue());
1567   Writer.AddSourceRange(E->getSourceRange(), Record);
1568   Writer.AddStmt(E->getOperand());
1569   Code = serialization::EXPR_CXX_NOEXCEPT;
1570 }
1571
1572 void ASTStmtWriter::VisitPackExpansionExpr(PackExpansionExpr *E) {
1573   VisitExpr(E);
1574   Writer.AddSourceLocation(E->getEllipsisLoc(), Record);
1575   Record.push_back(E->NumExpansions);
1576   Writer.AddStmt(E->getPattern());
1577   Code = serialization::EXPR_PACK_EXPANSION;
1578 }
1579
1580 void ASTStmtWriter::VisitSizeOfPackExpr(SizeOfPackExpr *E) {
1581   VisitExpr(E);
1582   Record.push_back(E->isPartiallySubstituted() ? E->getPartialArguments().size()
1583                                                : 0);
1584   Writer.AddSourceLocation(E->OperatorLoc, Record);
1585   Writer.AddSourceLocation(E->PackLoc, Record);
1586   Writer.AddSourceLocation(E->RParenLoc, Record);
1587   Writer.AddDeclRef(E->Pack, Record);
1588   if (E->isPartiallySubstituted()) {
1589     for (const auto &TA : E->getPartialArguments())
1590       Writer.AddTemplateArgument(TA, Record);
1591   } else if (!E->isValueDependent()) {
1592     Record.push_back(E->getPackLength());
1593   }
1594   Code = serialization::EXPR_SIZEOF_PACK;
1595 }
1596
1597 void ASTStmtWriter::VisitSubstNonTypeTemplateParmExpr(
1598                                               SubstNonTypeTemplateParmExpr *E) {
1599   VisitExpr(E);
1600   Writer.AddDeclRef(E->getParameter(), Record);
1601   Writer.AddSourceLocation(E->getNameLoc(), Record);
1602   Writer.AddStmt(E->getReplacement());
1603   Code = serialization::EXPR_SUBST_NON_TYPE_TEMPLATE_PARM;
1604 }
1605
1606 void ASTStmtWriter::VisitSubstNonTypeTemplateParmPackExpr(
1607                                           SubstNonTypeTemplateParmPackExpr *E) {
1608   VisitExpr(E);
1609   Writer.AddDeclRef(E->getParameterPack(), Record);
1610   Writer.AddTemplateArgument(E->getArgumentPack(), Record);
1611   Writer.AddSourceLocation(E->getParameterPackLocation(), Record);
1612   Code = serialization::EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK;
1613 }
1614
1615 void ASTStmtWriter::VisitFunctionParmPackExpr(FunctionParmPackExpr *E) {
1616   VisitExpr(E);
1617   Record.push_back(E->getNumExpansions());
1618   Writer.AddDeclRef(E->getParameterPack(), Record);
1619   Writer.AddSourceLocation(E->getParameterPackLocation(), Record);
1620   for (FunctionParmPackExpr::iterator I = E->begin(), End = E->end();
1621        I != End; ++I)
1622     Writer.AddDeclRef(*I, Record);
1623   Code = serialization::EXPR_FUNCTION_PARM_PACK;
1624 }
1625
1626 void ASTStmtWriter::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) {
1627   VisitExpr(E);
1628   Writer.AddStmt(E->getTemporary());
1629   Writer.AddDeclRef(E->getExtendingDecl(), Record);
1630   Record.push_back(E->getManglingNumber());
1631   Code = serialization::EXPR_MATERIALIZE_TEMPORARY;
1632 }
1633
1634 void ASTStmtWriter::VisitCXXFoldExpr(CXXFoldExpr *E) {
1635   VisitExpr(E);
1636   Writer.AddSourceLocation(E->LParenLoc, Record);
1637   Writer.AddSourceLocation(E->EllipsisLoc, Record);
1638   Writer.AddSourceLocation(E->RParenLoc, Record);
1639   Writer.AddStmt(E->SubExprs[0]);
1640   Writer.AddStmt(E->SubExprs[1]);
1641   Record.push_back(E->Opcode);
1642   Code = serialization::EXPR_CXX_FOLD;
1643 }
1644
1645 void ASTStmtWriter::VisitOpaqueValueExpr(OpaqueValueExpr *E) {
1646   VisitExpr(E);
1647   Writer.AddStmt(E->getSourceExpr());
1648   Writer.AddSourceLocation(E->getLocation(), Record);
1649   Code = serialization::EXPR_OPAQUE_VALUE;
1650 }
1651
1652 void ASTStmtWriter::VisitTypoExpr(TypoExpr *E) {
1653   VisitExpr(E);
1654   // TODO: Figure out sane writer behavior for a TypoExpr, if necessary
1655   assert(false && "Cannot write TypoExpr nodes");
1656 }
1657
1658 //===----------------------------------------------------------------------===//
1659 // CUDA Expressions and Statements.
1660 //===----------------------------------------------------------------------===//
1661
1662 void ASTStmtWriter::VisitCUDAKernelCallExpr(CUDAKernelCallExpr *E) {
1663   VisitCallExpr(E);
1664   Writer.AddStmt(E->getConfig());
1665   Code = serialization::EXPR_CUDA_KERNEL_CALL;
1666 }
1667
1668 //===----------------------------------------------------------------------===//
1669 // OpenCL Expressions and Statements.
1670 //===----------------------------------------------------------------------===//
1671 void ASTStmtWriter::VisitAsTypeExpr(AsTypeExpr *E) {
1672   VisitExpr(E);
1673   Writer.AddSourceLocation(E->getBuiltinLoc(), Record);
1674   Writer.AddSourceLocation(E->getRParenLoc(), Record);
1675   Writer.AddStmt(E->getSrcExpr());
1676   Code = serialization::EXPR_ASTYPE;
1677 }
1678
1679 //===----------------------------------------------------------------------===//
1680 // Microsoft Expressions and Statements.
1681 //===----------------------------------------------------------------------===//
1682 void ASTStmtWriter::VisitMSPropertyRefExpr(MSPropertyRefExpr *E) {
1683   VisitExpr(E);
1684   Record.push_back(E->isArrow());
1685   Writer.AddStmt(E->getBaseExpr());
1686   Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record);
1687   Writer.AddSourceLocation(E->getMemberLoc(), Record);
1688   Writer.AddDeclRef(E->getPropertyDecl(), Record);
1689   Code = serialization::EXPR_CXX_PROPERTY_REF_EXPR;
1690 }
1691
1692 void ASTStmtWriter::VisitMSPropertySubscriptExpr(MSPropertySubscriptExpr *E) {
1693   VisitExpr(E);
1694   Writer.AddStmt(E->getBase());
1695   Writer.AddStmt(E->getIdx());
1696   Writer.AddSourceLocation(E->getRBracketLoc(), Record);
1697   Code = serialization::EXPR_CXX_PROPERTY_SUBSCRIPT_EXPR;
1698 }
1699
1700 void ASTStmtWriter::VisitCXXUuidofExpr(CXXUuidofExpr *E) {
1701   VisitExpr(E);
1702   Writer.AddSourceRange(E->getSourceRange(), Record);
1703   if (E->isTypeOperand()) {
1704     Writer.AddTypeSourceInfo(E->getTypeOperandSourceInfo(), Record);
1705     Code = serialization::EXPR_CXX_UUIDOF_TYPE;
1706   } else {
1707     Writer.AddStmt(E->getExprOperand());
1708     Code = serialization::EXPR_CXX_UUIDOF_EXPR;
1709   }
1710 }
1711
1712 void ASTStmtWriter::VisitSEHExceptStmt(SEHExceptStmt *S) {
1713   VisitStmt(S);
1714   Writer.AddSourceLocation(S->getExceptLoc(), Record);
1715   Writer.AddStmt(S->getFilterExpr());
1716   Writer.AddStmt(S->getBlock());
1717   Code = serialization::STMT_SEH_EXCEPT;
1718 }
1719
1720 void ASTStmtWriter::VisitSEHFinallyStmt(SEHFinallyStmt *S) {
1721   VisitStmt(S);
1722   Writer.AddSourceLocation(S->getFinallyLoc(), Record);
1723   Writer.AddStmt(S->getBlock());
1724   Code = serialization::STMT_SEH_FINALLY;
1725 }
1726
1727 void ASTStmtWriter::VisitSEHTryStmt(SEHTryStmt *S) {
1728   VisitStmt(S);
1729   Record.push_back(S->getIsCXXTry());
1730   Writer.AddSourceLocation(S->getTryLoc(), Record);
1731   Writer.AddStmt(S->getTryBlock());
1732   Writer.AddStmt(S->getHandler());
1733   Code = serialization::STMT_SEH_TRY;
1734 }
1735
1736 void ASTStmtWriter::VisitSEHLeaveStmt(SEHLeaveStmt *S) {
1737   VisitStmt(S);
1738   Writer.AddSourceLocation(S->getLeaveLoc(), Record);
1739   Code = serialization::STMT_SEH_LEAVE;
1740 }
1741
1742 //===----------------------------------------------------------------------===//
1743 // OpenMP Clauses.
1744 //===----------------------------------------------------------------------===//
1745
1746 namespace clang {
1747 class OMPClauseWriter : public OMPClauseVisitor<OMPClauseWriter> {
1748   ASTStmtWriter *Writer;
1749   ASTWriter::RecordData &Record;
1750 public:
1751   OMPClauseWriter(ASTStmtWriter *W, ASTWriter::RecordData &Record)
1752     : Writer(W), Record(Record) { }
1753 #define OPENMP_CLAUSE(Name, Class)    \
1754   void Visit##Class(Class *S);
1755 #include "clang/Basic/OpenMPKinds.def"
1756   void writeClause(OMPClause *C);
1757 };
1758 }
1759
1760 void OMPClauseWriter::writeClause(OMPClause *C) {
1761   Record.push_back(C->getClauseKind());
1762   Visit(C);
1763   Writer->Writer.AddSourceLocation(C->getLocStart(), Record);
1764   Writer->Writer.AddSourceLocation(C->getLocEnd(), Record);
1765 }
1766
1767 void OMPClauseWriter::VisitOMPIfClause(OMPIfClause *C) {
1768   Record.push_back(C->getNameModifier());
1769   Writer->Writer.AddSourceLocation(C->getNameModifierLoc(), Record);
1770   Writer->Writer.AddSourceLocation(C->getColonLoc(), Record);
1771   Writer->Writer.AddStmt(C->getCondition());
1772   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1773 }
1774
1775 void OMPClauseWriter::VisitOMPFinalClause(OMPFinalClause *C) {
1776   Writer->Writer.AddStmt(C->getCondition());
1777   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1778 }
1779
1780 void OMPClauseWriter::VisitOMPNumThreadsClause(OMPNumThreadsClause *C) {
1781   Writer->Writer.AddStmt(C->getNumThreads());
1782   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1783 }
1784
1785 void OMPClauseWriter::VisitOMPSafelenClause(OMPSafelenClause *C) {
1786   Writer->Writer.AddStmt(C->getSafelen());
1787   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1788 }
1789
1790 void OMPClauseWriter::VisitOMPSimdlenClause(OMPSimdlenClause *C) {
1791   Writer->Writer.AddStmt(C->getSimdlen());
1792   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1793 }
1794
1795 void OMPClauseWriter::VisitOMPCollapseClause(OMPCollapseClause *C) {
1796   Writer->Writer.AddStmt(C->getNumForLoops());
1797   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1798 }
1799
1800 void OMPClauseWriter::VisitOMPDefaultClause(OMPDefaultClause *C) {
1801   Record.push_back(C->getDefaultKind());
1802   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1803   Writer->Writer.AddSourceLocation(C->getDefaultKindKwLoc(), Record);
1804 }
1805
1806 void OMPClauseWriter::VisitOMPProcBindClause(OMPProcBindClause *C) {
1807   Record.push_back(C->getProcBindKind());
1808   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1809   Writer->Writer.AddSourceLocation(C->getProcBindKindKwLoc(), Record);
1810 }
1811
1812 void OMPClauseWriter::VisitOMPScheduleClause(OMPScheduleClause *C) {
1813   Record.push_back(C->getScheduleKind());
1814   Record.push_back(C->getFirstScheduleModifier());
1815   Record.push_back(C->getSecondScheduleModifier());
1816   Writer->Writer.AddStmt(C->getChunkSize());
1817   Writer->Writer.AddStmt(C->getHelperChunkSize());
1818   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1819   Writer->Writer.AddSourceLocation(C->getFirstScheduleModifierLoc(), Record);
1820   Writer->Writer.AddSourceLocation(C->getSecondScheduleModifierLoc(), Record);
1821   Writer->Writer.AddSourceLocation(C->getScheduleKindLoc(), Record);
1822   Writer->Writer.AddSourceLocation(C->getCommaLoc(), Record);
1823 }
1824
1825 void OMPClauseWriter::VisitOMPOrderedClause(OMPOrderedClause *C) {
1826   Writer->Writer.AddStmt(C->getNumForLoops());
1827   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1828 }
1829
1830 void OMPClauseWriter::VisitOMPNowaitClause(OMPNowaitClause *) {}
1831
1832 void OMPClauseWriter::VisitOMPUntiedClause(OMPUntiedClause *) {}
1833
1834 void OMPClauseWriter::VisitOMPMergeableClause(OMPMergeableClause *) {}
1835
1836 void OMPClauseWriter::VisitOMPReadClause(OMPReadClause *) {}
1837
1838 void OMPClauseWriter::VisitOMPWriteClause(OMPWriteClause *) {}
1839
1840 void OMPClauseWriter::VisitOMPUpdateClause(OMPUpdateClause *) {}
1841
1842 void OMPClauseWriter::VisitOMPCaptureClause(OMPCaptureClause *) {}
1843
1844 void OMPClauseWriter::VisitOMPSeqCstClause(OMPSeqCstClause *) {}
1845
1846 void OMPClauseWriter::VisitOMPThreadsClause(OMPThreadsClause *) {}
1847
1848 void OMPClauseWriter::VisitOMPSIMDClause(OMPSIMDClause *) {}
1849
1850 void OMPClauseWriter::VisitOMPNogroupClause(OMPNogroupClause *) {}
1851
1852 void OMPClauseWriter::VisitOMPPrivateClause(OMPPrivateClause *C) {
1853   Record.push_back(C->varlist_size());
1854   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1855   for (auto *VE : C->varlists()) {
1856     Writer->Writer.AddStmt(VE);
1857   }
1858   for (auto *VE : C->private_copies()) {
1859     Writer->Writer.AddStmt(VE);
1860   }
1861 }
1862
1863 void OMPClauseWriter::VisitOMPFirstprivateClause(OMPFirstprivateClause *C) {
1864   Record.push_back(C->varlist_size());
1865   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1866   for (auto *VE : C->varlists()) {
1867     Writer->Writer.AddStmt(VE);
1868   }
1869   for (auto *VE : C->private_copies()) {
1870     Writer->Writer.AddStmt(VE);
1871   }
1872   for (auto *VE : C->inits()) {
1873     Writer->Writer.AddStmt(VE);
1874   }
1875 }
1876
1877 void OMPClauseWriter::VisitOMPLastprivateClause(OMPLastprivateClause *C) {
1878   Record.push_back(C->varlist_size());
1879   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1880   for (auto *VE : C->varlists())
1881     Writer->Writer.AddStmt(VE);
1882   for (auto *E : C->private_copies())
1883     Writer->Writer.AddStmt(E);
1884   for (auto *E : C->source_exprs())
1885     Writer->Writer.AddStmt(E);
1886   for (auto *E : C->destination_exprs())
1887     Writer->Writer.AddStmt(E);
1888   for (auto *E : C->assignment_ops())
1889     Writer->Writer.AddStmt(E);
1890 }
1891
1892 void OMPClauseWriter::VisitOMPSharedClause(OMPSharedClause *C) {
1893   Record.push_back(C->varlist_size());
1894   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1895   for (auto *VE : C->varlists())
1896     Writer->Writer.AddStmt(VE);
1897 }
1898
1899 void OMPClauseWriter::VisitOMPReductionClause(OMPReductionClause *C) {
1900   Record.push_back(C->varlist_size());
1901   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1902   Writer->Writer.AddSourceLocation(C->getColonLoc(), Record);
1903   Writer->Writer.AddNestedNameSpecifierLoc(C->getQualifierLoc(), Record);
1904   Writer->Writer.AddDeclarationNameInfo(C->getNameInfo(), Record);
1905   for (auto *VE : C->varlists())
1906     Writer->Writer.AddStmt(VE);
1907   for (auto *VE : C->privates())
1908     Writer->Writer.AddStmt(VE);
1909   for (auto *E : C->lhs_exprs())
1910     Writer->Writer.AddStmt(E);
1911   for (auto *E : C->rhs_exprs())
1912     Writer->Writer.AddStmt(E);
1913   for (auto *E : C->reduction_ops())
1914     Writer->Writer.AddStmt(E);
1915 }
1916
1917 void OMPClauseWriter::VisitOMPLinearClause(OMPLinearClause *C) {
1918   Record.push_back(C->varlist_size());
1919   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1920   Writer->Writer.AddSourceLocation(C->getColonLoc(), Record);
1921   Record.push_back(C->getModifier());
1922   Writer->Writer.AddSourceLocation(C->getModifierLoc(), Record);
1923   for (auto *VE : C->varlists()) {
1924     Writer->Writer.AddStmt(VE);
1925   }
1926   for (auto *VE : C->privates()) {
1927     Writer->Writer.AddStmt(VE);
1928   }
1929   for (auto *VE : C->inits()) {
1930     Writer->Writer.AddStmt(VE);
1931   }
1932   for (auto *VE : C->updates()) {
1933     Writer->Writer.AddStmt(VE);
1934   }
1935   for (auto *VE : C->finals()) {
1936     Writer->Writer.AddStmt(VE);
1937   }
1938   Writer->Writer.AddStmt(C->getStep());
1939   Writer->Writer.AddStmt(C->getCalcStep());
1940 }
1941
1942 void OMPClauseWriter::VisitOMPAlignedClause(OMPAlignedClause *C) {
1943   Record.push_back(C->varlist_size());
1944   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1945   Writer->Writer.AddSourceLocation(C->getColonLoc(), Record);
1946   for (auto *VE : C->varlists())
1947     Writer->Writer.AddStmt(VE);
1948   Writer->Writer.AddStmt(C->getAlignment());
1949 }
1950
1951 void OMPClauseWriter::VisitOMPCopyinClause(OMPCopyinClause *C) {
1952   Record.push_back(C->varlist_size());
1953   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1954   for (auto *VE : C->varlists())
1955     Writer->Writer.AddStmt(VE);
1956   for (auto *E : C->source_exprs())
1957     Writer->Writer.AddStmt(E);
1958   for (auto *E : C->destination_exprs())
1959     Writer->Writer.AddStmt(E);
1960   for (auto *E : C->assignment_ops())
1961     Writer->Writer.AddStmt(E);
1962 }
1963
1964 void OMPClauseWriter::VisitOMPCopyprivateClause(OMPCopyprivateClause *C) {
1965   Record.push_back(C->varlist_size());
1966   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1967   for (auto *VE : C->varlists())
1968     Writer->Writer.AddStmt(VE);
1969   for (auto *E : C->source_exprs())
1970     Writer->Writer.AddStmt(E);
1971   for (auto *E : C->destination_exprs())
1972     Writer->Writer.AddStmt(E);
1973   for (auto *E : C->assignment_ops())
1974     Writer->Writer.AddStmt(E);
1975 }
1976
1977 void OMPClauseWriter::VisitOMPFlushClause(OMPFlushClause *C) {
1978   Record.push_back(C->varlist_size());
1979   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1980   for (auto *VE : C->varlists())
1981     Writer->Writer.AddStmt(VE);
1982 }
1983
1984 void OMPClauseWriter::VisitOMPDependClause(OMPDependClause *C) {
1985   Record.push_back(C->varlist_size());
1986   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1987   Record.push_back(C->getDependencyKind());
1988   Writer->Writer.AddSourceLocation(C->getDependencyLoc(), Record);
1989   Writer->Writer.AddSourceLocation(C->getColonLoc(), Record);
1990   for (auto *VE : C->varlists())
1991     Writer->Writer.AddStmt(VE);
1992 }
1993
1994 void OMPClauseWriter::VisitOMPDeviceClause(OMPDeviceClause *C) {
1995   Writer->Writer.AddStmt(C->getDevice());
1996   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1997 }
1998
1999 void OMPClauseWriter::VisitOMPMapClause(OMPMapClause *C) {
2000   Record.push_back(C->varlist_size());
2001   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
2002   Record.push_back(C->getMapTypeModifier());
2003   Record.push_back(C->getMapType());
2004   Writer->Writer.AddSourceLocation(C->getMapLoc(), Record);
2005   Writer->Writer.AddSourceLocation(C->getColonLoc(), Record);
2006   for (auto *VE : C->varlists())
2007     Writer->Writer.AddStmt(VE);
2008 }
2009
2010 void OMPClauseWriter::VisitOMPNumTeamsClause(OMPNumTeamsClause *C) {
2011   Writer->Writer.AddStmt(C->getNumTeams());
2012   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
2013 }
2014
2015 void OMPClauseWriter::VisitOMPThreadLimitClause(OMPThreadLimitClause *C) {
2016   Writer->Writer.AddStmt(C->getThreadLimit());
2017   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
2018 }
2019
2020 void OMPClauseWriter::VisitOMPPriorityClause(OMPPriorityClause *C) {
2021   Writer->Writer.AddStmt(C->getPriority());
2022   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
2023 }
2024
2025 void OMPClauseWriter::VisitOMPGrainsizeClause(OMPGrainsizeClause *C) {
2026   Writer->Writer.AddStmt(C->getGrainsize());
2027   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
2028 }
2029
2030 void OMPClauseWriter::VisitOMPNumTasksClause(OMPNumTasksClause *C) {
2031   Writer->Writer.AddStmt(C->getNumTasks());
2032   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
2033 }
2034
2035 void OMPClauseWriter::VisitOMPHintClause(OMPHintClause *C) {
2036   Writer->Writer.AddStmt(C->getHint());
2037   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
2038 }
2039
2040 //===----------------------------------------------------------------------===//
2041 // OpenMP Directives.
2042 //===----------------------------------------------------------------------===//
2043 void ASTStmtWriter::VisitOMPExecutableDirective(OMPExecutableDirective *E) {
2044   Writer.AddSourceLocation(E->getLocStart(), Record);
2045   Writer.AddSourceLocation(E->getLocEnd(), Record);
2046   OMPClauseWriter ClauseWriter(this, Record);
2047   for (unsigned i = 0; i < E->getNumClauses(); ++i) {
2048     ClauseWriter.writeClause(E->getClause(i));
2049   }
2050   if (E->hasAssociatedStmt())
2051     Writer.AddStmt(E->getAssociatedStmt());
2052 }
2053
2054 void ASTStmtWriter::VisitOMPLoopDirective(OMPLoopDirective *D) {
2055   VisitStmt(D);
2056   Record.push_back(D->getNumClauses());
2057   Record.push_back(D->getCollapsedNumber());
2058   VisitOMPExecutableDirective(D);
2059   Writer.AddStmt(D->getIterationVariable());
2060   Writer.AddStmt(D->getLastIteration());
2061   Writer.AddStmt(D->getCalcLastIteration());
2062   Writer.AddStmt(D->getPreCond());
2063   Writer.AddStmt(D->getCond());
2064   Writer.AddStmt(D->getInit());
2065   Writer.AddStmt(D->getInc());
2066   if (isOpenMPWorksharingDirective(D->getDirectiveKind())) {
2067     Writer.AddStmt(D->getIsLastIterVariable());
2068     Writer.AddStmt(D->getLowerBoundVariable());
2069     Writer.AddStmt(D->getUpperBoundVariable());
2070     Writer.AddStmt(D->getStrideVariable());
2071     Writer.AddStmt(D->getEnsureUpperBound());
2072     Writer.AddStmt(D->getNextLowerBound());
2073     Writer.AddStmt(D->getNextUpperBound());
2074   }
2075   for (auto I : D->counters()) {
2076     Writer.AddStmt(I);
2077   }
2078   for (auto I : D->private_counters()) {
2079     Writer.AddStmt(I);
2080   }
2081   for (auto I : D->inits()) {
2082     Writer.AddStmt(I);
2083   }
2084   for (auto I : D->updates()) {
2085     Writer.AddStmt(I);
2086   }
2087   for (auto I : D->finals()) {
2088     Writer.AddStmt(I);
2089   }
2090 }
2091
2092 void ASTStmtWriter::VisitOMPParallelDirective(OMPParallelDirective *D) {
2093   VisitStmt(D);
2094   Record.push_back(D->getNumClauses());
2095   VisitOMPExecutableDirective(D);
2096   Record.push_back(D->hasCancel() ? 1 : 0);
2097   Code = serialization::STMT_OMP_PARALLEL_DIRECTIVE;
2098 }
2099
2100 void ASTStmtWriter::VisitOMPSimdDirective(OMPSimdDirective *D) {
2101   VisitOMPLoopDirective(D);
2102   Code = serialization::STMT_OMP_SIMD_DIRECTIVE;
2103 }
2104
2105 void ASTStmtWriter::VisitOMPForDirective(OMPForDirective *D) {
2106   VisitOMPLoopDirective(D);
2107   Record.push_back(D->hasCancel() ? 1 : 0);
2108   Code = serialization::STMT_OMP_FOR_DIRECTIVE;
2109 }
2110
2111 void ASTStmtWriter::VisitOMPForSimdDirective(OMPForSimdDirective *D) {
2112   VisitOMPLoopDirective(D);
2113   Code = serialization::STMT_OMP_FOR_SIMD_DIRECTIVE;
2114 }
2115
2116 void ASTStmtWriter::VisitOMPSectionsDirective(OMPSectionsDirective *D) {
2117   VisitStmt(D);
2118   Record.push_back(D->getNumClauses());
2119   VisitOMPExecutableDirective(D);
2120   Record.push_back(D->hasCancel() ? 1 : 0);
2121   Code = serialization::STMT_OMP_SECTIONS_DIRECTIVE;
2122 }
2123
2124 void ASTStmtWriter::VisitOMPSectionDirective(OMPSectionDirective *D) {
2125   VisitStmt(D);
2126   VisitOMPExecutableDirective(D);
2127   Record.push_back(D->hasCancel() ? 1 : 0);
2128   Code = serialization::STMT_OMP_SECTION_DIRECTIVE;
2129 }
2130
2131 void ASTStmtWriter::VisitOMPSingleDirective(OMPSingleDirective *D) {
2132   VisitStmt(D);
2133   Record.push_back(D->getNumClauses());
2134   VisitOMPExecutableDirective(D);
2135   Code = serialization::STMT_OMP_SINGLE_DIRECTIVE;
2136 }
2137
2138 void ASTStmtWriter::VisitOMPMasterDirective(OMPMasterDirective *D) {
2139   VisitStmt(D);
2140   VisitOMPExecutableDirective(D);
2141   Code = serialization::STMT_OMP_MASTER_DIRECTIVE;
2142 }
2143
2144 void ASTStmtWriter::VisitOMPCriticalDirective(OMPCriticalDirective *D) {
2145   VisitStmt(D);
2146   Record.push_back(D->getNumClauses());
2147   VisitOMPExecutableDirective(D);
2148   Writer.AddDeclarationNameInfo(D->getDirectiveName(), Record);
2149   Code = serialization::STMT_OMP_CRITICAL_DIRECTIVE;
2150 }
2151
2152 void ASTStmtWriter::VisitOMPParallelForDirective(OMPParallelForDirective *D) {
2153   VisitOMPLoopDirective(D);
2154   Record.push_back(D->hasCancel() ? 1 : 0);
2155   Code = serialization::STMT_OMP_PARALLEL_FOR_DIRECTIVE;
2156 }
2157
2158 void ASTStmtWriter::VisitOMPParallelForSimdDirective(
2159     OMPParallelForSimdDirective *D) {
2160   VisitOMPLoopDirective(D);
2161   Code = serialization::STMT_OMP_PARALLEL_FOR_SIMD_DIRECTIVE;
2162 }
2163
2164 void ASTStmtWriter::VisitOMPParallelSectionsDirective(
2165     OMPParallelSectionsDirective *D) {
2166   VisitStmt(D);
2167   Record.push_back(D->getNumClauses());
2168   VisitOMPExecutableDirective(D);
2169   Record.push_back(D->hasCancel() ? 1 : 0);
2170   Code = serialization::STMT_OMP_PARALLEL_SECTIONS_DIRECTIVE;
2171 }
2172
2173 void ASTStmtWriter::VisitOMPTaskDirective(OMPTaskDirective *D) {
2174   VisitStmt(D);
2175   Record.push_back(D->getNumClauses());
2176   VisitOMPExecutableDirective(D);
2177   Record.push_back(D->hasCancel() ? 1 : 0);
2178   Code = serialization::STMT_OMP_TASK_DIRECTIVE;
2179 }
2180
2181 void ASTStmtWriter::VisitOMPAtomicDirective(OMPAtomicDirective *D) {
2182   VisitStmt(D);
2183   Record.push_back(D->getNumClauses());
2184   VisitOMPExecutableDirective(D);
2185   Writer.AddStmt(D->getX());
2186   Writer.AddStmt(D->getV());
2187   Writer.AddStmt(D->getExpr());
2188   Writer.AddStmt(D->getUpdateExpr());
2189   Record.push_back(D->isXLHSInRHSPart() ? 1 : 0);
2190   Record.push_back(D->isPostfixUpdate() ? 1 : 0);
2191   Code = serialization::STMT_OMP_ATOMIC_DIRECTIVE;
2192 }
2193
2194 void ASTStmtWriter::VisitOMPTargetDirective(OMPTargetDirective *D) {
2195   VisitStmt(D);
2196   Record.push_back(D->getNumClauses());
2197   VisitOMPExecutableDirective(D);
2198   Code = serialization::STMT_OMP_TARGET_DIRECTIVE;
2199 }
2200
2201 void ASTStmtWriter::VisitOMPTargetDataDirective(OMPTargetDataDirective *D) {
2202   VisitStmt(D);
2203   Record.push_back(D->getNumClauses());
2204   VisitOMPExecutableDirective(D);
2205   Code = serialization::STMT_OMP_TARGET_DATA_DIRECTIVE;
2206 }
2207
2208 void ASTStmtWriter::VisitOMPTaskyieldDirective(OMPTaskyieldDirective *D) {
2209   VisitStmt(D);
2210   VisitOMPExecutableDirective(D);
2211   Code = serialization::STMT_OMP_TASKYIELD_DIRECTIVE;
2212 }
2213
2214 void ASTStmtWriter::VisitOMPBarrierDirective(OMPBarrierDirective *D) {
2215   VisitStmt(D);
2216   VisitOMPExecutableDirective(D);
2217   Code = serialization::STMT_OMP_BARRIER_DIRECTIVE;
2218 }
2219
2220 void ASTStmtWriter::VisitOMPTaskwaitDirective(OMPTaskwaitDirective *D) {
2221   VisitStmt(D);
2222   VisitOMPExecutableDirective(D);
2223   Code = serialization::STMT_OMP_TASKWAIT_DIRECTIVE;
2224 }
2225
2226 void ASTStmtWriter::VisitOMPTaskgroupDirective(OMPTaskgroupDirective *D) {
2227   VisitStmt(D);
2228   VisitOMPExecutableDirective(D);
2229   Code = serialization::STMT_OMP_TASKGROUP_DIRECTIVE;
2230 }
2231
2232 void ASTStmtWriter::VisitOMPFlushDirective(OMPFlushDirective *D) {
2233   VisitStmt(D);
2234   Record.push_back(D->getNumClauses());
2235   VisitOMPExecutableDirective(D);
2236   Code = serialization::STMT_OMP_FLUSH_DIRECTIVE;
2237 }
2238
2239 void ASTStmtWriter::VisitOMPOrderedDirective(OMPOrderedDirective *D) {
2240   VisitStmt(D);
2241   Record.push_back(D->getNumClauses());
2242   VisitOMPExecutableDirective(D);
2243   Code = serialization::STMT_OMP_ORDERED_DIRECTIVE;
2244 }
2245
2246 void ASTStmtWriter::VisitOMPTeamsDirective(OMPTeamsDirective *D) {
2247   VisitStmt(D);
2248   Record.push_back(D->getNumClauses());
2249   VisitOMPExecutableDirective(D);
2250   Code = serialization::STMT_OMP_TEAMS_DIRECTIVE;
2251 }
2252
2253 void ASTStmtWriter::VisitOMPCancellationPointDirective(
2254     OMPCancellationPointDirective *D) {
2255   VisitStmt(D);
2256   VisitOMPExecutableDirective(D);
2257   Record.push_back(D->getCancelRegion());
2258   Code = serialization::STMT_OMP_CANCELLATION_POINT_DIRECTIVE;
2259 }
2260
2261 void ASTStmtWriter::VisitOMPCancelDirective(OMPCancelDirective *D) {
2262   VisitStmt(D);
2263   Record.push_back(D->getNumClauses());
2264   VisitOMPExecutableDirective(D);
2265   Record.push_back(D->getCancelRegion());
2266   Code = serialization::STMT_OMP_CANCEL_DIRECTIVE;
2267 }
2268
2269 void ASTStmtWriter::VisitOMPTaskLoopDirective(OMPTaskLoopDirective *D) {
2270   VisitOMPLoopDirective(D);
2271   Code = serialization::STMT_OMP_TASKLOOP_DIRECTIVE;
2272 }
2273
2274 void ASTStmtWriter::VisitOMPTaskLoopSimdDirective(OMPTaskLoopSimdDirective *D) {
2275   VisitOMPLoopDirective(D);
2276   Code = serialization::STMT_OMP_TASKLOOP_SIMD_DIRECTIVE;
2277 }
2278
2279 void ASTStmtWriter::VisitOMPDistributeDirective(OMPDistributeDirective *D) {
2280   VisitOMPLoopDirective(D);
2281   Code = serialization::STMT_OMP_DISTRIBUTE_DIRECTIVE;
2282 }
2283
2284 //===----------------------------------------------------------------------===//
2285 // ASTWriter Implementation
2286 //===----------------------------------------------------------------------===//
2287
2288 unsigned ASTWriter::RecordSwitchCaseID(SwitchCase *S) {
2289   assert(SwitchCaseIDs.find(S) == SwitchCaseIDs.end() &&
2290          "SwitchCase recorded twice");
2291   unsigned NextID = SwitchCaseIDs.size();
2292   SwitchCaseIDs[S] = NextID;
2293   return NextID;
2294 }
2295
2296 unsigned ASTWriter::getSwitchCaseID(SwitchCase *S) {
2297   assert(SwitchCaseIDs.find(S) != SwitchCaseIDs.end() &&
2298          "SwitchCase hasn't been seen yet");
2299   return SwitchCaseIDs[S];
2300 }
2301
2302 void ASTWriter::ClearSwitchCaseIDs() {
2303   SwitchCaseIDs.clear();
2304 }
2305
2306 /// \brief Write the given substatement or subexpression to the
2307 /// bitstream.
2308 void ASTWriter::WriteSubStmt(Stmt *S,
2309                              llvm::DenseMap<Stmt *, uint64_t> &SubStmtEntries,
2310                              llvm::DenseSet<Stmt *> &ParentStmts) {
2311   RecordData Record;
2312   ASTStmtWriter Writer(*this, Record);
2313   ++NumStatements;
2314
2315   if (!S) {
2316     Stream.EmitRecord(serialization::STMT_NULL_PTR, Record);
2317     return;
2318   }
2319
2320   llvm::DenseMap<Stmt *, uint64_t>::iterator I = SubStmtEntries.find(S);
2321   if (I != SubStmtEntries.end()) {
2322     Record.push_back(I->second);
2323     Stream.EmitRecord(serialization::STMT_REF_PTR, Record);
2324     return;
2325   }
2326
2327 #ifndef NDEBUG
2328   assert(!ParentStmts.count(S) && "There is a Stmt cycle!");
2329
2330   struct ParentStmtInserterRAII {
2331     Stmt *S;
2332     llvm::DenseSet<Stmt *> &ParentStmts;
2333
2334     ParentStmtInserterRAII(Stmt *S, llvm::DenseSet<Stmt *> &ParentStmts)
2335       : S(S), ParentStmts(ParentStmts) {
2336       ParentStmts.insert(S);
2337     }
2338     ~ParentStmtInserterRAII() {
2339       ParentStmts.erase(S);
2340     }
2341   };
2342
2343   ParentStmtInserterRAII ParentStmtInserter(S, ParentStmts);
2344 #endif
2345
2346   // Redirect ASTWriter::AddStmt to collect sub-stmts.
2347   SmallVector<Stmt *, 16> SubStmts;
2348   CollectedStmts = &SubStmts;
2349
2350   Writer.Code = serialization::STMT_NULL_PTR;
2351   Writer.AbbrevToUse = 0;
2352   Writer.Visit(S);
2353
2354 #ifndef NDEBUG
2355   if (Writer.Code == serialization::STMT_NULL_PTR) {
2356     SourceManager &SrcMgr
2357       = DeclIDs.begin()->first->getASTContext().getSourceManager();
2358     S->dump(SrcMgr);
2359     llvm_unreachable("Unhandled sub-statement writing AST file");
2360   }
2361 #endif
2362
2363   // Revert ASTWriter::AddStmt.
2364   CollectedStmts = &StmtsToEmit;
2365
2366   // Write the sub-stmts in reverse order, last to first. When reading them back
2367   // we will read them in correct order by "pop"ing them from the Stmts stack.
2368   // This simplifies reading and allows to store a variable number of sub-stmts
2369   // without knowing it in advance.
2370   while (!SubStmts.empty())
2371     WriteSubStmt(SubStmts.pop_back_val(), SubStmtEntries, ParentStmts);
2372
2373   Stream.EmitRecord(Writer.Code, Record, Writer.AbbrevToUse);
2374
2375   SubStmtEntries[S] = Stream.GetCurrentBitNo();
2376 }
2377
2378 /// \brief Flush all of the statements that have been added to the
2379 /// queue via AddStmt().
2380 void ASTWriter::FlushStmts() {
2381   RecordData Record;
2382
2383   // We expect to be the only consumer of the two temporary statement maps,
2384   // assert that they are empty.
2385   assert(SubStmtEntries.empty() && "unexpected entries in sub-stmt map");
2386   assert(ParentStmts.empty() && "unexpected entries in parent stmt map");
2387
2388   for (unsigned I = 0, N = StmtsToEmit.size(); I != N; ++I) {
2389     WriteSubStmt(StmtsToEmit[I], SubStmtEntries, ParentStmts);
2390
2391     assert(N == StmtsToEmit.size() &&
2392            "Substatement written via AddStmt rather than WriteSubStmt!");
2393
2394     // Note that we are at the end of a full expression. Any
2395     // expression records that follow this one are part of a different
2396     // expression.
2397     Stream.EmitRecord(serialization::STMT_STOP, Record);
2398
2399     SubStmtEntries.clear();
2400     ParentStmts.clear();
2401   }
2402
2403   StmtsToEmit.clear();
2404 }