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
1340   bool HasOtherExprStored = E->Param.getInt();
1341   // Store these first, the reader reads them before creation.
1342   Record.push_back(HasOtherExprStored);
1343   if (HasOtherExprStored)
1344     Writer.AddStmt(E->getExpr());
1345   Writer.AddDeclRef(E->getParam(), Record);
1346   Writer.AddSourceLocation(E->getUsedLocation(), Record);
1347
1348   Code = serialization::EXPR_CXX_DEFAULT_ARG;
1349 }
1350
1351 void ASTStmtWriter::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E) {
1352   VisitExpr(E);
1353   Writer.AddDeclRef(E->getField(), Record);
1354   Writer.AddSourceLocation(E->getExprLoc(), Record);
1355   Code = serialization::EXPR_CXX_DEFAULT_INIT;
1356 }
1357
1358 void ASTStmtWriter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
1359   VisitExpr(E);
1360   Writer.AddCXXTemporary(E->getTemporary(), Record);
1361   Writer.AddStmt(E->getSubExpr());
1362   Code = serialization::EXPR_CXX_BIND_TEMPORARY;
1363 }
1364
1365 void ASTStmtWriter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
1366   VisitExpr(E);
1367   Writer.AddTypeSourceInfo(E->getTypeSourceInfo(), Record);
1368   Writer.AddSourceLocation(E->getRParenLoc(), Record);
1369   Code = serialization::EXPR_CXX_SCALAR_VALUE_INIT;
1370 }
1371
1372 void ASTStmtWriter::VisitCXXNewExpr(CXXNewExpr *E) {
1373   VisitExpr(E);
1374   Record.push_back(E->isGlobalNew());
1375   Record.push_back(E->isArray());
1376   Record.push_back(E->doesUsualArrayDeleteWantSize());
1377   Record.push_back(E->getNumPlacementArgs());
1378   Record.push_back(E->StoredInitializationStyle);
1379   Writer.AddDeclRef(E->getOperatorNew(), Record);
1380   Writer.AddDeclRef(E->getOperatorDelete(), Record);
1381   Writer.AddTypeSourceInfo(E->getAllocatedTypeSourceInfo(), Record);
1382   Writer.AddSourceRange(E->getTypeIdParens(), Record);
1383   Writer.AddSourceRange(E->getSourceRange(), Record);
1384   Writer.AddSourceRange(E->getDirectInitRange(), Record);
1385   for (CXXNewExpr::arg_iterator I = E->raw_arg_begin(), e = E->raw_arg_end();
1386        I != e; ++I)
1387     Writer.AddStmt(*I);
1388
1389   Code = serialization::EXPR_CXX_NEW;
1390 }
1391
1392 void ASTStmtWriter::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
1393   VisitExpr(E);
1394   Record.push_back(E->isGlobalDelete());
1395   Record.push_back(E->isArrayForm());
1396   Record.push_back(E->isArrayFormAsWritten());
1397   Record.push_back(E->doesUsualArrayDeleteWantSize());
1398   Writer.AddDeclRef(E->getOperatorDelete(), Record);
1399   Writer.AddStmt(E->getArgument());
1400   Writer.AddSourceLocation(E->getSourceRange().getBegin(), Record);
1401
1402   Code = serialization::EXPR_CXX_DELETE;
1403 }
1404
1405 void ASTStmtWriter::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) {
1406   VisitExpr(E);
1407
1408   Writer.AddStmt(E->getBase());
1409   Record.push_back(E->isArrow());
1410   Writer.AddSourceLocation(E->getOperatorLoc(), Record);
1411   Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record);
1412   Writer.AddTypeSourceInfo(E->getScopeTypeInfo(), Record);
1413   Writer.AddSourceLocation(E->getColonColonLoc(), Record);
1414   Writer.AddSourceLocation(E->getTildeLoc(), Record);
1415
1416   // PseudoDestructorTypeStorage.
1417   Writer.AddIdentifierRef(E->getDestroyedTypeIdentifier(), Record);
1418   if (E->getDestroyedTypeIdentifier())
1419     Writer.AddSourceLocation(E->getDestroyedTypeLoc(), Record);
1420   else
1421     Writer.AddTypeSourceInfo(E->getDestroyedTypeInfo(), Record);
1422
1423   Code = serialization::EXPR_CXX_PSEUDO_DESTRUCTOR;
1424 }
1425
1426 void ASTStmtWriter::VisitExprWithCleanups(ExprWithCleanups *E) {
1427   VisitExpr(E);
1428   Record.push_back(E->getNumObjects());
1429   for (unsigned i = 0, e = E->getNumObjects(); i != e; ++i)
1430     Writer.AddDeclRef(E->getObject(i), Record);
1431
1432   Writer.AddStmt(E->getSubExpr());
1433   Code = serialization::EXPR_EXPR_WITH_CLEANUPS;
1434 }
1435
1436 void
1437 ASTStmtWriter::VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E){
1438   VisitExpr(E);
1439
1440   // Don't emit anything here, HasTemplateKWAndArgsInfo must be
1441   // emitted first.
1442
1443   Record.push_back(E->HasTemplateKWAndArgsInfo);
1444   if (E->HasTemplateKWAndArgsInfo) {
1445     const ASTTemplateKWAndArgsInfo &ArgInfo =
1446         *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>();
1447     Record.push_back(ArgInfo.NumTemplateArgs);
1448     AddTemplateKWAndArgsInfo(ArgInfo,
1449                              E->getTrailingObjects<TemplateArgumentLoc>());
1450   }
1451
1452   if (!E->isImplicitAccess())
1453     Writer.AddStmt(E->getBase());
1454   else
1455     Writer.AddStmt(nullptr);
1456   Writer.AddTypeRef(E->getBaseType(), Record);
1457   Record.push_back(E->isArrow());
1458   Writer.AddSourceLocation(E->getOperatorLoc(), Record);
1459   Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record);
1460   Writer.AddDeclRef(E->getFirstQualifierFoundInScope(), Record);
1461   Writer.AddDeclarationNameInfo(E->MemberNameInfo, Record);
1462   Code = serialization::EXPR_CXX_DEPENDENT_SCOPE_MEMBER;
1463 }
1464
1465 void
1466 ASTStmtWriter::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) {
1467   VisitExpr(E);
1468
1469   // Don't emit anything here, HasTemplateKWAndArgsInfo must be
1470   // emitted first.
1471
1472   Record.push_back(E->HasTemplateKWAndArgsInfo);
1473   if (E->HasTemplateKWAndArgsInfo) {
1474     const ASTTemplateKWAndArgsInfo &ArgInfo =
1475         *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>();
1476     Record.push_back(ArgInfo.NumTemplateArgs);
1477     AddTemplateKWAndArgsInfo(ArgInfo,
1478                              E->getTrailingObjects<TemplateArgumentLoc>());
1479   }
1480
1481   Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record);
1482   Writer.AddDeclarationNameInfo(E->NameInfo, Record);
1483   Code = serialization::EXPR_CXX_DEPENDENT_SCOPE_DECL_REF;
1484 }
1485
1486 void
1487 ASTStmtWriter::VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E) {
1488   VisitExpr(E);
1489   Record.push_back(E->arg_size());
1490   for (CXXUnresolvedConstructExpr::arg_iterator
1491          ArgI = E->arg_begin(), ArgE = E->arg_end(); ArgI != ArgE; ++ArgI)
1492     Writer.AddStmt(*ArgI);
1493   Writer.AddTypeSourceInfo(E->getTypeSourceInfo(), Record);
1494   Writer.AddSourceLocation(E->getLParenLoc(), Record);
1495   Writer.AddSourceLocation(E->getRParenLoc(), Record);
1496   Code = serialization::EXPR_CXX_UNRESOLVED_CONSTRUCT;
1497 }
1498
1499 void ASTStmtWriter::VisitOverloadExpr(OverloadExpr *E) {
1500   VisitExpr(E);
1501
1502   // Don't emit anything here, HasTemplateKWAndArgsInfo must be
1503   // emitted first.
1504
1505   Record.push_back(E->HasTemplateKWAndArgsInfo);
1506   if (E->HasTemplateKWAndArgsInfo) {
1507     const ASTTemplateKWAndArgsInfo &ArgInfo =
1508         *E->getTrailingASTTemplateKWAndArgsInfo();
1509     Record.push_back(ArgInfo.NumTemplateArgs);
1510     AddTemplateKWAndArgsInfo(ArgInfo, E->getTrailingTemplateArgumentLoc());
1511   }
1512
1513   Record.push_back(E->getNumDecls());
1514   for (OverloadExpr::decls_iterator
1515          OvI = E->decls_begin(), OvE = E->decls_end(); OvI != OvE; ++OvI) {
1516     Writer.AddDeclRef(OvI.getDecl(), Record);
1517     Record.push_back(OvI.getAccess());
1518   }
1519
1520   Writer.AddDeclarationNameInfo(E->NameInfo, Record);
1521   Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record);
1522 }
1523
1524 void ASTStmtWriter::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) {
1525   VisitOverloadExpr(E);
1526   Record.push_back(E->isArrow());
1527   Record.push_back(E->hasUnresolvedUsing());
1528   Writer.AddStmt(!E->isImplicitAccess() ? E->getBase() : nullptr);
1529   Writer.AddTypeRef(E->getBaseType(), Record);
1530   Writer.AddSourceLocation(E->getOperatorLoc(), Record);
1531   Code = serialization::EXPR_CXX_UNRESOLVED_MEMBER;
1532 }
1533
1534 void ASTStmtWriter::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) {
1535   VisitOverloadExpr(E);
1536   Record.push_back(E->requiresADL());
1537   Record.push_back(E->isOverloaded());
1538   Writer.AddDeclRef(E->getNamingClass(), Record);
1539   Code = serialization::EXPR_CXX_UNRESOLVED_LOOKUP;
1540 }
1541
1542 void ASTStmtWriter::VisitTypeTraitExpr(TypeTraitExpr *E) {
1543   VisitExpr(E);
1544   Record.push_back(E->TypeTraitExprBits.NumArgs);
1545   Record.push_back(E->TypeTraitExprBits.Kind); // FIXME: Stable encoding
1546   Record.push_back(E->TypeTraitExprBits.Value);
1547   Writer.AddSourceRange(E->getSourceRange(), Record);
1548   for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
1549     Writer.AddTypeSourceInfo(E->getArg(I), Record);
1550   Code = serialization::EXPR_TYPE_TRAIT;
1551 }
1552
1553 void ASTStmtWriter::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
1554   VisitExpr(E);
1555   Record.push_back(E->getTrait());
1556   Record.push_back(E->getValue());
1557   Writer.AddSourceRange(E->getSourceRange(), Record);
1558   Writer.AddTypeSourceInfo(E->getQueriedTypeSourceInfo(), Record);
1559   Code = serialization::EXPR_ARRAY_TYPE_TRAIT;
1560 }
1561
1562 void ASTStmtWriter::VisitExpressionTraitExpr(ExpressionTraitExpr *E) {
1563   VisitExpr(E);
1564   Record.push_back(E->getTrait());
1565   Record.push_back(E->getValue());
1566   Writer.AddSourceRange(E->getSourceRange(), Record);
1567   Writer.AddStmt(E->getQueriedExpression());
1568   Code = serialization::EXPR_CXX_EXPRESSION_TRAIT;
1569 }
1570
1571 void ASTStmtWriter::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) {
1572   VisitExpr(E);
1573   Record.push_back(E->getValue());
1574   Writer.AddSourceRange(E->getSourceRange(), Record);
1575   Writer.AddStmt(E->getOperand());
1576   Code = serialization::EXPR_CXX_NOEXCEPT;
1577 }
1578
1579 void ASTStmtWriter::VisitPackExpansionExpr(PackExpansionExpr *E) {
1580   VisitExpr(E);
1581   Writer.AddSourceLocation(E->getEllipsisLoc(), Record);
1582   Record.push_back(E->NumExpansions);
1583   Writer.AddStmt(E->getPattern());
1584   Code = serialization::EXPR_PACK_EXPANSION;
1585 }
1586
1587 void ASTStmtWriter::VisitSizeOfPackExpr(SizeOfPackExpr *E) {
1588   VisitExpr(E);
1589   Record.push_back(E->isPartiallySubstituted() ? E->getPartialArguments().size()
1590                                                : 0);
1591   Writer.AddSourceLocation(E->OperatorLoc, Record);
1592   Writer.AddSourceLocation(E->PackLoc, Record);
1593   Writer.AddSourceLocation(E->RParenLoc, Record);
1594   Writer.AddDeclRef(E->Pack, Record);
1595   if (E->isPartiallySubstituted()) {
1596     for (const auto &TA : E->getPartialArguments())
1597       Writer.AddTemplateArgument(TA, Record);
1598   } else if (!E->isValueDependent()) {
1599     Record.push_back(E->getPackLength());
1600   }
1601   Code = serialization::EXPR_SIZEOF_PACK;
1602 }
1603
1604 void ASTStmtWriter::VisitSubstNonTypeTemplateParmExpr(
1605                                               SubstNonTypeTemplateParmExpr *E) {
1606   VisitExpr(E);
1607   Writer.AddDeclRef(E->getParameter(), Record);
1608   Writer.AddSourceLocation(E->getNameLoc(), Record);
1609   Writer.AddStmt(E->getReplacement());
1610   Code = serialization::EXPR_SUBST_NON_TYPE_TEMPLATE_PARM;
1611 }
1612
1613 void ASTStmtWriter::VisitSubstNonTypeTemplateParmPackExpr(
1614                                           SubstNonTypeTemplateParmPackExpr *E) {
1615   VisitExpr(E);
1616   Writer.AddDeclRef(E->getParameterPack(), Record);
1617   Writer.AddTemplateArgument(E->getArgumentPack(), Record);
1618   Writer.AddSourceLocation(E->getParameterPackLocation(), Record);
1619   Code = serialization::EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK;
1620 }
1621
1622 void ASTStmtWriter::VisitFunctionParmPackExpr(FunctionParmPackExpr *E) {
1623   VisitExpr(E);
1624   Record.push_back(E->getNumExpansions());
1625   Writer.AddDeclRef(E->getParameterPack(), Record);
1626   Writer.AddSourceLocation(E->getParameterPackLocation(), Record);
1627   for (FunctionParmPackExpr::iterator I = E->begin(), End = E->end();
1628        I != End; ++I)
1629     Writer.AddDeclRef(*I, Record);
1630   Code = serialization::EXPR_FUNCTION_PARM_PACK;
1631 }
1632
1633 void ASTStmtWriter::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) {
1634   VisitExpr(E);
1635   Writer.AddStmt(E->getTemporary());
1636   Writer.AddDeclRef(E->getExtendingDecl(), Record);
1637   Record.push_back(E->getManglingNumber());
1638   Code = serialization::EXPR_MATERIALIZE_TEMPORARY;
1639 }
1640
1641 void ASTStmtWriter::VisitCXXFoldExpr(CXXFoldExpr *E) {
1642   VisitExpr(E);
1643   Writer.AddSourceLocation(E->LParenLoc, Record);
1644   Writer.AddSourceLocation(E->EllipsisLoc, Record);
1645   Writer.AddSourceLocation(E->RParenLoc, Record);
1646   Writer.AddStmt(E->SubExprs[0]);
1647   Writer.AddStmt(E->SubExprs[1]);
1648   Record.push_back(E->Opcode);
1649   Code = serialization::EXPR_CXX_FOLD;
1650 }
1651
1652 void ASTStmtWriter::VisitOpaqueValueExpr(OpaqueValueExpr *E) {
1653   VisitExpr(E);
1654   Writer.AddStmt(E->getSourceExpr());
1655   Writer.AddSourceLocation(E->getLocation(), Record);
1656   Code = serialization::EXPR_OPAQUE_VALUE;
1657 }
1658
1659 void ASTStmtWriter::VisitTypoExpr(TypoExpr *E) {
1660   VisitExpr(E);
1661   // TODO: Figure out sane writer behavior for a TypoExpr, if necessary
1662   assert(false && "Cannot write TypoExpr nodes");
1663 }
1664
1665 //===----------------------------------------------------------------------===//
1666 // CUDA Expressions and Statements.
1667 //===----------------------------------------------------------------------===//
1668
1669 void ASTStmtWriter::VisitCUDAKernelCallExpr(CUDAKernelCallExpr *E) {
1670   VisitCallExpr(E);
1671   Writer.AddStmt(E->getConfig());
1672   Code = serialization::EXPR_CUDA_KERNEL_CALL;
1673 }
1674
1675 //===----------------------------------------------------------------------===//
1676 // OpenCL Expressions and Statements.
1677 //===----------------------------------------------------------------------===//
1678 void ASTStmtWriter::VisitAsTypeExpr(AsTypeExpr *E) {
1679   VisitExpr(E);
1680   Writer.AddSourceLocation(E->getBuiltinLoc(), Record);
1681   Writer.AddSourceLocation(E->getRParenLoc(), Record);
1682   Writer.AddStmt(E->getSrcExpr());
1683   Code = serialization::EXPR_ASTYPE;
1684 }
1685
1686 //===----------------------------------------------------------------------===//
1687 // Microsoft Expressions and Statements.
1688 //===----------------------------------------------------------------------===//
1689 void ASTStmtWriter::VisitMSPropertyRefExpr(MSPropertyRefExpr *E) {
1690   VisitExpr(E);
1691   Record.push_back(E->isArrow());
1692   Writer.AddStmt(E->getBaseExpr());
1693   Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record);
1694   Writer.AddSourceLocation(E->getMemberLoc(), Record);
1695   Writer.AddDeclRef(E->getPropertyDecl(), Record);
1696   Code = serialization::EXPR_CXX_PROPERTY_REF_EXPR;
1697 }
1698
1699 void ASTStmtWriter::VisitMSPropertySubscriptExpr(MSPropertySubscriptExpr *E) {
1700   VisitExpr(E);
1701   Writer.AddStmt(E->getBase());
1702   Writer.AddStmt(E->getIdx());
1703   Writer.AddSourceLocation(E->getRBracketLoc(), Record);
1704   Code = serialization::EXPR_CXX_PROPERTY_SUBSCRIPT_EXPR;
1705 }
1706
1707 void ASTStmtWriter::VisitCXXUuidofExpr(CXXUuidofExpr *E) {
1708   VisitExpr(E);
1709   Writer.AddSourceRange(E->getSourceRange(), Record);
1710   if (E->isTypeOperand()) {
1711     Writer.AddTypeSourceInfo(E->getTypeOperandSourceInfo(), Record);
1712     Code = serialization::EXPR_CXX_UUIDOF_TYPE;
1713   } else {
1714     Writer.AddStmt(E->getExprOperand());
1715     Code = serialization::EXPR_CXX_UUIDOF_EXPR;
1716   }
1717 }
1718
1719 void ASTStmtWriter::VisitSEHExceptStmt(SEHExceptStmt *S) {
1720   VisitStmt(S);
1721   Writer.AddSourceLocation(S->getExceptLoc(), Record);
1722   Writer.AddStmt(S->getFilterExpr());
1723   Writer.AddStmt(S->getBlock());
1724   Code = serialization::STMT_SEH_EXCEPT;
1725 }
1726
1727 void ASTStmtWriter::VisitSEHFinallyStmt(SEHFinallyStmt *S) {
1728   VisitStmt(S);
1729   Writer.AddSourceLocation(S->getFinallyLoc(), Record);
1730   Writer.AddStmt(S->getBlock());
1731   Code = serialization::STMT_SEH_FINALLY;
1732 }
1733
1734 void ASTStmtWriter::VisitSEHTryStmt(SEHTryStmt *S) {
1735   VisitStmt(S);
1736   Record.push_back(S->getIsCXXTry());
1737   Writer.AddSourceLocation(S->getTryLoc(), Record);
1738   Writer.AddStmt(S->getTryBlock());
1739   Writer.AddStmt(S->getHandler());
1740   Code = serialization::STMT_SEH_TRY;
1741 }
1742
1743 void ASTStmtWriter::VisitSEHLeaveStmt(SEHLeaveStmt *S) {
1744   VisitStmt(S);
1745   Writer.AddSourceLocation(S->getLeaveLoc(), Record);
1746   Code = serialization::STMT_SEH_LEAVE;
1747 }
1748
1749 //===----------------------------------------------------------------------===//
1750 // OpenMP Clauses.
1751 //===----------------------------------------------------------------------===//
1752
1753 namespace clang {
1754 class OMPClauseWriter : public OMPClauseVisitor<OMPClauseWriter> {
1755   ASTStmtWriter *Writer;
1756   ASTWriter::RecordData &Record;
1757 public:
1758   OMPClauseWriter(ASTStmtWriter *W, ASTWriter::RecordData &Record)
1759     : Writer(W), Record(Record) { }
1760 #define OPENMP_CLAUSE(Name, Class)    \
1761   void Visit##Class(Class *S);
1762 #include "clang/Basic/OpenMPKinds.def"
1763   void writeClause(OMPClause *C);
1764 };
1765 }
1766
1767 void OMPClauseWriter::writeClause(OMPClause *C) {
1768   Record.push_back(C->getClauseKind());
1769   Visit(C);
1770   Writer->Writer.AddSourceLocation(C->getLocStart(), Record);
1771   Writer->Writer.AddSourceLocation(C->getLocEnd(), Record);
1772 }
1773
1774 void OMPClauseWriter::VisitOMPIfClause(OMPIfClause *C) {
1775   Record.push_back(C->getNameModifier());
1776   Writer->Writer.AddSourceLocation(C->getNameModifierLoc(), Record);
1777   Writer->Writer.AddSourceLocation(C->getColonLoc(), Record);
1778   Writer->Writer.AddStmt(C->getCondition());
1779   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1780 }
1781
1782 void OMPClauseWriter::VisitOMPFinalClause(OMPFinalClause *C) {
1783   Writer->Writer.AddStmt(C->getCondition());
1784   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1785 }
1786
1787 void OMPClauseWriter::VisitOMPNumThreadsClause(OMPNumThreadsClause *C) {
1788   Writer->Writer.AddStmt(C->getNumThreads());
1789   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1790 }
1791
1792 void OMPClauseWriter::VisitOMPSafelenClause(OMPSafelenClause *C) {
1793   Writer->Writer.AddStmt(C->getSafelen());
1794   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1795 }
1796
1797 void OMPClauseWriter::VisitOMPSimdlenClause(OMPSimdlenClause *C) {
1798   Writer->Writer.AddStmt(C->getSimdlen());
1799   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1800 }
1801
1802 void OMPClauseWriter::VisitOMPCollapseClause(OMPCollapseClause *C) {
1803   Writer->Writer.AddStmt(C->getNumForLoops());
1804   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1805 }
1806
1807 void OMPClauseWriter::VisitOMPDefaultClause(OMPDefaultClause *C) {
1808   Record.push_back(C->getDefaultKind());
1809   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1810   Writer->Writer.AddSourceLocation(C->getDefaultKindKwLoc(), Record);
1811 }
1812
1813 void OMPClauseWriter::VisitOMPProcBindClause(OMPProcBindClause *C) {
1814   Record.push_back(C->getProcBindKind());
1815   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1816   Writer->Writer.AddSourceLocation(C->getProcBindKindKwLoc(), Record);
1817 }
1818
1819 void OMPClauseWriter::VisitOMPScheduleClause(OMPScheduleClause *C) {
1820   Record.push_back(C->getScheduleKind());
1821   Record.push_back(C->getFirstScheduleModifier());
1822   Record.push_back(C->getSecondScheduleModifier());
1823   Writer->Writer.AddStmt(C->getChunkSize());
1824   Writer->Writer.AddStmt(C->getHelperChunkSize());
1825   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1826   Writer->Writer.AddSourceLocation(C->getFirstScheduleModifierLoc(), Record);
1827   Writer->Writer.AddSourceLocation(C->getSecondScheduleModifierLoc(), Record);
1828   Writer->Writer.AddSourceLocation(C->getScheduleKindLoc(), Record);
1829   Writer->Writer.AddSourceLocation(C->getCommaLoc(), Record);
1830 }
1831
1832 void OMPClauseWriter::VisitOMPOrderedClause(OMPOrderedClause *C) {
1833   Writer->Writer.AddStmt(C->getNumForLoops());
1834   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1835 }
1836
1837 void OMPClauseWriter::VisitOMPNowaitClause(OMPNowaitClause *) {}
1838
1839 void OMPClauseWriter::VisitOMPUntiedClause(OMPUntiedClause *) {}
1840
1841 void OMPClauseWriter::VisitOMPMergeableClause(OMPMergeableClause *) {}
1842
1843 void OMPClauseWriter::VisitOMPReadClause(OMPReadClause *) {}
1844
1845 void OMPClauseWriter::VisitOMPWriteClause(OMPWriteClause *) {}
1846
1847 void OMPClauseWriter::VisitOMPUpdateClause(OMPUpdateClause *) {}
1848
1849 void OMPClauseWriter::VisitOMPCaptureClause(OMPCaptureClause *) {}
1850
1851 void OMPClauseWriter::VisitOMPSeqCstClause(OMPSeqCstClause *) {}
1852
1853 void OMPClauseWriter::VisitOMPThreadsClause(OMPThreadsClause *) {}
1854
1855 void OMPClauseWriter::VisitOMPSIMDClause(OMPSIMDClause *) {}
1856
1857 void OMPClauseWriter::VisitOMPNogroupClause(OMPNogroupClause *) {}
1858
1859 void OMPClauseWriter::VisitOMPPrivateClause(OMPPrivateClause *C) {
1860   Record.push_back(C->varlist_size());
1861   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1862   for (auto *VE : C->varlists()) {
1863     Writer->Writer.AddStmt(VE);
1864   }
1865   for (auto *VE : C->private_copies()) {
1866     Writer->Writer.AddStmt(VE);
1867   }
1868 }
1869
1870 void OMPClauseWriter::VisitOMPFirstprivateClause(OMPFirstprivateClause *C) {
1871   Record.push_back(C->varlist_size());
1872   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1873   for (auto *VE : C->varlists()) {
1874     Writer->Writer.AddStmt(VE);
1875   }
1876   for (auto *VE : C->private_copies()) {
1877     Writer->Writer.AddStmt(VE);
1878   }
1879   for (auto *VE : C->inits()) {
1880     Writer->Writer.AddStmt(VE);
1881   }
1882 }
1883
1884 void OMPClauseWriter::VisitOMPLastprivateClause(OMPLastprivateClause *C) {
1885   Record.push_back(C->varlist_size());
1886   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1887   for (auto *VE : C->varlists())
1888     Writer->Writer.AddStmt(VE);
1889   for (auto *E : C->private_copies())
1890     Writer->Writer.AddStmt(E);
1891   for (auto *E : C->source_exprs())
1892     Writer->Writer.AddStmt(E);
1893   for (auto *E : C->destination_exprs())
1894     Writer->Writer.AddStmt(E);
1895   for (auto *E : C->assignment_ops())
1896     Writer->Writer.AddStmt(E);
1897 }
1898
1899 void OMPClauseWriter::VisitOMPSharedClause(OMPSharedClause *C) {
1900   Record.push_back(C->varlist_size());
1901   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1902   for (auto *VE : C->varlists())
1903     Writer->Writer.AddStmt(VE);
1904 }
1905
1906 void OMPClauseWriter::VisitOMPReductionClause(OMPReductionClause *C) {
1907   Record.push_back(C->varlist_size());
1908   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1909   Writer->Writer.AddSourceLocation(C->getColonLoc(), Record);
1910   Writer->Writer.AddNestedNameSpecifierLoc(C->getQualifierLoc(), Record);
1911   Writer->Writer.AddDeclarationNameInfo(C->getNameInfo(), Record);
1912   for (auto *VE : C->varlists())
1913     Writer->Writer.AddStmt(VE);
1914   for (auto *VE : C->privates())
1915     Writer->Writer.AddStmt(VE);
1916   for (auto *E : C->lhs_exprs())
1917     Writer->Writer.AddStmt(E);
1918   for (auto *E : C->rhs_exprs())
1919     Writer->Writer.AddStmt(E);
1920   for (auto *E : C->reduction_ops())
1921     Writer->Writer.AddStmt(E);
1922 }
1923
1924 void OMPClauseWriter::VisitOMPLinearClause(OMPLinearClause *C) {
1925   Record.push_back(C->varlist_size());
1926   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1927   Writer->Writer.AddSourceLocation(C->getColonLoc(), Record);
1928   Record.push_back(C->getModifier());
1929   Writer->Writer.AddSourceLocation(C->getModifierLoc(), Record);
1930   for (auto *VE : C->varlists()) {
1931     Writer->Writer.AddStmt(VE);
1932   }
1933   for (auto *VE : C->privates()) {
1934     Writer->Writer.AddStmt(VE);
1935   }
1936   for (auto *VE : C->inits()) {
1937     Writer->Writer.AddStmt(VE);
1938   }
1939   for (auto *VE : C->updates()) {
1940     Writer->Writer.AddStmt(VE);
1941   }
1942   for (auto *VE : C->finals()) {
1943     Writer->Writer.AddStmt(VE);
1944   }
1945   Writer->Writer.AddStmt(C->getStep());
1946   Writer->Writer.AddStmt(C->getCalcStep());
1947 }
1948
1949 void OMPClauseWriter::VisitOMPAlignedClause(OMPAlignedClause *C) {
1950   Record.push_back(C->varlist_size());
1951   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1952   Writer->Writer.AddSourceLocation(C->getColonLoc(), Record);
1953   for (auto *VE : C->varlists())
1954     Writer->Writer.AddStmt(VE);
1955   Writer->Writer.AddStmt(C->getAlignment());
1956 }
1957
1958 void OMPClauseWriter::VisitOMPCopyinClause(OMPCopyinClause *C) {
1959   Record.push_back(C->varlist_size());
1960   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1961   for (auto *VE : C->varlists())
1962     Writer->Writer.AddStmt(VE);
1963   for (auto *E : C->source_exprs())
1964     Writer->Writer.AddStmt(E);
1965   for (auto *E : C->destination_exprs())
1966     Writer->Writer.AddStmt(E);
1967   for (auto *E : C->assignment_ops())
1968     Writer->Writer.AddStmt(E);
1969 }
1970
1971 void OMPClauseWriter::VisitOMPCopyprivateClause(OMPCopyprivateClause *C) {
1972   Record.push_back(C->varlist_size());
1973   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1974   for (auto *VE : C->varlists())
1975     Writer->Writer.AddStmt(VE);
1976   for (auto *E : C->source_exprs())
1977     Writer->Writer.AddStmt(E);
1978   for (auto *E : C->destination_exprs())
1979     Writer->Writer.AddStmt(E);
1980   for (auto *E : C->assignment_ops())
1981     Writer->Writer.AddStmt(E);
1982 }
1983
1984 void OMPClauseWriter::VisitOMPFlushClause(OMPFlushClause *C) {
1985   Record.push_back(C->varlist_size());
1986   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1987   for (auto *VE : C->varlists())
1988     Writer->Writer.AddStmt(VE);
1989 }
1990
1991 void OMPClauseWriter::VisitOMPDependClause(OMPDependClause *C) {
1992   Record.push_back(C->varlist_size());
1993   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1994   Record.push_back(C->getDependencyKind());
1995   Writer->Writer.AddSourceLocation(C->getDependencyLoc(), Record);
1996   Writer->Writer.AddSourceLocation(C->getColonLoc(), Record);
1997   for (auto *VE : C->varlists())
1998     Writer->Writer.AddStmt(VE);
1999 }
2000
2001 void OMPClauseWriter::VisitOMPDeviceClause(OMPDeviceClause *C) {
2002   Writer->Writer.AddStmt(C->getDevice());
2003   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
2004 }
2005
2006 void OMPClauseWriter::VisitOMPMapClause(OMPMapClause *C) {
2007   Record.push_back(C->varlist_size());
2008   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
2009   Record.push_back(C->getMapTypeModifier());
2010   Record.push_back(C->getMapType());
2011   Writer->Writer.AddSourceLocation(C->getMapLoc(), Record);
2012   Writer->Writer.AddSourceLocation(C->getColonLoc(), Record);
2013   for (auto *VE : C->varlists())
2014     Writer->Writer.AddStmt(VE);
2015 }
2016
2017 void OMPClauseWriter::VisitOMPNumTeamsClause(OMPNumTeamsClause *C) {
2018   Writer->Writer.AddStmt(C->getNumTeams());
2019   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
2020 }
2021
2022 void OMPClauseWriter::VisitOMPThreadLimitClause(OMPThreadLimitClause *C) {
2023   Writer->Writer.AddStmt(C->getThreadLimit());
2024   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
2025 }
2026
2027 void OMPClauseWriter::VisitOMPPriorityClause(OMPPriorityClause *C) {
2028   Writer->Writer.AddStmt(C->getPriority());
2029   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
2030 }
2031
2032 void OMPClauseWriter::VisitOMPGrainsizeClause(OMPGrainsizeClause *C) {
2033   Writer->Writer.AddStmt(C->getGrainsize());
2034   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
2035 }
2036
2037 void OMPClauseWriter::VisitOMPNumTasksClause(OMPNumTasksClause *C) {
2038   Writer->Writer.AddStmt(C->getNumTasks());
2039   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
2040 }
2041
2042 void OMPClauseWriter::VisitOMPHintClause(OMPHintClause *C) {
2043   Writer->Writer.AddStmt(C->getHint());
2044   Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
2045 }
2046
2047 //===----------------------------------------------------------------------===//
2048 // OpenMP Directives.
2049 //===----------------------------------------------------------------------===//
2050 void ASTStmtWriter::VisitOMPExecutableDirective(OMPExecutableDirective *E) {
2051   Writer.AddSourceLocation(E->getLocStart(), Record);
2052   Writer.AddSourceLocation(E->getLocEnd(), Record);
2053   OMPClauseWriter ClauseWriter(this, Record);
2054   for (unsigned i = 0; i < E->getNumClauses(); ++i) {
2055     ClauseWriter.writeClause(E->getClause(i));
2056   }
2057   if (E->hasAssociatedStmt())
2058     Writer.AddStmt(E->getAssociatedStmt());
2059 }
2060
2061 void ASTStmtWriter::VisitOMPLoopDirective(OMPLoopDirective *D) {
2062   VisitStmt(D);
2063   Record.push_back(D->getNumClauses());
2064   Record.push_back(D->getCollapsedNumber());
2065   VisitOMPExecutableDirective(D);
2066   Writer.AddStmt(D->getIterationVariable());
2067   Writer.AddStmt(D->getLastIteration());
2068   Writer.AddStmt(D->getCalcLastIteration());
2069   Writer.AddStmt(D->getPreCond());
2070   Writer.AddStmt(D->getCond());
2071   Writer.AddStmt(D->getInit());
2072   Writer.AddStmt(D->getInc());
2073   if (isOpenMPWorksharingDirective(D->getDirectiveKind())) {
2074     Writer.AddStmt(D->getIsLastIterVariable());
2075     Writer.AddStmt(D->getLowerBoundVariable());
2076     Writer.AddStmt(D->getUpperBoundVariable());
2077     Writer.AddStmt(D->getStrideVariable());
2078     Writer.AddStmt(D->getEnsureUpperBound());
2079     Writer.AddStmt(D->getNextLowerBound());
2080     Writer.AddStmt(D->getNextUpperBound());
2081   }
2082   for (auto I : D->counters()) {
2083     Writer.AddStmt(I);
2084   }
2085   for (auto I : D->private_counters()) {
2086     Writer.AddStmt(I);
2087   }
2088   for (auto I : D->inits()) {
2089     Writer.AddStmt(I);
2090   }
2091   for (auto I : D->updates()) {
2092     Writer.AddStmt(I);
2093   }
2094   for (auto I : D->finals()) {
2095     Writer.AddStmt(I);
2096   }
2097 }
2098
2099 void ASTStmtWriter::VisitOMPParallelDirective(OMPParallelDirective *D) {
2100   VisitStmt(D);
2101   Record.push_back(D->getNumClauses());
2102   VisitOMPExecutableDirective(D);
2103   Record.push_back(D->hasCancel() ? 1 : 0);
2104   Code = serialization::STMT_OMP_PARALLEL_DIRECTIVE;
2105 }
2106
2107 void ASTStmtWriter::VisitOMPSimdDirective(OMPSimdDirective *D) {
2108   VisitOMPLoopDirective(D);
2109   Code = serialization::STMT_OMP_SIMD_DIRECTIVE;
2110 }
2111
2112 void ASTStmtWriter::VisitOMPForDirective(OMPForDirective *D) {
2113   VisitOMPLoopDirective(D);
2114   Record.push_back(D->hasCancel() ? 1 : 0);
2115   Code = serialization::STMT_OMP_FOR_DIRECTIVE;
2116 }
2117
2118 void ASTStmtWriter::VisitOMPForSimdDirective(OMPForSimdDirective *D) {
2119   VisitOMPLoopDirective(D);
2120   Code = serialization::STMT_OMP_FOR_SIMD_DIRECTIVE;
2121 }
2122
2123 void ASTStmtWriter::VisitOMPSectionsDirective(OMPSectionsDirective *D) {
2124   VisitStmt(D);
2125   Record.push_back(D->getNumClauses());
2126   VisitOMPExecutableDirective(D);
2127   Record.push_back(D->hasCancel() ? 1 : 0);
2128   Code = serialization::STMT_OMP_SECTIONS_DIRECTIVE;
2129 }
2130
2131 void ASTStmtWriter::VisitOMPSectionDirective(OMPSectionDirective *D) {
2132   VisitStmt(D);
2133   VisitOMPExecutableDirective(D);
2134   Record.push_back(D->hasCancel() ? 1 : 0);
2135   Code = serialization::STMT_OMP_SECTION_DIRECTIVE;
2136 }
2137
2138 void ASTStmtWriter::VisitOMPSingleDirective(OMPSingleDirective *D) {
2139   VisitStmt(D);
2140   Record.push_back(D->getNumClauses());
2141   VisitOMPExecutableDirective(D);
2142   Code = serialization::STMT_OMP_SINGLE_DIRECTIVE;
2143 }
2144
2145 void ASTStmtWriter::VisitOMPMasterDirective(OMPMasterDirective *D) {
2146   VisitStmt(D);
2147   VisitOMPExecutableDirective(D);
2148   Code = serialization::STMT_OMP_MASTER_DIRECTIVE;
2149 }
2150
2151 void ASTStmtWriter::VisitOMPCriticalDirective(OMPCriticalDirective *D) {
2152   VisitStmt(D);
2153   Record.push_back(D->getNumClauses());
2154   VisitOMPExecutableDirective(D);
2155   Writer.AddDeclarationNameInfo(D->getDirectiveName(), Record);
2156   Code = serialization::STMT_OMP_CRITICAL_DIRECTIVE;
2157 }
2158
2159 void ASTStmtWriter::VisitOMPParallelForDirective(OMPParallelForDirective *D) {
2160   VisitOMPLoopDirective(D);
2161   Record.push_back(D->hasCancel() ? 1 : 0);
2162   Code = serialization::STMT_OMP_PARALLEL_FOR_DIRECTIVE;
2163 }
2164
2165 void ASTStmtWriter::VisitOMPParallelForSimdDirective(
2166     OMPParallelForSimdDirective *D) {
2167   VisitOMPLoopDirective(D);
2168   Code = serialization::STMT_OMP_PARALLEL_FOR_SIMD_DIRECTIVE;
2169 }
2170
2171 void ASTStmtWriter::VisitOMPParallelSectionsDirective(
2172     OMPParallelSectionsDirective *D) {
2173   VisitStmt(D);
2174   Record.push_back(D->getNumClauses());
2175   VisitOMPExecutableDirective(D);
2176   Record.push_back(D->hasCancel() ? 1 : 0);
2177   Code = serialization::STMT_OMP_PARALLEL_SECTIONS_DIRECTIVE;
2178 }
2179
2180 void ASTStmtWriter::VisitOMPTaskDirective(OMPTaskDirective *D) {
2181   VisitStmt(D);
2182   Record.push_back(D->getNumClauses());
2183   VisitOMPExecutableDirective(D);
2184   Record.push_back(D->hasCancel() ? 1 : 0);
2185   Code = serialization::STMT_OMP_TASK_DIRECTIVE;
2186 }
2187
2188 void ASTStmtWriter::VisitOMPAtomicDirective(OMPAtomicDirective *D) {
2189   VisitStmt(D);
2190   Record.push_back(D->getNumClauses());
2191   VisitOMPExecutableDirective(D);
2192   Writer.AddStmt(D->getX());
2193   Writer.AddStmt(D->getV());
2194   Writer.AddStmt(D->getExpr());
2195   Writer.AddStmt(D->getUpdateExpr());
2196   Record.push_back(D->isXLHSInRHSPart() ? 1 : 0);
2197   Record.push_back(D->isPostfixUpdate() ? 1 : 0);
2198   Code = serialization::STMT_OMP_ATOMIC_DIRECTIVE;
2199 }
2200
2201 void ASTStmtWriter::VisitOMPTargetDirective(OMPTargetDirective *D) {
2202   VisitStmt(D);
2203   Record.push_back(D->getNumClauses());
2204   VisitOMPExecutableDirective(D);
2205   Code = serialization::STMT_OMP_TARGET_DIRECTIVE;
2206 }
2207
2208 void ASTStmtWriter::VisitOMPTargetDataDirective(OMPTargetDataDirective *D) {
2209   VisitStmt(D);
2210   Record.push_back(D->getNumClauses());
2211   VisitOMPExecutableDirective(D);
2212   Code = serialization::STMT_OMP_TARGET_DATA_DIRECTIVE;
2213 }
2214
2215 void ASTStmtWriter::VisitOMPTaskyieldDirective(OMPTaskyieldDirective *D) {
2216   VisitStmt(D);
2217   VisitOMPExecutableDirective(D);
2218   Code = serialization::STMT_OMP_TASKYIELD_DIRECTIVE;
2219 }
2220
2221 void ASTStmtWriter::VisitOMPBarrierDirective(OMPBarrierDirective *D) {
2222   VisitStmt(D);
2223   VisitOMPExecutableDirective(D);
2224   Code = serialization::STMT_OMP_BARRIER_DIRECTIVE;
2225 }
2226
2227 void ASTStmtWriter::VisitOMPTaskwaitDirective(OMPTaskwaitDirective *D) {
2228   VisitStmt(D);
2229   VisitOMPExecutableDirective(D);
2230   Code = serialization::STMT_OMP_TASKWAIT_DIRECTIVE;
2231 }
2232
2233 void ASTStmtWriter::VisitOMPTaskgroupDirective(OMPTaskgroupDirective *D) {
2234   VisitStmt(D);
2235   VisitOMPExecutableDirective(D);
2236   Code = serialization::STMT_OMP_TASKGROUP_DIRECTIVE;
2237 }
2238
2239 void ASTStmtWriter::VisitOMPFlushDirective(OMPFlushDirective *D) {
2240   VisitStmt(D);
2241   Record.push_back(D->getNumClauses());
2242   VisitOMPExecutableDirective(D);
2243   Code = serialization::STMT_OMP_FLUSH_DIRECTIVE;
2244 }
2245
2246 void ASTStmtWriter::VisitOMPOrderedDirective(OMPOrderedDirective *D) {
2247   VisitStmt(D);
2248   Record.push_back(D->getNumClauses());
2249   VisitOMPExecutableDirective(D);
2250   Code = serialization::STMT_OMP_ORDERED_DIRECTIVE;
2251 }
2252
2253 void ASTStmtWriter::VisitOMPTeamsDirective(OMPTeamsDirective *D) {
2254   VisitStmt(D);
2255   Record.push_back(D->getNumClauses());
2256   VisitOMPExecutableDirective(D);
2257   Code = serialization::STMT_OMP_TEAMS_DIRECTIVE;
2258 }
2259
2260 void ASTStmtWriter::VisitOMPCancellationPointDirective(
2261     OMPCancellationPointDirective *D) {
2262   VisitStmt(D);
2263   VisitOMPExecutableDirective(D);
2264   Record.push_back(D->getCancelRegion());
2265   Code = serialization::STMT_OMP_CANCELLATION_POINT_DIRECTIVE;
2266 }
2267
2268 void ASTStmtWriter::VisitOMPCancelDirective(OMPCancelDirective *D) {
2269   VisitStmt(D);
2270   Record.push_back(D->getNumClauses());
2271   VisitOMPExecutableDirective(D);
2272   Record.push_back(D->getCancelRegion());
2273   Code = serialization::STMT_OMP_CANCEL_DIRECTIVE;
2274 }
2275
2276 void ASTStmtWriter::VisitOMPTaskLoopDirective(OMPTaskLoopDirective *D) {
2277   VisitOMPLoopDirective(D);
2278   Code = serialization::STMT_OMP_TASKLOOP_DIRECTIVE;
2279 }
2280
2281 void ASTStmtWriter::VisitOMPTaskLoopSimdDirective(OMPTaskLoopSimdDirective *D) {
2282   VisitOMPLoopDirective(D);
2283   Code = serialization::STMT_OMP_TASKLOOP_SIMD_DIRECTIVE;
2284 }
2285
2286 void ASTStmtWriter::VisitOMPDistributeDirective(OMPDistributeDirective *D) {
2287   VisitOMPLoopDirective(D);
2288   Code = serialization::STMT_OMP_DISTRIBUTE_DIRECTIVE;
2289 }
2290
2291 //===----------------------------------------------------------------------===//
2292 // ASTWriter Implementation
2293 //===----------------------------------------------------------------------===//
2294
2295 unsigned ASTWriter::RecordSwitchCaseID(SwitchCase *S) {
2296   assert(SwitchCaseIDs.find(S) == SwitchCaseIDs.end() &&
2297          "SwitchCase recorded twice");
2298   unsigned NextID = SwitchCaseIDs.size();
2299   SwitchCaseIDs[S] = NextID;
2300   return NextID;
2301 }
2302
2303 unsigned ASTWriter::getSwitchCaseID(SwitchCase *S) {
2304   assert(SwitchCaseIDs.find(S) != SwitchCaseIDs.end() &&
2305          "SwitchCase hasn't been seen yet");
2306   return SwitchCaseIDs[S];
2307 }
2308
2309 void ASTWriter::ClearSwitchCaseIDs() {
2310   SwitchCaseIDs.clear();
2311 }
2312
2313 /// \brief Write the given substatement or subexpression to the
2314 /// bitstream.
2315 void ASTWriter::WriteSubStmt(Stmt *S,
2316                              llvm::DenseMap<Stmt *, uint64_t> &SubStmtEntries,
2317                              llvm::DenseSet<Stmt *> &ParentStmts) {
2318   RecordData Record;
2319   ASTStmtWriter Writer(*this, Record);
2320   ++NumStatements;
2321
2322   if (!S) {
2323     Stream.EmitRecord(serialization::STMT_NULL_PTR, Record);
2324     return;
2325   }
2326
2327   llvm::DenseMap<Stmt *, uint64_t>::iterator I = SubStmtEntries.find(S);
2328   if (I != SubStmtEntries.end()) {
2329     Record.push_back(I->second);
2330     Stream.EmitRecord(serialization::STMT_REF_PTR, Record);
2331     return;
2332   }
2333
2334 #ifndef NDEBUG
2335   assert(!ParentStmts.count(S) && "There is a Stmt cycle!");
2336
2337   struct ParentStmtInserterRAII {
2338     Stmt *S;
2339     llvm::DenseSet<Stmt *> &ParentStmts;
2340
2341     ParentStmtInserterRAII(Stmt *S, llvm::DenseSet<Stmt *> &ParentStmts)
2342       : S(S), ParentStmts(ParentStmts) {
2343       ParentStmts.insert(S);
2344     }
2345     ~ParentStmtInserterRAII() {
2346       ParentStmts.erase(S);
2347     }
2348   };
2349
2350   ParentStmtInserterRAII ParentStmtInserter(S, ParentStmts);
2351 #endif
2352
2353   // Redirect ASTWriter::AddStmt to collect sub-stmts.
2354   SmallVector<Stmt *, 16> SubStmts;
2355   CollectedStmts = &SubStmts;
2356
2357   Writer.Code = serialization::STMT_NULL_PTR;
2358   Writer.AbbrevToUse = 0;
2359   Writer.Visit(S);
2360
2361 #ifndef NDEBUG
2362   if (Writer.Code == serialization::STMT_NULL_PTR) {
2363     SourceManager &SrcMgr
2364       = DeclIDs.begin()->first->getASTContext().getSourceManager();
2365     S->dump(SrcMgr);
2366     llvm_unreachable("Unhandled sub-statement writing AST file");
2367   }
2368 #endif
2369
2370   // Revert ASTWriter::AddStmt.
2371   CollectedStmts = &StmtsToEmit;
2372
2373   // Write the sub-stmts in reverse order, last to first. When reading them back
2374   // we will read them in correct order by "pop"ing them from the Stmts stack.
2375   // This simplifies reading and allows to store a variable number of sub-stmts
2376   // without knowing it in advance.
2377   while (!SubStmts.empty())
2378     WriteSubStmt(SubStmts.pop_back_val(), SubStmtEntries, ParentStmts);
2379
2380   Stream.EmitRecord(Writer.Code, Record, Writer.AbbrevToUse);
2381
2382   SubStmtEntries[S] = Stream.GetCurrentBitNo();
2383 }
2384
2385 /// \brief Flush all of the statements that have been added to the
2386 /// queue via AddStmt().
2387 void ASTWriter::FlushStmts() {
2388   RecordData Record;
2389
2390   // We expect to be the only consumer of the two temporary statement maps,
2391   // assert that they are empty.
2392   assert(SubStmtEntries.empty() && "unexpected entries in sub-stmt map");
2393   assert(ParentStmts.empty() && "unexpected entries in parent stmt map");
2394
2395   for (unsigned I = 0, N = StmtsToEmit.size(); I != N; ++I) {
2396     WriteSubStmt(StmtsToEmit[I], SubStmtEntries, ParentStmts);
2397
2398     assert(N == StmtsToEmit.size() &&
2399            "Substatement written via AddStmt rather than WriteSubStmt!");
2400
2401     // Note that we are at the end of a full expression. Any
2402     // expression records that follow this one are part of a different
2403     // expression.
2404     Stream.EmitRecord(serialization::STMT_STOP, Record);
2405
2406     SubStmtEntries.clear();
2407     ParentStmts.clear();
2408   }
2409
2410   StmtsToEmit.clear();
2411 }