contrib/llvm/tools/clang/lib/Serialization/ASTReaderStmt.cpp

   1 //===--- ASTReaderStmt.cpp - Stmt/Expr Deserialization ----------*- C++ -*-===//
   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 // Statement/expression deserialization.  This implements the
  11 // ASTReader::ReadStmt method.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "clang/Serialization/ASTReader.h"
  16 #include "clang/AST/ASTContext.h"
  17 #include "clang/AST/DeclCXX.h"
  18 #include "clang/AST/DeclTemplate.h"
  19 #include "clang/AST/StmtVisitor.h"
  20 #include "clang/Lex/Token.h"
  21 #include "llvm/ADT/SmallString.h"
  22 using namespace clang;
  23 using namespace clang::serialization;
  24
  25 namespace clang {
  26
  27   class ASTStmtReader : public StmtVisitor<ASTStmtReader> {
  28     friend class OMPClauseReader;
  29
  30     ASTRecordReader &Record;
  31     llvm::BitstreamCursor &DeclsCursor;
  32
  33     SourceLocation ReadSourceLocation() {
  34       return Record.readSourceLocation();
  35     }
  36
  37     SourceRange ReadSourceRange() {
  38       return Record.readSourceRange();
  39     }
  40
  41     std::string ReadString() {
  42       return Record.readString();
  43     }
  44
  45     TypeSourceInfo *GetTypeSourceInfo() {
  46       return Record.getTypeSourceInfo();
  47     }
  48
  49     Decl *ReadDecl() {
  50       return Record.readDecl();
  51     }
  52
  53     template<typename T>
  54     T *ReadDeclAs() {
  55       return Record.readDeclAs<T>();
  56     }
  57
  58     void ReadDeclarationNameLoc(DeclarationNameLoc &DNLoc,
  59                                 DeclarationName Name) {
  60       Record.readDeclarationNameLoc(DNLoc, Name);
  61     }
  62
  63     void ReadDeclarationNameInfo(DeclarationNameInfo &NameInfo) {
  64       Record.readDeclarationNameInfo(NameInfo);
  65     }
  66
  67   public:
  68     ASTStmtReader(ASTRecordReader &Record, llvm::BitstreamCursor &Cursor)
  69         : Record(Record), DeclsCursor(Cursor) {}
  70
  71     /// \brief The number of record fields required for the Stmt class
  72     /// itself.
  73     static const unsigned NumStmtFields = 0;
  74
  75     /// \brief The number of record fields required for the Expr class
  76     /// itself.
  77     static const unsigned NumExprFields = NumStmtFields + 7;
  78
  79     /// \brief Read and initialize a ExplicitTemplateArgumentList structure.
  80     void ReadTemplateKWAndArgsInfo(ASTTemplateKWAndArgsInfo &Args,
  81                                    TemplateArgumentLoc *ArgsLocArray,
  82                                    unsigned NumTemplateArgs);
  83     /// \brief Read and initialize a ExplicitTemplateArgumentList structure.
  84     void ReadExplicitTemplateArgumentList(ASTTemplateArgumentListInfo &ArgList,
  85                                           unsigned NumTemplateArgs);
  86
  87     void VisitStmt(Stmt *S);
  88 #define STMT(Type, Base) \
  89     void Visit##Type(Type *);
  90 #include "clang/AST/StmtNodes.inc"
  91   };
  92 }
  93
  94 void ASTStmtReader::ReadTemplateKWAndArgsInfo(ASTTemplateKWAndArgsInfo &Args,
  95                                               TemplateArgumentLoc *ArgsLocArray,
  96                                               unsigned NumTemplateArgs) {
  97   SourceLocation TemplateKWLoc = ReadSourceLocation();
  98   TemplateArgumentListInfo ArgInfo;
  99   ArgInfo.setLAngleLoc(ReadSourceLocation());
 100   ArgInfo.setRAngleLoc(ReadSourceLocation());
 101   for (unsigned i = 0; i != NumTemplateArgs; ++i)
 102     ArgInfo.addArgument(Record.readTemplateArgumentLoc());
 103   Args.initializeFrom(TemplateKWLoc, ArgInfo, ArgsLocArray);
 104 }
 105
 106 void ASTStmtReader::VisitStmt(Stmt *S) {
 107   assert(Record.getIdx() == NumStmtFields && "Incorrect statement field count");
 108 }
 109
 110 void ASTStmtReader::VisitNullStmt(NullStmt *S) {
 111   VisitStmt(S);
 112   S->setSemiLoc(ReadSourceLocation());
 113   S->HasLeadingEmptyMacro = Record.readInt();
 114 }
 115
 116 void ASTStmtReader::VisitCompoundStmt(CompoundStmt *S) {
 117   VisitStmt(S);
 118   SmallVector<Stmt *, 16> Stmts;
 119   unsigned NumStmts = Record.readInt();
 120   while (NumStmts--)
 121     Stmts.push_back(Record.readSubStmt());
 122   S->setStmts(Record.getContext(), Stmts);
 123   S->LBraceLoc = ReadSourceLocation();
 124   S->RBraceLoc = ReadSourceLocation();
 125 }
 126
 127 void ASTStmtReader::VisitSwitchCase(SwitchCase *S) {
 128   VisitStmt(S);
 129   Record.recordSwitchCaseID(S, Record.readInt());
 130   S->setKeywordLoc(ReadSourceLocation());
 131   S->setColonLoc(ReadSourceLocation());
 132 }
 133
 134 void ASTStmtReader::VisitCaseStmt(CaseStmt *S) {
 135   VisitSwitchCase(S);
 136   S->setLHS(Record.readSubExpr());
 137   S->setRHS(Record.readSubExpr());
 138   S->setSubStmt(Record.readSubStmt());
 139   S->setEllipsisLoc(ReadSourceLocation());
 140 }
 141
 142 void ASTStmtReader::VisitDefaultStmt(DefaultStmt *S) {
 143   VisitSwitchCase(S);
 144   S->setSubStmt(Record.readSubStmt());
 145 }
 146
 147 void ASTStmtReader::VisitLabelStmt(LabelStmt *S) {
 148   VisitStmt(S);
 149   LabelDecl *LD = ReadDeclAs<LabelDecl>();
 150   LD->setStmt(S);
 151   S->setDecl(LD);
 152   S->setSubStmt(Record.readSubStmt());
 153   S->setIdentLoc(ReadSourceLocation());
 154 }
 155
 156 void ASTStmtReader::VisitAttributedStmt(AttributedStmt *S) {
 157   VisitStmt(S);
 158   uint64_t NumAttrs = Record.readInt();
 159   AttrVec Attrs;
 160   Record.readAttributes(Attrs);
 161   (void)NumAttrs;
 162   assert(NumAttrs == S->NumAttrs);
 163   assert(NumAttrs == Attrs.size());
 164   std::copy(Attrs.begin(), Attrs.end(), S->getAttrArrayPtr());
 165   S->SubStmt = Record.readSubStmt();
 166   S->AttrLoc = ReadSourceLocation();
 167 }
 168
 169 void ASTStmtReader::VisitIfStmt(IfStmt *S) {
 170   VisitStmt(S);
 171   S->setConstexpr(Record.readInt());
 172   S->setInit(Record.readSubStmt());
 173   S->setConditionVariable(Record.getContext(), ReadDeclAs<VarDecl>());
 174   S->setCond(Record.readSubExpr());
 175   S->setThen(Record.readSubStmt());
 176   S->setElse(Record.readSubStmt());
 177   S->setIfLoc(ReadSourceLocation());
 178   S->setElseLoc(ReadSourceLocation());
 179 }
 180
 181 void ASTStmtReader::VisitSwitchStmt(SwitchStmt *S) {
 182   VisitStmt(S);
 183   S->setInit(Record.readSubStmt());
 184   S->setConditionVariable(Record.getContext(), ReadDeclAs<VarDecl>());
 185   S->setCond(Record.readSubExpr());
 186   S->setBody(Record.readSubStmt());
 187   S->setSwitchLoc(ReadSourceLocation());
 188   if (Record.readInt())
 189     S->setAllEnumCasesCovered();
 190
 191   SwitchCase *PrevSC = nullptr;
 192   for (auto E = Record.size(); Record.getIdx() != E; ) {
 193     SwitchCase *SC = Record.getSwitchCaseWithID(Record.readInt());
 194     if (PrevSC)
 195       PrevSC->setNextSwitchCase(SC);
 196     else
 197       S->setSwitchCaseList(SC);
 198
 199     PrevSC = SC;
 200   }
 201 }
 202
 203 void ASTStmtReader::VisitWhileStmt(WhileStmt *S) {
 204   VisitStmt(S);
 205   S->setConditionVariable(Record.getContext(), ReadDeclAs<VarDecl>());
 206
 207   S->setCond(Record.readSubExpr());
 208   S->setBody(Record.readSubStmt());
 209   S->setWhileLoc(ReadSourceLocation());
 210 }
 211
 212 void ASTStmtReader::VisitDoStmt(DoStmt *S) {
 213   VisitStmt(S);
 214   S->setCond(Record.readSubExpr());
 215   S->setBody(Record.readSubStmt());
 216   S->setDoLoc(ReadSourceLocation());
 217   S->setWhileLoc(ReadSourceLocation());
 218   S->setRParenLoc(ReadSourceLocation());
 219 }
 220
 221 void ASTStmtReader::VisitForStmt(ForStmt *S) {
 222   VisitStmt(S);
 223   S->setInit(Record.readSubStmt());
 224   S->setCond(Record.readSubExpr());
 225   S->setConditionVariable(Record.getContext(), ReadDeclAs<VarDecl>());
 226   S->setInc(Record.readSubExpr());
 227   S->setBody(Record.readSubStmt());
 228   S->setForLoc(ReadSourceLocation());
 229   S->setLParenLoc(ReadSourceLocation());
 230   S->setRParenLoc(ReadSourceLocation());
 231 }
 232
 233 void ASTStmtReader::VisitGotoStmt(GotoStmt *S) {
 234   VisitStmt(S);
 235   S->setLabel(ReadDeclAs<LabelDecl>());
 236   S->setGotoLoc(ReadSourceLocation());
 237   S->setLabelLoc(ReadSourceLocation());
 238 }
 239
 240 void ASTStmtReader::VisitIndirectGotoStmt(IndirectGotoStmt *S) {
 241   VisitStmt(S);
 242   S->setGotoLoc(ReadSourceLocation());
 243   S->setStarLoc(ReadSourceLocation());
 244   S->setTarget(Record.readSubExpr());
 245 }
 246
 247 void ASTStmtReader::VisitContinueStmt(ContinueStmt *S) {
 248   VisitStmt(S);
 249   S->setContinueLoc(ReadSourceLocation());
 250 }
 251
 252 void ASTStmtReader::VisitBreakStmt(BreakStmt *S) {
 253   VisitStmt(S);
 254   S->setBreakLoc(ReadSourceLocation());
 255 }
 256
 257 void ASTStmtReader::VisitReturnStmt(ReturnStmt *S) {
 258   VisitStmt(S);
 259   S->setRetValue(Record.readSubExpr());
 260   S->setReturnLoc(ReadSourceLocation());
 261   S->setNRVOCandidate(ReadDeclAs<VarDecl>());
 262 }
 263
 264 void ASTStmtReader::VisitDeclStmt(DeclStmt *S) {
 265   VisitStmt(S);
 266   S->setStartLoc(ReadSourceLocation());
 267   S->setEndLoc(ReadSourceLocation());
 268
 269   if (Record.size() - Record.getIdx() == 1) {
 270     // Single declaration
 271     S->setDeclGroup(DeclGroupRef(ReadDecl()));
 272   } else {
 273     SmallVector<Decl *, 16> Decls;
 274     int N = Record.size() - Record.getIdx();
 275     Decls.reserve(N);
 276     for (int I = 0; I < N; ++I)
 277       Decls.push_back(ReadDecl());
 278     S->setDeclGroup(DeclGroupRef(DeclGroup::Create(Record.getContext(),
 279                                                    Decls.data(),
 280                                                    Decls.size())));
 281   }
 282 }
 283
 284 void ASTStmtReader::VisitAsmStmt(AsmStmt *S) {
 285   VisitStmt(S);
 286   S->NumOutputs = Record.readInt();
 287   S->NumInputs = Record.readInt();
 288   S->NumClobbers = Record.readInt();
 289   S->setAsmLoc(ReadSourceLocation());
 290   S->setVolatile(Record.readInt());
 291   S->setSimple(Record.readInt());
 292 }
 293
 294 void ASTStmtReader::VisitGCCAsmStmt(GCCAsmStmt *S) {
 295   VisitAsmStmt(S);
 296   S->setRParenLoc(ReadSourceLocation());
 297   S->setAsmString(cast_or_null<StringLiteral>(Record.readSubStmt()));
 298
 299   unsigned NumOutputs = S->getNumOutputs();
 300   unsigned NumInputs = S->getNumInputs();
 301   unsigned NumClobbers = S->getNumClobbers();
 302
 303   // Outputs and inputs
 304   SmallVector<IdentifierInfo *, 16> Names;
 305   SmallVector<StringLiteral*, 16> Constraints;
 306   SmallVector<Stmt*, 16> Exprs;
 307   for (unsigned I = 0, N = NumOutputs + NumInputs; I != N; ++I) {
 308     Names.push_back(Record.getIdentifierInfo());
 309     Constraints.push_back(cast_or_null<StringLiteral>(Record.readSubStmt()));
 310     Exprs.push_back(Record.readSubStmt());
 311   }
 312
 313   // Constraints
 314   SmallVector<StringLiteral*, 16> Clobbers;
 315   for (unsigned I = 0; I != NumClobbers; ++I)
 316     Clobbers.push_back(cast_or_null<StringLiteral>(Record.readSubStmt()));
 317
 318   S->setOutputsAndInputsAndClobbers(Record.getContext(),
 319                                     Names.data(), Constraints.data(),
 320                                     Exprs.data(), NumOutputs, NumInputs,
 321                                     Clobbers.data(), NumClobbers);
 322 }
 323
 324 void ASTStmtReader::VisitMSAsmStmt(MSAsmStmt *S) {
 325   VisitAsmStmt(S);
 326   S->LBraceLoc = ReadSourceLocation();
 327   S->EndLoc = ReadSourceLocation();
 328   S->NumAsmToks = Record.readInt();
 329   std::string AsmStr = ReadString();
 330
 331   // Read the tokens.
 332   SmallVector<Token, 16> AsmToks;
 333   AsmToks.reserve(S->NumAsmToks);
 334   for (unsigned i = 0, e = S->NumAsmToks; i != e; ++i) {
 335     AsmToks.push_back(Record.readToken());
 336   }
 337
 338   // The calls to reserve() for the FooData vectors are mandatory to
 339   // prevent dead StringRefs in the Foo vectors.
 340
 341   // Read the clobbers.
 342   SmallVector<std::string, 16> ClobbersData;
 343   SmallVector<StringRef, 16> Clobbers;
 344   ClobbersData.reserve(S->NumClobbers);
 345   Clobbers.reserve(S->NumClobbers);
 346   for (unsigned i = 0, e = S->NumClobbers; i != e; ++i) {
 347     ClobbersData.push_back(ReadString());
 348     Clobbers.push_back(ClobbersData.back());
 349   }
 350
 351   // Read the operands.
 352   unsigned NumOperands = S->NumOutputs + S->NumInputs;
 353   SmallVector<Expr*, 16> Exprs;
 354   SmallVector<std::string, 16> ConstraintsData;
 355   SmallVector<StringRef, 16> Constraints;
 356   Exprs.reserve(NumOperands);
 357   ConstraintsData.reserve(NumOperands);
 358   Constraints.reserve(NumOperands);
 359   for (unsigned i = 0; i != NumOperands; ++i) {
 360     Exprs.push_back(cast<Expr>(Record.readSubStmt()));
 361     ConstraintsData.push_back(ReadString());
 362     Constraints.push_back(ConstraintsData.back());
 363   }
 364
 365   S->initialize(Record.getContext(), AsmStr, AsmToks,
 366                 Constraints, Exprs, Clobbers);
 367 }
 368
 369 void ASTStmtReader::VisitCoroutineBodyStmt(CoroutineBodyStmt *S) {
 370   // FIXME: Implement coroutine serialization.
 371   llvm_unreachable("unimplemented");
 372 }
 373
 374 void ASTStmtReader::VisitCoreturnStmt(CoreturnStmt *S) {
 375   // FIXME: Implement coroutine serialization.
 376   llvm_unreachable("unimplemented");
 377 }
 378
 379 void ASTStmtReader::VisitCoawaitExpr(CoawaitExpr *S) {
 380   // FIXME: Implement coroutine serialization.
 381   llvm_unreachable("unimplemented");
 382 }
 383
 384 void ASTStmtReader::VisitCoyieldExpr(CoyieldExpr *S) {
 385   // FIXME: Implement coroutine serialization.
 386   llvm_unreachable("unimplemented");
 387 }
 388
 389 void ASTStmtReader::VisitCapturedStmt(CapturedStmt *S) {
 390   VisitStmt(S);
 391   Record.skipInts(1);
 392   S->setCapturedDecl(ReadDeclAs<CapturedDecl>());
 393   S->setCapturedRegionKind(static_cast<CapturedRegionKind>(Record.readInt()));
 394   S->setCapturedRecordDecl(ReadDeclAs<RecordDecl>());
 395
 396   // Capture inits
 397   for (CapturedStmt::capture_init_iterator I = S->capture_init_begin(),
 398                                            E = S->capture_init_end();
 399        I != E; ++I)
 400     *I = Record.readSubExpr();
 401
 402   // Body
 403   S->setCapturedStmt(Record.readSubStmt());
 404   S->getCapturedDecl()->setBody(S->getCapturedStmt());
 405
 406   // Captures
 407   for (auto &I : S->captures()) {
 408     I.VarAndKind.setPointer(ReadDeclAs<VarDecl>());
 409     I.VarAndKind.setInt(
 410         static_cast<CapturedStmt::VariableCaptureKind>(Record.readInt()));
 411     I.Loc = ReadSourceLocation();
 412   }
 413 }
 414
 415 void ASTStmtReader::VisitExpr(Expr *E) {
 416   VisitStmt(E);
 417   E->setType(Record.readType());
 418   E->setTypeDependent(Record.readInt());
 419   E->setValueDependent(Record.readInt());
 420   E->setInstantiationDependent(Record.readInt());
 421   E->ExprBits.ContainsUnexpandedParameterPack = Record.readInt();
 422   E->setValueKind(static_cast<ExprValueKind>(Record.readInt()));
 423   E->setObjectKind(static_cast<ExprObjectKind>(Record.readInt()));
 424   assert(Record.getIdx() == NumExprFields &&
 425          "Incorrect expression field count");
 426 }
 427
 428 void ASTStmtReader::VisitPredefinedExpr(PredefinedExpr *E) {
 429   VisitExpr(E);
 430   E->setLocation(ReadSourceLocation());
 431   E->Type = (PredefinedExpr::IdentType)Record.readInt();
 432   E->FnName = cast_or_null<StringLiteral>(Record.readSubExpr());
 433 }
 434
 435 void ASTStmtReader::VisitDeclRefExpr(DeclRefExpr *E) {
 436   VisitExpr(E);
 437
 438   E->DeclRefExprBits.HasQualifier = Record.readInt();
 439   E->DeclRefExprBits.HasFoundDecl = Record.readInt();
 440   E->DeclRefExprBits.HasTemplateKWAndArgsInfo = Record.readInt();
 441   E->DeclRefExprBits.HadMultipleCandidates = Record.readInt();
 442   E->DeclRefExprBits.RefersToEnclosingVariableOrCapture = Record.readInt();
 443   unsigned NumTemplateArgs = 0;
 444   if (E->hasTemplateKWAndArgsInfo())
 445     NumTemplateArgs = Record.readInt();
 446
 447   if (E->hasQualifier())
 448     new (E->getTrailingObjects<NestedNameSpecifierLoc>())
 449         NestedNameSpecifierLoc(Record.readNestedNameSpecifierLoc());
 450
 451   if (E->hasFoundDecl())
 452     *E->getTrailingObjects<NamedDecl *>() = ReadDeclAs<NamedDecl>();
 453
 454   if (E->hasTemplateKWAndArgsInfo())
 455     ReadTemplateKWAndArgsInfo(
 456         *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(),
 457         E->getTrailingObjects<TemplateArgumentLoc>(), NumTemplateArgs);
 458
 459   E->setDecl(ReadDeclAs<ValueDecl>());
 460   E->setLocation(ReadSourceLocation());
 461   ReadDeclarationNameLoc(E->DNLoc, E->getDecl()->getDeclName());
 462 }
 463
 464 void ASTStmtReader::VisitIntegerLiteral(IntegerLiteral *E) {
 465   VisitExpr(E);
 466   E->setLocation(ReadSourceLocation());
 467   E->setValue(Record.getContext(), Record.readAPInt());
 468 }
 469
 470 void ASTStmtReader::VisitFloatingLiteral(FloatingLiteral *E) {
 471   VisitExpr(E);
 472   E->setRawSemantics(static_cast<Stmt::APFloatSemantics>(Record.readInt()));
 473   E->setExact(Record.readInt());
 474   E->setValue(Record.getContext(), Record.readAPFloat(E->getSemantics()));
 475   E->setLocation(ReadSourceLocation());
 476 }
 477
 478 void ASTStmtReader::VisitImaginaryLiteral(ImaginaryLiteral *E) {
 479   VisitExpr(E);
 480   E->setSubExpr(Record.readSubExpr());
 481 }
 482
 483 void ASTStmtReader::VisitStringLiteral(StringLiteral *E) {
 484   VisitExpr(E);
 485   unsigned Len = Record.readInt();
 486   assert(Record.peekInt() == E->getNumConcatenated() &&
 487          "Wrong number of concatenated tokens!");
 488   Record.skipInts(1);
 489   StringLiteral::StringKind kind =
 490         static_cast<StringLiteral::StringKind>(Record.readInt());
 491   bool isPascal = Record.readInt();
 492
 493   // Read string data
 494   auto B = &Record.peekInt();
 495   SmallString<16> Str(B, B + Len);
 496   E->setString(Record.getContext(), Str, kind, isPascal);
 497   Record.skipInts(Len);
 498
 499   // Read source locations
 500   for (unsigned I = 0, N = E->getNumConcatenated(); I != N; ++I)
 501     E->setStrTokenLoc(I, ReadSourceLocation());
 502 }
 503
 504 void ASTStmtReader::VisitCharacterLiteral(CharacterLiteral *E) {
 505   VisitExpr(E);
 506   E->setValue(Record.readInt());
 507   E->setLocation(ReadSourceLocation());
 508   E->setKind(static_cast<CharacterLiteral::CharacterKind>(Record.readInt()));
 509 }
 510
 511 void ASTStmtReader::VisitParenExpr(ParenExpr *E) {
 512   VisitExpr(E);
 513   E->setLParen(ReadSourceLocation());
 514   E->setRParen(ReadSourceLocation());
 515   E->setSubExpr(Record.readSubExpr());
 516 }
 517
 518 void ASTStmtReader::VisitParenListExpr(ParenListExpr *E) {
 519   VisitExpr(E);
 520   unsigned NumExprs = Record.readInt();
 521   E->Exprs = new (Record.getContext()) Stmt*[NumExprs];
 522   for (unsigned i = 0; i != NumExprs; ++i)
 523     E->Exprs[i] = Record.readSubStmt();
 524   E->NumExprs = NumExprs;
 525   E->LParenLoc = ReadSourceLocation();
 526   E->RParenLoc = ReadSourceLocation();
 527 }
 528
 529 void ASTStmtReader::VisitUnaryOperator(UnaryOperator *E) {
 530   VisitExpr(E);
 531   E->setSubExpr(Record.readSubExpr());
 532   E->setOpcode((UnaryOperator::Opcode)Record.readInt());
 533   E->setOperatorLoc(ReadSourceLocation());
 534 }
 535
 536 void ASTStmtReader::VisitOffsetOfExpr(OffsetOfExpr *E) {
 537   VisitExpr(E);
 538   assert(E->getNumComponents() == Record.peekInt());
 539   Record.skipInts(1);
 540   assert(E->getNumExpressions() == Record.peekInt());
 541   Record.skipInts(1);
 542   E->setOperatorLoc(ReadSourceLocation());
 543   E->setRParenLoc(ReadSourceLocation());
 544   E->setTypeSourceInfo(GetTypeSourceInfo());
 545   for (unsigned I = 0, N = E->getNumComponents(); I != N; ++I) {
 546     OffsetOfNode::Kind Kind = static_cast<OffsetOfNode::Kind>(Record.readInt());
 547     SourceLocation Start = ReadSourceLocation();
 548     SourceLocation End = ReadSourceLocation();
 549     switch (Kind) {
 550     case OffsetOfNode::Array:
 551       E->setComponent(I, OffsetOfNode(Start, Record.readInt(), End));
 552       break;
 553
 554     case OffsetOfNode::Field:
 555       E->setComponent(
 556           I, OffsetOfNode(Start, ReadDeclAs<FieldDecl>(), End));
 557       break;
 558
 559     case OffsetOfNode::Identifier:
 560       E->setComponent(
 561           I,
 562           OffsetOfNode(Start, Record.getIdentifierInfo(), End));
 563       break;
 564
 565     case OffsetOfNode::Base: {
 566       CXXBaseSpecifier *Base = new (Record.getContext()) CXXBaseSpecifier();
 567       *Base = Record.readCXXBaseSpecifier();
 568       E->setComponent(I, OffsetOfNode(Base));
 569       break;
 570     }
 571     }
 572   }
 573
 574   for (unsigned I = 0, N = E->getNumExpressions(); I != N; ++I)
 575     E->setIndexExpr(I, Record.readSubExpr());
 576 }
 577
 578 void ASTStmtReader::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E) {
 579   VisitExpr(E);
 580   E->setKind(static_cast<UnaryExprOrTypeTrait>(Record.readInt()));
 581   if (Record.peekInt() == 0) {
 582     E->setArgument(Record.readSubExpr());
 583     Record.skipInts(1);
 584   } else {
 585     E->setArgument(GetTypeSourceInfo());
 586   }
 587   E->setOperatorLoc(ReadSourceLocation());
 588   E->setRParenLoc(ReadSourceLocation());
 589 }
 590
 591 void ASTStmtReader::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
 592   VisitExpr(E);
 593   E->setLHS(Record.readSubExpr());
 594   E->setRHS(Record.readSubExpr());
 595   E->setRBracketLoc(ReadSourceLocation());
 596 }
 597
 598 void ASTStmtReader::VisitOMPArraySectionExpr(OMPArraySectionExpr *E) {
 599   VisitExpr(E);
 600   E->setBase(Record.readSubExpr());
 601   E->setLowerBound(Record.readSubExpr());
 602   E->setLength(Record.readSubExpr());
 603   E->setColonLoc(ReadSourceLocation());
 604   E->setRBracketLoc(ReadSourceLocation());
 605 }
 606
 607 void ASTStmtReader::VisitCallExpr(CallExpr *E) {
 608   VisitExpr(E);
 609   E->setNumArgs(Record.getContext(), Record.readInt());
 610   E->setRParenLoc(ReadSourceLocation());
 611   E->setCallee(Record.readSubExpr());
 612   for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
 613     E->setArg(I, Record.readSubExpr());
 614 }
 615
 616 void ASTStmtReader::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
 617   VisitCallExpr(E);
 618 }
 619
 620 void ASTStmtReader::VisitMemberExpr(MemberExpr *E) {
 621   // Don't call VisitExpr, this is fully initialized at creation.
 622   assert(E->getStmtClass() == Stmt::MemberExprClass &&
 623          "It's a subclass, we must advance Idx!");
 624 }
 625
 626 void ASTStmtReader::VisitObjCIsaExpr(ObjCIsaExpr *E) {
 627   VisitExpr(E);
 628   E->setBase(Record.readSubExpr());
 629   E->setIsaMemberLoc(ReadSourceLocation());
 630   E->setOpLoc(ReadSourceLocation());
 631   E->setArrow(Record.readInt());
 632 }
 633
 634 void ASTStmtReader::
 635 VisitObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *E) {
 636   VisitExpr(E);
 637   E->Operand = Record.readSubExpr();
 638   E->setShouldCopy(Record.readInt());
 639 }
 640
 641 void ASTStmtReader::VisitObjCBridgedCastExpr(ObjCBridgedCastExpr *E) {
 642   VisitExplicitCastExpr(E);
 643   E->LParenLoc = ReadSourceLocation();
 644   E->BridgeKeywordLoc = ReadSourceLocation();
 645   E->Kind = Record.readInt();
 646 }
 647
 648 void ASTStmtReader::VisitCastExpr(CastExpr *E) {
 649   VisitExpr(E);
 650   unsigned NumBaseSpecs = Record.readInt();
 651   assert(NumBaseSpecs == E->path_size());
 652   E->setSubExpr(Record.readSubExpr());
 653   E->setCastKind((CastKind)Record.readInt());
 654   CastExpr::path_iterator BaseI = E->path_begin();
 655   while (NumBaseSpecs--) {
 656     CXXBaseSpecifier *BaseSpec = new (Record.getContext()) CXXBaseSpecifier;
 657     *BaseSpec = Record.readCXXBaseSpecifier();
 658     *BaseI++ = BaseSpec;
 659   }
 660 }
 661
 662 void ASTStmtReader::VisitBinaryOperator(BinaryOperator *E) {
 663   VisitExpr(E);
 664   E->setLHS(Record.readSubExpr());
 665   E->setRHS(Record.readSubExpr());
 666   E->setOpcode((BinaryOperator::Opcode)Record.readInt());
 667   E->setOperatorLoc(ReadSourceLocation());
 668   E->setFPContractable((bool)Record.readInt());
 669 }
 670
 671 void ASTStmtReader::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
 672   VisitBinaryOperator(E);
 673   E->setComputationLHSType(Record.readType());
 674   E->setComputationResultType(Record.readType());
 675 }
 676
 677 void ASTStmtReader::VisitConditionalOperator(ConditionalOperator *E) {
 678   VisitExpr(E);
 679   E->SubExprs[ConditionalOperator::COND] = Record.readSubExpr();
 680   E->SubExprs[ConditionalOperator::LHS] = Record.readSubExpr();
 681   E->SubExprs[ConditionalOperator::RHS] = Record.readSubExpr();
 682   E->QuestionLoc = ReadSourceLocation();
 683   E->ColonLoc = ReadSourceLocation();
 684 }
 685
 686 void
 687 ASTStmtReader::VisitBinaryConditionalOperator(BinaryConditionalOperator *E) {
 688   VisitExpr(E);
 689   E->OpaqueValue = cast<OpaqueValueExpr>(Record.readSubExpr());
 690   E->SubExprs[BinaryConditionalOperator::COMMON] = Record.readSubExpr();
 691   E->SubExprs[BinaryConditionalOperator::COND] = Record.readSubExpr();
 692   E->SubExprs[BinaryConditionalOperator::LHS] = Record.readSubExpr();
 693   E->SubExprs[BinaryConditionalOperator::RHS] = Record.readSubExpr();
 694   E->QuestionLoc = ReadSourceLocation();
 695   E->ColonLoc = ReadSourceLocation();
 696 }
 697
 698 void ASTStmtReader::VisitImplicitCastExpr(ImplicitCastExpr *E) {
 699   VisitCastExpr(E);
 700 }
 701
 702 void ASTStmtReader::VisitExplicitCastExpr(ExplicitCastExpr *E) {
 703   VisitCastExpr(E);
 704   E->setTypeInfoAsWritten(GetTypeSourceInfo());
 705 }
 706
 707 void ASTStmtReader::VisitCStyleCastExpr(CStyleCastExpr *E) {
 708   VisitExplicitCastExpr(E);
 709   E->setLParenLoc(ReadSourceLocation());
 710   E->setRParenLoc(ReadSourceLocation());
 711 }
 712
 713 void ASTStmtReader::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
 714   VisitExpr(E);
 715   E->setLParenLoc(ReadSourceLocation());
 716   E->setTypeSourceInfo(GetTypeSourceInfo());
 717   E->setInitializer(Record.readSubExpr());
 718   E->setFileScope(Record.readInt());
 719 }
 720
 721 void ASTStmtReader::VisitExtVectorElementExpr(ExtVectorElementExpr *E) {
 722   VisitExpr(E);
 723   E->setBase(Record.readSubExpr());
 724   E->setAccessor(Record.getIdentifierInfo());
 725   E->setAccessorLoc(ReadSourceLocation());
 726 }
 727
 728 void ASTStmtReader::VisitInitListExpr(InitListExpr *E) {
 729   VisitExpr(E);
 730   if (InitListExpr *SyntForm = cast_or_null<InitListExpr>(Record.readSubStmt()))
 731     E->setSyntacticForm(SyntForm);
 732   E->setLBraceLoc(ReadSourceLocation());
 733   E->setRBraceLoc(ReadSourceLocation());
 734   bool isArrayFiller = Record.readInt();
 735   Expr *filler = nullptr;
 736   if (isArrayFiller) {
 737     filler = Record.readSubExpr();
 738     E->ArrayFillerOrUnionFieldInit = filler;
 739   } else
 740     E->ArrayFillerOrUnionFieldInit = ReadDeclAs<FieldDecl>();
 741   E->sawArrayRangeDesignator(Record.readInt());
 742   unsigned NumInits = Record.readInt();
 743   E->reserveInits(Record.getContext(), NumInits);
 744   if (isArrayFiller) {
 745     for (unsigned I = 0; I != NumInits; ++I) {
 746       Expr *init = Record.readSubExpr();
 747       E->updateInit(Record.getContext(), I, init ? init : filler);
 748     }
 749   } else {
 750     for (unsigned I = 0; I != NumInits; ++I)
 751       E->updateInit(Record.getContext(), I, Record.readSubExpr());
 752   }
 753 }
 754
 755 void ASTStmtReader::VisitDesignatedInitExpr(DesignatedInitExpr *E) {
 756   typedef DesignatedInitExpr::Designator Designator;
 757
 758   VisitExpr(E);
 759   unsigned NumSubExprs = Record.readInt();
 760   assert(NumSubExprs == E->getNumSubExprs() && "Wrong number of subexprs");
 761   for (unsigned I = 0; I != NumSubExprs; ++I)
 762     E->setSubExpr(I, Record.readSubExpr());
 763   E->setEqualOrColonLoc(ReadSourceLocation());
 764   E->setGNUSyntax(Record.readInt());
 765
 766   SmallVector<Designator, 4> Designators;
 767   while (Record.getIdx() < Record.size()) {
 768     switch ((DesignatorTypes)Record.readInt()) {
 769     case DESIG_FIELD_DECL: {
 770       FieldDecl *Field = ReadDeclAs<FieldDecl>();
 771       SourceLocation DotLoc = ReadSourceLocation();
 772       SourceLocation FieldLoc = ReadSourceLocation();
 773       Designators.push_back(Designator(Field->getIdentifier(), DotLoc,
 774                                        FieldLoc));
 775       Designators.back().setField(Field);
 776       break;
 777     }
 778
 779     case DESIG_FIELD_NAME: {
 780       const IdentifierInfo *Name = Record.getIdentifierInfo();
 781       SourceLocation DotLoc = ReadSourceLocation();
 782       SourceLocation FieldLoc = ReadSourceLocation();
 783       Designators.push_back(Designator(Name, DotLoc, FieldLoc));
 784       break;
 785     }
 786
 787     case DESIG_ARRAY: {
 788       unsigned Index = Record.readInt();
 789       SourceLocation LBracketLoc = ReadSourceLocation();
 790       SourceLocation RBracketLoc = ReadSourceLocation();
 791       Designators.push_back(Designator(Index, LBracketLoc, RBracketLoc));
 792       break;
 793     }
 794
 795     case DESIG_ARRAY_RANGE: {
 796       unsigned Index = Record.readInt();
 797       SourceLocation LBracketLoc = ReadSourceLocation();
 798       SourceLocation EllipsisLoc = ReadSourceLocation();
 799       SourceLocation RBracketLoc = ReadSourceLocation();
 800       Designators.push_back(Designator(Index, LBracketLoc, EllipsisLoc,
 801                                        RBracketLoc));
 802       break;
 803     }
 804     }
 805   }
 806   E->setDesignators(Record.getContext(),
 807                     Designators.data(), Designators.size());
 808 }
 809
 810 void ASTStmtReader::VisitDesignatedInitUpdateExpr(DesignatedInitUpdateExpr *E) {
 811   VisitExpr(E);
 812   E->setBase(Record.readSubExpr());
 813   E->setUpdater(Record.readSubExpr());
 814 }
 815
 816 void ASTStmtReader::VisitNoInitExpr(NoInitExpr *E) {
 817   VisitExpr(E);
 818 }
 819
 820 void ASTStmtReader::VisitArrayInitLoopExpr(ArrayInitLoopExpr *E) {
 821   VisitExpr(E);
 822   E->SubExprs[0] = Record.readSubExpr();
 823   E->SubExprs[1] = Record.readSubExpr();
 824 }
 825
 826 void ASTStmtReader::VisitArrayInitIndexExpr(ArrayInitIndexExpr *E) {
 827   VisitExpr(E);
 828 }
 829
 830 void ASTStmtReader::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
 831   VisitExpr(E);
 832 }
 833
 834 void ASTStmtReader::VisitVAArgExpr(VAArgExpr *E) {
 835   VisitExpr(E);
 836   E->setSubExpr(Record.readSubExpr());
 837   E->setWrittenTypeInfo(GetTypeSourceInfo());
 838   E->setBuiltinLoc(ReadSourceLocation());
 839   E->setRParenLoc(ReadSourceLocation());
 840   E->setIsMicrosoftABI(Record.readInt());
 841 }
 842
 843 void ASTStmtReader::VisitAddrLabelExpr(AddrLabelExpr *E) {
 844   VisitExpr(E);
 845   E->setAmpAmpLoc(ReadSourceLocation());
 846   E->setLabelLoc(ReadSourceLocation());
 847   E->setLabel(ReadDeclAs<LabelDecl>());
 848 }
 849
 850 void ASTStmtReader::VisitStmtExpr(StmtExpr *E) {
 851   VisitExpr(E);
 852   E->setLParenLoc(ReadSourceLocation());
 853   E->setRParenLoc(ReadSourceLocation());
 854   E->setSubStmt(cast_or_null<CompoundStmt>(Record.readSubStmt()));
 855 }
 856
 857 void ASTStmtReader::VisitChooseExpr(ChooseExpr *E) {
 858   VisitExpr(E);
 859   E->setCond(Record.readSubExpr());
 860   E->setLHS(Record.readSubExpr());
 861   E->setRHS(Record.readSubExpr());
 862   E->setBuiltinLoc(ReadSourceLocation());
 863   E->setRParenLoc(ReadSourceLocation());
 864   E->setIsConditionTrue(Record.readInt());
 865 }
 866
 867 void ASTStmtReader::VisitGNUNullExpr(GNUNullExpr *E) {
 868   VisitExpr(E);
 869   E->setTokenLocation(ReadSourceLocation());
 870 }
 871
 872 void ASTStmtReader::VisitShuffleVectorExpr(ShuffleVectorExpr *E) {
 873   VisitExpr(E);
 874   SmallVector<Expr *, 16> Exprs;
 875   unsigned NumExprs = Record.readInt();
 876   while (NumExprs--)
 877     Exprs.push_back(Record.readSubExpr());
 878   E->setExprs(Record.getContext(), Exprs);
 879   E->setBuiltinLoc(ReadSourceLocation());
 880   E->setRParenLoc(ReadSourceLocation());
 881 }
 882
 883 void ASTStmtReader::VisitConvertVectorExpr(ConvertVectorExpr *E) {
 884   VisitExpr(E);
 885   E->BuiltinLoc = ReadSourceLocation();
 886   E->RParenLoc = ReadSourceLocation();
 887   E->TInfo = GetTypeSourceInfo();
 888   E->SrcExpr = Record.readSubExpr();
 889 }
 890
 891 void ASTStmtReader::VisitBlockExpr(BlockExpr *E) {
 892   VisitExpr(E);
 893   E->setBlockDecl(ReadDeclAs<BlockDecl>());
 894 }
 895
 896 void ASTStmtReader::VisitGenericSelectionExpr(GenericSelectionExpr *E) {
 897   VisitExpr(E);
 898   E->NumAssocs = Record.readInt();
 899   E->AssocTypes = new (Record.getContext()) TypeSourceInfo*[E->NumAssocs];
 900   E->SubExprs =
 901    new(Record.getContext()) Stmt*[GenericSelectionExpr::END_EXPR+E->NumAssocs];
 902
 903   E->SubExprs[GenericSelectionExpr::CONTROLLING] = Record.readSubExpr();
 904   for (unsigned I = 0, N = E->getNumAssocs(); I != N; ++I) {
 905     E->AssocTypes[I] = GetTypeSourceInfo();
 906     E->SubExprs[GenericSelectionExpr::END_EXPR+I] = Record.readSubExpr();
 907   }
 908   E->ResultIndex = Record.readInt();
 909
 910   E->GenericLoc = ReadSourceLocation();
 911   E->DefaultLoc = ReadSourceLocation();
 912   E->RParenLoc = ReadSourceLocation();
 913 }
 914
 915 void ASTStmtReader::VisitPseudoObjectExpr(PseudoObjectExpr *E) {
 916   VisitExpr(E);
 917   unsigned numSemanticExprs = Record.readInt();
 918   assert(numSemanticExprs + 1 == E->PseudoObjectExprBits.NumSubExprs);
 919   E->PseudoObjectExprBits.ResultIndex = Record.readInt();
 920
 921   // Read the syntactic expression.
 922   E->getSubExprsBuffer()[0] = Record.readSubExpr();
 923
 924   // Read all the semantic expressions.
 925   for (unsigned i = 0; i != numSemanticExprs; ++i) {
 926     Expr *subExpr = Record.readSubExpr();
 927     E->getSubExprsBuffer()[i+1] = subExpr;
 928   }
 929 }
 930
 931 void ASTStmtReader::VisitAtomicExpr(AtomicExpr *E) {
 932   VisitExpr(E);
 933   E->Op = AtomicExpr::AtomicOp(Record.readInt());
 934   E->NumSubExprs = AtomicExpr::getNumSubExprs(E->Op);
 935   for (unsigned I = 0; I != E->NumSubExprs; ++I)
 936     E->SubExprs[I] = Record.readSubExpr();
 937   E->BuiltinLoc = ReadSourceLocation();
 938   E->RParenLoc = ReadSourceLocation();
 939 }
 940
 941 //===----------------------------------------------------------------------===//
 942 // Objective-C Expressions and Statements
 943
 944 void ASTStmtReader::VisitObjCStringLiteral(ObjCStringLiteral *E) {
 945   VisitExpr(E);
 946   E->setString(cast<StringLiteral>(Record.readSubStmt()));
 947   E->setAtLoc(ReadSourceLocation());
 948 }
 949
 950 void ASTStmtReader::VisitObjCBoxedExpr(ObjCBoxedExpr *E) {
 951   VisitExpr(E);
 952   // could be one of several IntegerLiteral, FloatLiteral, etc.
 953   E->SubExpr = Record.readSubStmt();
 954   E->BoxingMethod = ReadDeclAs<ObjCMethodDecl>();
 955   E->Range = ReadSourceRange();
 956 }
 957
 958 void ASTStmtReader::VisitObjCArrayLiteral(ObjCArrayLiteral *E) {
 959   VisitExpr(E);
 960   unsigned NumElements = Record.readInt();
 961   assert(NumElements == E->getNumElements() && "Wrong number of elements");
 962   Expr **Elements = E->getElements();
 963   for (unsigned I = 0, N = NumElements; I != N; ++I)
 964     Elements[I] = Record.readSubExpr();
 965   E->ArrayWithObjectsMethod = ReadDeclAs<ObjCMethodDecl>();
 966   E->Range = ReadSourceRange();
 967 }
 968
 969 void ASTStmtReader::VisitObjCDictionaryLiteral(ObjCDictionaryLiteral *E) {
 970   VisitExpr(E);
 971   unsigned NumElements = Record.readInt();
 972   assert(NumElements == E->getNumElements() && "Wrong number of elements");
 973   bool HasPackExpansions = Record.readInt();
 974   assert(HasPackExpansions == E->HasPackExpansions &&"Pack expansion mismatch");
 975   ObjCDictionaryLiteral::KeyValuePair *KeyValues =
 976       E->getTrailingObjects<ObjCDictionaryLiteral::KeyValuePair>();
 977   ObjCDictionaryLiteral::ExpansionData *Expansions =
 978       E->getTrailingObjects<ObjCDictionaryLiteral::ExpansionData>();
 979   for (unsigned I = 0; I != NumElements; ++I) {
 980     KeyValues[I].Key = Record.readSubExpr();
 981     KeyValues[I].Value = Record.readSubExpr();
 982     if (HasPackExpansions) {
 983       Expansions[I].EllipsisLoc = ReadSourceLocation();
 984       Expansions[I].NumExpansionsPlusOne = Record.readInt();
 985     }
 986   }
 987   E->DictWithObjectsMethod = ReadDeclAs<ObjCMethodDecl>();
 988   E->Range = ReadSourceRange();
 989 }
 990
 991 void ASTStmtReader::VisitObjCEncodeExpr(ObjCEncodeExpr *E) {
 992   VisitExpr(E);
 993   E->setEncodedTypeSourceInfo(GetTypeSourceInfo());
 994   E->setAtLoc(ReadSourceLocation());
 995   E->setRParenLoc(ReadSourceLocation());
 996 }
 997
 998 void ASTStmtReader::VisitObjCSelectorExpr(ObjCSelectorExpr *E) {
 999   VisitExpr(E);
1000   E->setSelector(Record.readSelector());
1001   E->setAtLoc(ReadSourceLocation());
1002   E->setRParenLoc(ReadSourceLocation());
1003 }
1004
1005 void ASTStmtReader::VisitObjCProtocolExpr(ObjCProtocolExpr *E) {
1006   VisitExpr(E);
1007   E->setProtocol(ReadDeclAs<ObjCProtocolDecl>());
1008   E->setAtLoc(ReadSourceLocation());
1009   E->ProtoLoc = ReadSourceLocation();
1010   E->setRParenLoc(ReadSourceLocation());
1011 }
1012
1013 void ASTStmtReader::VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
1014   VisitExpr(E);
1015   E->setDecl(ReadDeclAs<ObjCIvarDecl>());
1016   E->setLocation(ReadSourceLocation());
1017   E->setOpLoc(ReadSourceLocation());
1018   E->setBase(Record.readSubExpr());
1019   E->setIsArrow(Record.readInt());
1020   E->setIsFreeIvar(Record.readInt());
1021 }
1022
1023 void ASTStmtReader::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
1024   VisitExpr(E);
1025   unsigned MethodRefFlags = Record.readInt();
1026   bool Implicit = Record.readInt() != 0;
1027   if (Implicit) {
1028     ObjCMethodDecl *Getter = ReadDeclAs<ObjCMethodDecl>();
1029     ObjCMethodDecl *Setter = ReadDeclAs<ObjCMethodDecl>();
1030     E->setImplicitProperty(Getter, Setter, MethodRefFlags);
1031   } else {
1032     E->setExplicitProperty(ReadDeclAs<ObjCPropertyDecl>(), MethodRefFlags);
1033   }
1034   E->setLocation(ReadSourceLocation());
1035   E->setReceiverLocation(ReadSourceLocation());
1036   switch (Record.readInt()) {
1037   case 0:
1038     E->setBase(Record.readSubExpr());
1039     break;
1040   case 1:
1041     E->setSuperReceiver(Record.readType());
1042     break;
1043   case 2:
1044     E->setClassReceiver(ReadDeclAs<ObjCInterfaceDecl>());
1045     break;
1046   }
1047 }
1048
1049 void ASTStmtReader::VisitObjCSubscriptRefExpr(ObjCSubscriptRefExpr *E) {
1050   VisitExpr(E);
1051   E->setRBracket(ReadSourceLocation());
1052   E->setBaseExpr(Record.readSubExpr());
1053   E->setKeyExpr(Record.readSubExpr());
1054   E->GetAtIndexMethodDecl = ReadDeclAs<ObjCMethodDecl>();
1055   E->SetAtIndexMethodDecl = ReadDeclAs<ObjCMethodDecl>();
1056 }
1057
1058 void ASTStmtReader::VisitObjCMessageExpr(ObjCMessageExpr *E) {
1059   VisitExpr(E);
1060   assert(Record.peekInt() == E->getNumArgs());
1061   Record.skipInts(1);
1062   unsigned NumStoredSelLocs = Record.readInt();
1063   E->SelLocsKind = Record.readInt();
1064   E->setDelegateInitCall(Record.readInt());
1065   E->IsImplicit = Record.readInt();
1066   ObjCMessageExpr::ReceiverKind Kind
1067     = static_cast<ObjCMessageExpr::ReceiverKind>(Record.readInt());
1068   switch (Kind) {
1069   case ObjCMessageExpr::Instance:
1070     E->setInstanceReceiver(Record.readSubExpr());
1071     break;
1072
1073   case ObjCMessageExpr::Class:
1074     E->setClassReceiver(GetTypeSourceInfo());
1075     break;
1076
1077   case ObjCMessageExpr::SuperClass:
1078   case ObjCMessageExpr::SuperInstance: {
1079     QualType T = Record.readType();
1080     SourceLocation SuperLoc = ReadSourceLocation();
1081     E->setSuper(SuperLoc, T, Kind == ObjCMessageExpr::SuperInstance);
1082     break;
1083   }
1084   }
1085
1086   assert(Kind == E->getReceiverKind());
1087
1088   if (Record.readInt())
1089     E->setMethodDecl(ReadDeclAs<ObjCMethodDecl>());
1090   else
1091     E->setSelector(Record.readSelector());
1092
1093   E->LBracLoc = ReadSourceLocation();
1094   E->RBracLoc = ReadSourceLocation();
1095
1096   for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
1097     E->setArg(I, Record.readSubExpr());
1098
1099   SourceLocation *Locs = E->getStoredSelLocs();
1100   for (unsigned I = 0; I != NumStoredSelLocs; ++I)
1101     Locs[I] = ReadSourceLocation();
1102 }
1103
1104 void ASTStmtReader::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) {
1105   VisitStmt(S);
1106   S->setElement(Record.readSubStmt());
1107   S->setCollection(Record.readSubExpr());
1108   S->setBody(Record.readSubStmt());
1109   S->setForLoc(ReadSourceLocation());
1110   S->setRParenLoc(ReadSourceLocation());
1111 }
1112
1113 void ASTStmtReader::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) {
1114   VisitStmt(S);
1115   S->setCatchBody(Record.readSubStmt());
1116   S->setCatchParamDecl(ReadDeclAs<VarDecl>());
1117   S->setAtCatchLoc(ReadSourceLocation());
1118   S->setRParenLoc(ReadSourceLocation());
1119 }
1120
1121 void ASTStmtReader::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
1122   VisitStmt(S);
1123   S->setFinallyBody(Record.readSubStmt());
1124   S->setAtFinallyLoc(ReadSourceLocation());
1125 }
1126
1127 void ASTStmtReader::VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S) {
1128   VisitStmt(S);
1129   S->setSubStmt(Record.readSubStmt());
1130   S->setAtLoc(ReadSourceLocation());
1131 }
1132
1133 void ASTStmtReader::VisitObjCAtTryStmt(ObjCAtTryStmt *S) {
1134   VisitStmt(S);
1135   assert(Record.peekInt() == S->getNumCatchStmts());
1136   Record.skipInts(1);
1137   bool HasFinally = Record.readInt();
1138   S->setTryBody(Record.readSubStmt());
1139   for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I)
1140     S->setCatchStmt(I, cast_or_null<ObjCAtCatchStmt>(Record.readSubStmt()));
1141
1142   if (HasFinally)
1143     S->setFinallyStmt(Record.readSubStmt());
1144   S->setAtTryLoc(ReadSourceLocation());
1145 }
1146
1147 void ASTStmtReader::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S) {
1148   VisitStmt(S);
1149   S->setSynchExpr(Record.readSubStmt());
1150   S->setSynchBody(Record.readSubStmt());
1151   S->setAtSynchronizedLoc(ReadSourceLocation());
1152 }
1153
1154 void ASTStmtReader::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) {
1155   VisitStmt(S);
1156   S->setThrowExpr(Record.readSubStmt());
1157   S->setThrowLoc(ReadSourceLocation());
1158 }
1159
1160 void ASTStmtReader::VisitObjCBoolLiteralExpr(ObjCBoolLiteralExpr *E) {
1161   VisitExpr(E);
1162   E->setValue(Record.readInt());
1163   E->setLocation(ReadSourceLocation());
1164 }
1165
1166 void ASTStmtReader::VisitObjCAvailabilityCheckExpr(ObjCAvailabilityCheckExpr *E) {
1167   VisitExpr(E);
1168   SourceRange R = Record.readSourceRange();
1169   E->AtLoc = R.getBegin();
1170   E->RParen = R.getEnd();
1171   E->VersionToCheck = Record.readVersionTuple();
1172 }
1173
1174 //===----------------------------------------------------------------------===//
1175 // C++ Expressions and Statements
1176 //===----------------------------------------------------------------------===//
1177
1178 void ASTStmtReader::VisitCXXCatchStmt(CXXCatchStmt *S) {
1179   VisitStmt(S);
1180   S->CatchLoc = ReadSourceLocation();
1181   S->ExceptionDecl = ReadDeclAs<VarDecl>();
1182   S->HandlerBlock = Record.readSubStmt();
1183 }
1184
1185 void ASTStmtReader::VisitCXXTryStmt(CXXTryStmt *S) {
1186   VisitStmt(S);
1187   assert(Record.peekInt() == S->getNumHandlers() && "NumStmtFields is wrong ?");
1188   Record.skipInts(1);
1189   S->TryLoc = ReadSourceLocation();
1190   S->getStmts()[0] = Record.readSubStmt();
1191   for (unsigned i = 0, e = S->getNumHandlers(); i != e; ++i)
1192     S->getStmts()[i + 1] = Record.readSubStmt();
1193 }
1194
1195 void ASTStmtReader::VisitCXXForRangeStmt(CXXForRangeStmt *S) {
1196   VisitStmt(S);
1197   S->ForLoc = ReadSourceLocation();
1198   S->CoawaitLoc = ReadSourceLocation();
1199   S->ColonLoc = ReadSourceLocation();
1200   S->RParenLoc = ReadSourceLocation();
1201   S->setRangeStmt(Record.readSubStmt());
1202   S->setBeginStmt(Record.readSubStmt());
1203   S->setEndStmt(Record.readSubStmt());
1204   S->setCond(Record.readSubExpr());
1205   S->setInc(Record.readSubExpr());
1206   S->setLoopVarStmt(Record.readSubStmt());
1207   S->setBody(Record.readSubStmt());
1208 }
1209
1210 void ASTStmtReader::VisitMSDependentExistsStmt(MSDependentExistsStmt *S) {
1211   VisitStmt(S);
1212   S->KeywordLoc = ReadSourceLocation();
1213   S->IsIfExists = Record.readInt();
1214   S->QualifierLoc = Record.readNestedNameSpecifierLoc();
1215   ReadDeclarationNameInfo(S->NameInfo);
1216   S->SubStmt = Record.readSubStmt();
1217 }
1218
1219 void ASTStmtReader::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
1220   VisitCallExpr(E);
1221   E->Operator = (OverloadedOperatorKind)Record.readInt();
1222   E->Range = Record.readSourceRange();
1223   E->setFPContractable((bool)Record.readInt());
1224 }
1225
1226 void ASTStmtReader::VisitCXXConstructExpr(CXXConstructExpr *E) {
1227   VisitExpr(E);
1228   E->NumArgs = Record.readInt();
1229   if (E->NumArgs)
1230     E->Args = new (Record.getContext()) Stmt*[E->NumArgs];
1231   for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
1232     E->setArg(I, Record.readSubExpr());
1233   E->setConstructor(ReadDeclAs<CXXConstructorDecl>());
1234   E->setLocation(ReadSourceLocation());
1235   E->setElidable(Record.readInt());
1236   E->setHadMultipleCandidates(Record.readInt());
1237   E->setListInitialization(Record.readInt());
1238   E->setStdInitListInitialization(Record.readInt());
1239   E->setRequiresZeroInitialization(Record.readInt());
1240   E->setConstructionKind((CXXConstructExpr::ConstructionKind)Record.readInt());
1241   E->ParenOrBraceRange = ReadSourceRange();
1242 }
1243
1244 void ASTStmtReader::VisitCXXInheritedCtorInitExpr(CXXInheritedCtorInitExpr *E) {
1245   VisitExpr(E);
1246   E->Constructor = ReadDeclAs<CXXConstructorDecl>();
1247   E->Loc = ReadSourceLocation();
1248   E->ConstructsVirtualBase = Record.readInt();
1249   E->InheritedFromVirtualBase = Record.readInt();
1250 }
1251
1252 void ASTStmtReader::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E) {
1253   VisitCXXConstructExpr(E);
1254   E->Type = GetTypeSourceInfo();
1255 }
1256
1257 void ASTStmtReader::VisitLambdaExpr(LambdaExpr *E) {
1258   VisitExpr(E);
1259   unsigned NumCaptures = Record.readInt();
1260   assert(NumCaptures == E->NumCaptures);(void)NumCaptures;
1261   E->IntroducerRange = ReadSourceRange();
1262   E->CaptureDefault = static_cast<LambdaCaptureDefault>(Record.readInt());
1263   E->CaptureDefaultLoc = ReadSourceLocation();
1264   E->ExplicitParams = Record.readInt();
1265   E->ExplicitResultType = Record.readInt();
1266   E->ClosingBrace = ReadSourceLocation();
1267
1268   // Read capture initializers.
1269   for (LambdaExpr::capture_init_iterator C = E->capture_init_begin(),
1270                                       CEnd = E->capture_init_end();
1271        C != CEnd; ++C)
1272     *C = Record.readSubExpr();
1273 }
1274
1275 void
1276 ASTStmtReader::VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E) {
1277   VisitExpr(E);
1278   E->SubExpr = Record.readSubExpr();
1279 }
1280
1281 void ASTStmtReader::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) {
1282   VisitExplicitCastExpr(E);
1283   SourceRange R = ReadSourceRange();
1284   E->Loc = R.getBegin();
1285   E->RParenLoc = R.getEnd();
1286   R = ReadSourceRange();
1287   E->AngleBrackets = R;
1288 }
1289
1290 void ASTStmtReader::VisitCXXStaticCastExpr(CXXStaticCastExpr *E) {
1291   return VisitCXXNamedCastExpr(E);
1292 }
1293
1294 void ASTStmtReader::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *E) {
1295   return VisitCXXNamedCastExpr(E);
1296 }
1297
1298 void ASTStmtReader::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *E) {
1299   return VisitCXXNamedCastExpr(E);
1300 }
1301
1302 void ASTStmtReader::VisitCXXConstCastExpr(CXXConstCastExpr *E) {
1303   return VisitCXXNamedCastExpr(E);
1304 }
1305
1306 void ASTStmtReader::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E) {
1307   VisitExplicitCastExpr(E);
1308   E->setLParenLoc(ReadSourceLocation());
1309   E->setRParenLoc(ReadSourceLocation());
1310 }
1311
1312 void ASTStmtReader::VisitUserDefinedLiteral(UserDefinedLiteral *E) {
1313   VisitCallExpr(E);
1314   E->UDSuffixLoc = ReadSourceLocation();
1315 }
1316
1317 void ASTStmtReader::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
1318   VisitExpr(E);
1319   E->setValue(Record.readInt());
1320   E->setLocation(ReadSourceLocation());
1321 }
1322
1323 void ASTStmtReader::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) {
1324   VisitExpr(E);
1325   E->setLocation(ReadSourceLocation());
1326 }
1327
1328 void ASTStmtReader::VisitCXXTypeidExpr(CXXTypeidExpr *E) {
1329   VisitExpr(E);
1330   E->setSourceRange(ReadSourceRange());
1331   if (E->isTypeOperand()) { // typeid(int)
1332     E->setTypeOperandSourceInfo(
1333         GetTypeSourceInfo());
1334     return;
1335   }
1336
1337   // typeid(42+2)
1338   E->setExprOperand(Record.readSubExpr());
1339 }
1340
1341 void ASTStmtReader::VisitCXXThisExpr(CXXThisExpr *E) {
1342   VisitExpr(E);
1343   E->setLocation(ReadSourceLocation());
1344   E->setImplicit(Record.readInt());
1345 }
1346
1347 void ASTStmtReader::VisitCXXThrowExpr(CXXThrowExpr *E) {
1348   VisitExpr(E);
1349   E->ThrowLoc = ReadSourceLocation();
1350   E->Op = Record.readSubExpr();
1351   E->IsThrownVariableInScope = Record.readInt();
1352 }
1353
1354 void ASTStmtReader::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
1355   VisitExpr(E);
1356   E->Param = ReadDeclAs<ParmVarDecl>();
1357   E->Loc = ReadSourceLocation();
1358 }
1359
1360 void ASTStmtReader::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E) {
1361   VisitExpr(E);
1362   E->Field = ReadDeclAs<FieldDecl>();
1363   E->Loc = ReadSourceLocation();
1364 }
1365
1366 void ASTStmtReader::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
1367   VisitExpr(E);
1368   E->setTemporary(Record.readCXXTemporary());
1369   E->setSubExpr(Record.readSubExpr());
1370 }
1371
1372 void ASTStmtReader::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
1373   VisitExpr(E);
1374   E->TypeInfo = GetTypeSourceInfo();
1375   E->RParenLoc = ReadSourceLocation();
1376 }
1377
1378 void ASTStmtReader::VisitCXXNewExpr(CXXNewExpr *E) {
1379   VisitExpr(E);
1380   E->GlobalNew = Record.readInt();
1381   bool isArray = Record.readInt();
1382   E->PassAlignment = Record.readInt();
1383   E->UsualArrayDeleteWantsSize = Record.readInt();
1384   unsigned NumPlacementArgs = Record.readInt();
1385   E->StoredInitializationStyle = Record.readInt();
1386   E->setOperatorNew(ReadDeclAs<FunctionDecl>());
1387   E->setOperatorDelete(ReadDeclAs<FunctionDecl>());
1388   E->AllocatedTypeInfo = GetTypeSourceInfo();
1389   E->TypeIdParens = ReadSourceRange();
1390   E->Range = ReadSourceRange();
1391   E->DirectInitRange = ReadSourceRange();
1392
1393   E->AllocateArgsArray(Record.getContext(), isArray, NumPlacementArgs,
1394                        E->StoredInitializationStyle != 0);
1395
1396   // Install all the subexpressions.
1397   for (CXXNewExpr::raw_arg_iterator I = E->raw_arg_begin(),e = E->raw_arg_end();
1398        I != e; ++I)
1399     *I = Record.readSubStmt();
1400 }
1401
1402 void ASTStmtReader::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
1403   VisitExpr(E);
1404   E->GlobalDelete = Record.readInt();
1405   E->ArrayForm = Record.readInt();
1406   E->ArrayFormAsWritten = Record.readInt();
1407   E->UsualArrayDeleteWantsSize = Record.readInt();
1408   E->OperatorDelete = ReadDeclAs<FunctionDecl>();
1409   E->Argument = Record.readSubExpr();
1410   E->Loc = ReadSourceLocation();
1411 }
1412
1413 void ASTStmtReader::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) {
1414   VisitExpr(E);
1415
1416   E->Base = Record.readSubExpr();
1417   E->IsArrow = Record.readInt();
1418   E->OperatorLoc = ReadSourceLocation();
1419   E->QualifierLoc = Record.readNestedNameSpecifierLoc();
1420   E->ScopeType = GetTypeSourceInfo();
1421   E->ColonColonLoc = ReadSourceLocation();
1422   E->TildeLoc = ReadSourceLocation();
1423
1424   IdentifierInfo *II = Record.getIdentifierInfo();
1425   if (II)
1426     E->setDestroyedType(II, ReadSourceLocation());
1427   else
1428     E->setDestroyedType(GetTypeSourceInfo());
1429 }
1430
1431 void ASTStmtReader::VisitExprWithCleanups(ExprWithCleanups *E) {
1432   VisitExpr(E);
1433
1434   unsigned NumObjects = Record.readInt();
1435   assert(NumObjects == E->getNumObjects());
1436   for (unsigned i = 0; i != NumObjects; ++i)
1437     E->getTrailingObjects<BlockDecl *>()[i] =
1438         ReadDeclAs<BlockDecl>();
1439
1440   E->ExprWithCleanupsBits.CleanupsHaveSideEffects = Record.readInt();
1441   E->SubExpr = Record.readSubExpr();
1442 }
1443
1444 void
1445 ASTStmtReader::VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E){
1446   VisitExpr(E);
1447
1448   if (Record.readInt()) // HasTemplateKWAndArgsInfo
1449     ReadTemplateKWAndArgsInfo(
1450         *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(),
1451         E->getTrailingObjects<TemplateArgumentLoc>(),
1452         /*NumTemplateArgs=*/Record.readInt());
1453
1454   E->Base = Record.readSubExpr();
1455   E->BaseType = Record.readType();
1456   E->IsArrow = Record.readInt();
1457   E->OperatorLoc = ReadSourceLocation();
1458   E->QualifierLoc = Record.readNestedNameSpecifierLoc();
1459   E->FirstQualifierFoundInScope = ReadDeclAs<NamedDecl>();
1460   ReadDeclarationNameInfo(E->MemberNameInfo);
1461 }
1462
1463 void
1464 ASTStmtReader::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) {
1465   VisitExpr(E);
1466
1467   if (Record.readInt()) // HasTemplateKWAndArgsInfo
1468     ReadTemplateKWAndArgsInfo(
1469         *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(),
1470         E->getTrailingObjects<TemplateArgumentLoc>(),
1471         /*NumTemplateArgs=*/Record.readInt());
1472
1473   E->QualifierLoc = Record.readNestedNameSpecifierLoc();
1474   ReadDeclarationNameInfo(E->NameInfo);
1475 }
1476
1477 void
1478 ASTStmtReader::VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E) {
1479   VisitExpr(E);
1480   assert(Record.peekInt() == E->arg_size() &&
1481          "Read wrong record during creation ?");
1482   Record.skipInts(1);
1483   for (unsigned I = 0, N = E->arg_size(); I != N; ++I)
1484     E->setArg(I, Record.readSubExpr());
1485   E->Type = GetTypeSourceInfo();
1486   E->setLParenLoc(ReadSourceLocation());
1487   E->setRParenLoc(ReadSourceLocation());
1488 }
1489
1490 void ASTStmtReader::VisitOverloadExpr(OverloadExpr *E) {
1491   VisitExpr(E);
1492
1493   if (Record.readInt()) // HasTemplateKWAndArgsInfo
1494     ReadTemplateKWAndArgsInfo(*E->getTrailingASTTemplateKWAndArgsInfo(),
1495                               E->getTrailingTemplateArgumentLoc(),
1496                               /*NumTemplateArgs=*/Record.readInt());
1497
1498   unsigned NumDecls = Record.readInt();
1499   UnresolvedSet<8> Decls;
1500   for (unsigned i = 0; i != NumDecls; ++i) {
1501     NamedDecl *D = ReadDeclAs<NamedDecl>();
1502     AccessSpecifier AS = (AccessSpecifier)Record.readInt();
1503     Decls.addDecl(D, AS);
1504   }
1505   E->initializeResults(Record.getContext(), Decls.begin(), Decls.end());
1506
1507   ReadDeclarationNameInfo(E->NameInfo);
1508   E->QualifierLoc = Record.readNestedNameSpecifierLoc();
1509 }
1510
1511 void ASTStmtReader::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) {
1512   VisitOverloadExpr(E);
1513   E->IsArrow = Record.readInt();
1514   E->HasUnresolvedUsing = Record.readInt();
1515   E->Base = Record.readSubExpr();
1516   E->BaseType = Record.readType();
1517   E->OperatorLoc = ReadSourceLocation();
1518 }
1519
1520 void ASTStmtReader::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) {
1521   VisitOverloadExpr(E);
1522   E->RequiresADL = Record.readInt();
1523   E->Overloaded = Record.readInt();
1524   E->NamingClass = ReadDeclAs<CXXRecordDecl>();
1525 }
1526
1527 void ASTStmtReader::VisitTypeTraitExpr(TypeTraitExpr *E) {
1528   VisitExpr(E);
1529   E->TypeTraitExprBits.NumArgs = Record.readInt();
1530   E->TypeTraitExprBits.Kind = Record.readInt();
1531   E->TypeTraitExprBits.Value = Record.readInt();
1532   SourceRange Range = ReadSourceRange();
1533   E->Loc = Range.getBegin();
1534   E->RParenLoc = Range.getEnd();
1535
1536   TypeSourceInfo **Args = E->getTrailingObjects<TypeSourceInfo *>();
1537   for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
1538     Args[I] = GetTypeSourceInfo();
1539 }
1540
1541 void ASTStmtReader::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
1542   VisitExpr(E);
1543   E->ATT = (ArrayTypeTrait)Record.readInt();
1544   E->Value = (unsigned int)Record.readInt();
1545   SourceRange Range = ReadSourceRange();
1546   E->Loc = Range.getBegin();
1547   E->RParen = Range.getEnd();
1548   E->QueriedType = GetTypeSourceInfo();
1549   E->Dimension = Record.readSubExpr();
1550 }
1551
1552 void ASTStmtReader::VisitExpressionTraitExpr(ExpressionTraitExpr *E) {
1553   VisitExpr(E);
1554   E->ET = (ExpressionTrait)Record.readInt();
1555   E->Value = (bool)Record.readInt();
1556   SourceRange Range = ReadSourceRange();
1557   E->QueriedExpression = Record.readSubExpr();
1558   E->Loc = Range.getBegin();
1559   E->RParen = Range.getEnd();
1560 }
1561
1562 void ASTStmtReader::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) {
1563   VisitExpr(E);
1564   E->Value = (bool)Record.readInt();
1565   E->Range = ReadSourceRange();
1566   E->Operand = Record.readSubExpr();
1567 }
1568
1569 void ASTStmtReader::VisitPackExpansionExpr(PackExpansionExpr *E) {
1570   VisitExpr(E);
1571   E->EllipsisLoc = ReadSourceLocation();
1572   E->NumExpansions = Record.readInt();
1573   E->Pattern = Record.readSubExpr();
1574 }
1575
1576 void ASTStmtReader::VisitSizeOfPackExpr(SizeOfPackExpr *E) {
1577   VisitExpr(E);
1578   unsigned NumPartialArgs = Record.readInt();
1579   E->OperatorLoc = ReadSourceLocation();
1580   E->PackLoc = ReadSourceLocation();
1581   E->RParenLoc = ReadSourceLocation();
1582   E->Pack = Record.readDeclAs<NamedDecl>();
1583   if (E->isPartiallySubstituted()) {
1584     assert(E->Length == NumPartialArgs);
1585     for (auto *I = E->getTrailingObjects<TemplateArgument>(),
1586               *E = I + NumPartialArgs;
1587          I != E; ++I)
1588       new (I) TemplateArgument(Record.readTemplateArgument());
1589   } else if (!E->isValueDependent()) {
1590     E->Length = Record.readInt();
1591   }
1592 }
1593
1594 void ASTStmtReader::VisitSubstNonTypeTemplateParmExpr(
1595                                               SubstNonTypeTemplateParmExpr *E) {
1596   VisitExpr(E);
1597   E->Param = ReadDeclAs<NonTypeTemplateParmDecl>();
1598   E->NameLoc = ReadSourceLocation();
1599   E->Replacement = Record.readSubExpr();
1600 }
1601
1602 void ASTStmtReader::VisitSubstNonTypeTemplateParmPackExpr(
1603                                           SubstNonTypeTemplateParmPackExpr *E) {
1604   VisitExpr(E);
1605   E->Param = ReadDeclAs<NonTypeTemplateParmDecl>();
1606   TemplateArgument ArgPack = Record.readTemplateArgument();
1607   if (ArgPack.getKind() != TemplateArgument::Pack)
1608     return;
1609
1610   E->Arguments = ArgPack.pack_begin();
1611   E->NumArguments = ArgPack.pack_size();
1612   E->NameLoc = ReadSourceLocation();
1613 }
1614
1615 void ASTStmtReader::VisitFunctionParmPackExpr(FunctionParmPackExpr *E) {
1616   VisitExpr(E);
1617   E->NumParameters = Record.readInt();
1618   E->ParamPack = ReadDeclAs<ParmVarDecl>();
1619   E->NameLoc = ReadSourceLocation();
1620   ParmVarDecl **Parms = E->getTrailingObjects<ParmVarDecl *>();
1621   for (unsigned i = 0, n = E->NumParameters; i != n; ++i)
1622     Parms[i] = ReadDeclAs<ParmVarDecl>();
1623 }
1624
1625 void ASTStmtReader::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) {
1626   VisitExpr(E);
1627   E->State = Record.readSubExpr();
1628   auto VD = ReadDeclAs<ValueDecl>();
1629   unsigned ManglingNumber = Record.readInt();
1630   E->setExtendingDecl(VD, ManglingNumber);
1631 }
1632
1633 void ASTStmtReader::VisitCXXFoldExpr(CXXFoldExpr *E) {
1634   VisitExpr(E);
1635   E->LParenLoc = ReadSourceLocation();
1636   E->EllipsisLoc = ReadSourceLocation();
1637   E->RParenLoc = ReadSourceLocation();
1638   E->SubExprs[0] = Record.readSubExpr();
1639   E->SubExprs[1] = Record.readSubExpr();
1640   E->Opcode = (BinaryOperatorKind)Record.readInt();
1641 }
1642
1643 void ASTStmtReader::VisitOpaqueValueExpr(OpaqueValueExpr *E) {
1644   VisitExpr(E);
1645   E->SourceExpr = Record.readSubExpr();
1646   E->Loc = ReadSourceLocation();
1647 }
1648
1649 void ASTStmtReader::VisitTypoExpr(TypoExpr *E) {
1650   llvm_unreachable("Cannot read TypoExpr nodes");
1651 }
1652
1653 //===----------------------------------------------------------------------===//
1654 // Microsoft Expressions and Statements
1655 //===----------------------------------------------------------------------===//
1656 void ASTStmtReader::VisitMSPropertyRefExpr(MSPropertyRefExpr *E) {
1657   VisitExpr(E);
1658   E->IsArrow = (Record.readInt() != 0);
1659   E->BaseExpr = Record.readSubExpr();
1660   E->QualifierLoc = Record.readNestedNameSpecifierLoc();
1661   E->MemberLoc = ReadSourceLocation();
1662   E->TheDecl = ReadDeclAs<MSPropertyDecl>();
1663 }
1664
1665 void ASTStmtReader::VisitMSPropertySubscriptExpr(MSPropertySubscriptExpr *E) {
1666   VisitExpr(E);
1667   E->setBase(Record.readSubExpr());
1668   E->setIdx(Record.readSubExpr());
1669   E->setRBracketLoc(ReadSourceLocation());
1670 }
1671
1672 void ASTStmtReader::VisitCXXUuidofExpr(CXXUuidofExpr *E) {
1673   VisitExpr(E);
1674   E->setSourceRange(ReadSourceRange());
1675   std::string UuidStr = ReadString();
1676   E->setUuidStr(StringRef(UuidStr).copy(Record.getContext()));
1677   if (E->isTypeOperand()) { // __uuidof(ComType)
1678     E->setTypeOperandSourceInfo(
1679         GetTypeSourceInfo());
1680     return;
1681   }
1682
1683   // __uuidof(expr)
1684   E->setExprOperand(Record.readSubExpr());
1685 }
1686
1687 void ASTStmtReader::VisitSEHLeaveStmt(SEHLeaveStmt *S) {
1688   VisitStmt(S);
1689   S->setLeaveLoc(ReadSourceLocation());
1690 }
1691
1692 void ASTStmtReader::VisitSEHExceptStmt(SEHExceptStmt *S) {
1693   VisitStmt(S);
1694   S->Loc = ReadSourceLocation();
1695   S->Children[SEHExceptStmt::FILTER_EXPR] = Record.readSubStmt();
1696   S->Children[SEHExceptStmt::BLOCK] = Record.readSubStmt();
1697 }
1698
1699 void ASTStmtReader::VisitSEHFinallyStmt(SEHFinallyStmt *S) {
1700   VisitStmt(S);
1701   S->Loc = ReadSourceLocation();
1702   S->Block = Record.readSubStmt();
1703 }
1704
1705 void ASTStmtReader::VisitSEHTryStmt(SEHTryStmt *S) {
1706   VisitStmt(S);
1707   S->IsCXXTry = Record.readInt();
1708   S->TryLoc = ReadSourceLocation();
1709   S->Children[SEHTryStmt::TRY] = Record.readSubStmt();
1710   S->Children[SEHTryStmt::HANDLER] = Record.readSubStmt();
1711 }
1712
1713 //===----------------------------------------------------------------------===//
1714 // CUDA Expressions and Statements
1715 //===----------------------------------------------------------------------===//
1716
1717 void ASTStmtReader::VisitCUDAKernelCallExpr(CUDAKernelCallExpr *E) {
1718   VisitCallExpr(E);
1719   E->setConfig(cast<CallExpr>(Record.readSubExpr()));
1720 }
1721
1722 //===----------------------------------------------------------------------===//
1723 // OpenCL Expressions and Statements.
1724 //===----------------------------------------------------------------------===//
1725 void ASTStmtReader::VisitAsTypeExpr(AsTypeExpr *E) {
1726   VisitExpr(E);
1727   E->BuiltinLoc = ReadSourceLocation();
1728   E->RParenLoc = ReadSourceLocation();
1729   E->SrcExpr = Record.readSubExpr();
1730 }
1731
1732 //===----------------------------------------------------------------------===//
1733 // OpenMP Clauses.
1734 //===----------------------------------------------------------------------===//
1735
1736 namespace clang {
1737 class OMPClauseReader : public OMPClauseVisitor<OMPClauseReader> {
1738   ASTStmtReader *Reader;
1739   ASTContext &Context;
1740 public:
1741   OMPClauseReader(ASTStmtReader *R, ASTRecordReader &Record)
1742       : Reader(R), Context(Record.getContext()) {}
1743 #define OPENMP_CLAUSE(Name, Class) void Visit##Class(Class *C);
1744 #include "clang/Basic/OpenMPKinds.def"
1745   OMPClause *readClause();
1746   void VisitOMPClauseWithPreInit(OMPClauseWithPreInit *C);
1747   void VisitOMPClauseWithPostUpdate(OMPClauseWithPostUpdate *C);
1748 };
1749 }
1750
1751 OMPClause *OMPClauseReader::readClause() {
1752   OMPClause *C;
1753   switch (Reader->Record.readInt()) {
1754   case OMPC_if:
1755     C = new (Context) OMPIfClause();
1756     break;
1757   case OMPC_final:
1758     C = new (Context) OMPFinalClause();
1759     break;
1760   case OMPC_num_threads:
1761     C = new (Context) OMPNumThreadsClause();
1762     break;
1763   case OMPC_safelen:
1764     C = new (Context) OMPSafelenClause();
1765     break;
1766   case OMPC_simdlen:
1767     C = new (Context) OMPSimdlenClause();
1768     break;
1769   case OMPC_collapse:
1770     C = new (Context) OMPCollapseClause();
1771     break;
1772   case OMPC_default:
1773     C = new (Context) OMPDefaultClause();
1774     break;
1775   case OMPC_proc_bind:
1776     C = new (Context) OMPProcBindClause();
1777     break;
1778   case OMPC_schedule:
1779     C = new (Context) OMPScheduleClause();
1780     break;
1781   case OMPC_ordered:
1782     C = new (Context) OMPOrderedClause();
1783     break;
1784   case OMPC_nowait:
1785     C = new (Context) OMPNowaitClause();
1786     break;
1787   case OMPC_untied:
1788     C = new (Context) OMPUntiedClause();
1789     break;
1790   case OMPC_mergeable:
1791     C = new (Context) OMPMergeableClause();
1792     break;
1793   case OMPC_read:
1794     C = new (Context) OMPReadClause();
1795     break;
1796   case OMPC_write:
1797     C = new (Context) OMPWriteClause();
1798     break;
1799   case OMPC_update:
1800     C = new (Context) OMPUpdateClause();
1801     break;
1802   case OMPC_capture:
1803     C = new (Context) OMPCaptureClause();
1804     break;
1805   case OMPC_seq_cst:
1806     C = new (Context) OMPSeqCstClause();
1807     break;
1808   case OMPC_threads:
1809     C = new (Context) OMPThreadsClause();
1810     break;
1811   case OMPC_simd:
1812     C = new (Context) OMPSIMDClause();
1813     break;
1814   case OMPC_nogroup:
1815     C = new (Context) OMPNogroupClause();
1816     break;
1817   case OMPC_private:
1818     C = OMPPrivateClause::CreateEmpty(Context, Reader->Record.readInt());
1819     break;
1820   case OMPC_firstprivate:
1821     C = OMPFirstprivateClause::CreateEmpty(Context, Reader->Record.readInt());
1822     break;
1823   case OMPC_lastprivate:
1824     C = OMPLastprivateClause::CreateEmpty(Context, Reader->Record.readInt());
1825     break;
1826   case OMPC_shared:
1827     C = OMPSharedClause::CreateEmpty(Context, Reader->Record.readInt());
1828     break;
1829   case OMPC_reduction:
1830     C = OMPReductionClause::CreateEmpty(Context, Reader->Record.readInt());
1831     break;
1832   case OMPC_linear:
1833     C = OMPLinearClause::CreateEmpty(Context, Reader->Record.readInt());
1834     break;
1835   case OMPC_aligned:
1836     C = OMPAlignedClause::CreateEmpty(Context, Reader->Record.readInt());
1837     break;
1838   case OMPC_copyin:
1839     C = OMPCopyinClause::CreateEmpty(Context, Reader->Record.readInt());
1840     break;
1841   case OMPC_copyprivate:
1842     C = OMPCopyprivateClause::CreateEmpty(Context, Reader->Record.readInt());
1843     break;
1844   case OMPC_flush:
1845     C = OMPFlushClause::CreateEmpty(Context, Reader->Record.readInt());
1846     break;
1847   case OMPC_depend:
1848     C = OMPDependClause::CreateEmpty(Context, Reader->Record.readInt());
1849     break;
1850   case OMPC_device:
1851     C = new (Context) OMPDeviceClause();
1852     break;
1853   case OMPC_map: {
1854     unsigned NumVars = Reader->Record.readInt();
1855     unsigned NumDeclarations = Reader->Record.readInt();
1856     unsigned NumLists = Reader->Record.readInt();
1857     unsigned NumComponents = Reader->Record.readInt();
1858     C = OMPMapClause::CreateEmpty(Context, NumVars, NumDeclarations, NumLists,
1859                                   NumComponents);
1860     break;
1861   }
1862   case OMPC_num_teams:
1863     C = new (Context) OMPNumTeamsClause();
1864     break;
1865   case OMPC_thread_limit:
1866     C = new (Context) OMPThreadLimitClause();
1867     break;
1868   case OMPC_priority:
1869     C = new (Context) OMPPriorityClause();
1870     break;
1871   case OMPC_grainsize:
1872     C = new (Context) OMPGrainsizeClause();
1873     break;
1874   case OMPC_num_tasks:
1875     C = new (Context) OMPNumTasksClause();
1876     break;
1877   case OMPC_hint:
1878     C = new (Context) OMPHintClause();
1879     break;
1880   case OMPC_dist_schedule:
1881     C = new (Context) OMPDistScheduleClause();
1882     break;
1883   case OMPC_defaultmap:
1884     C = new (Context) OMPDefaultmapClause();
1885     break;
1886   case OMPC_to: {
1887     unsigned NumVars = Reader->Record.readInt();
1888     unsigned NumDeclarations = Reader->Record.readInt();
1889     unsigned NumLists = Reader->Record.readInt();
1890     unsigned NumComponents = Reader->Record.readInt();
1891     C = OMPToClause::CreateEmpty(Context, NumVars, NumDeclarations, NumLists,
1892                                  NumComponents);
1893     break;
1894   }
1895   case OMPC_from: {
1896     unsigned NumVars = Reader->Record.readInt();
1897     unsigned NumDeclarations = Reader->Record.readInt();
1898     unsigned NumLists = Reader->Record.readInt();
1899     unsigned NumComponents = Reader->Record.readInt();
1900     C = OMPFromClause::CreateEmpty(Context, NumVars, NumDeclarations, NumLists,
1901                                    NumComponents);
1902     break;
1903   }
1904   case OMPC_use_device_ptr: {
1905     unsigned NumVars = Reader->Record.readInt();
1906     unsigned NumDeclarations = Reader->Record.readInt();
1907     unsigned NumLists = Reader->Record.readInt();
1908     unsigned NumComponents = Reader->Record.readInt();
1909     C = OMPUseDevicePtrClause::CreateEmpty(Context, NumVars, NumDeclarations,
1910                                            NumLists, NumComponents);
1911     break;
1912   }
1913   case OMPC_is_device_ptr: {
1914     unsigned NumVars = Reader->Record.readInt();
1915     unsigned NumDeclarations = Reader->Record.readInt();
1916     unsigned NumLists = Reader->Record.readInt();
1917     unsigned NumComponents = Reader->Record.readInt();
1918     C = OMPIsDevicePtrClause::CreateEmpty(Context, NumVars, NumDeclarations,
1919                                           NumLists, NumComponents);
1920     break;
1921   }
1922   }
1923   Visit(C);
1924   C->setLocStart(Reader->ReadSourceLocation());
1925   C->setLocEnd(Reader->ReadSourceLocation());
1926
1927   return C;
1928 }
1929
1930 void OMPClauseReader::VisitOMPClauseWithPreInit(OMPClauseWithPreInit *C) {
1931   C->setPreInitStmt(Reader->Record.readSubStmt());
1932 }
1933
1934 void OMPClauseReader::VisitOMPClauseWithPostUpdate(OMPClauseWithPostUpdate *C) {
1935   VisitOMPClauseWithPreInit(C);
1936   C->setPostUpdateExpr(Reader->Record.readSubExpr());
1937 }
1938
1939 void OMPClauseReader::VisitOMPIfClause(OMPIfClause *C) {
1940   C->setNameModifier(static_cast<OpenMPDirectiveKind>(Reader->Record.readInt()));
1941   C->setNameModifierLoc(Reader->ReadSourceLocation());
1942   C->setColonLoc(Reader->ReadSourceLocation());
1943   C->setCondition(Reader->Record.readSubExpr());
1944   C->setLParenLoc(Reader->ReadSourceLocation());
1945 }
1946
1947 void OMPClauseReader::VisitOMPFinalClause(OMPFinalClause *C) {
1948   C->setCondition(Reader->Record.readSubExpr());
1949   C->setLParenLoc(Reader->ReadSourceLocation());
1950 }
1951
1952 void OMPClauseReader::VisitOMPNumThreadsClause(OMPNumThreadsClause *C) {
1953   C->setNumThreads(Reader->Record.readSubExpr());
1954   C->setLParenLoc(Reader->ReadSourceLocation());
1955 }
1956
1957 void OMPClauseReader::VisitOMPSafelenClause(OMPSafelenClause *C) {
1958   C->setSafelen(Reader->Record.readSubExpr());
1959   C->setLParenLoc(Reader->ReadSourceLocation());
1960 }
1961
1962 void OMPClauseReader::VisitOMPSimdlenClause(OMPSimdlenClause *C) {
1963   C->setSimdlen(Reader->Record.readSubExpr());
1964   C->setLParenLoc(Reader->ReadSourceLocation());
1965 }
1966
1967 void OMPClauseReader::VisitOMPCollapseClause(OMPCollapseClause *C) {
1968   C->setNumForLoops(Reader->Record.readSubExpr());
1969   C->setLParenLoc(Reader->ReadSourceLocation());
1970 }
1971
1972 void OMPClauseReader::VisitOMPDefaultClause(OMPDefaultClause *C) {
1973   C->setDefaultKind(
1974        static_cast<OpenMPDefaultClauseKind>(Reader->Record.readInt()));
1975   C->setLParenLoc(Reader->ReadSourceLocation());
1976   C->setDefaultKindKwLoc(Reader->ReadSourceLocation());
1977 }
1978
1979 void OMPClauseReader::VisitOMPProcBindClause(OMPProcBindClause *C) {
1980   C->setProcBindKind(
1981        static_cast<OpenMPProcBindClauseKind>(Reader->Record.readInt()));
1982   C->setLParenLoc(Reader->ReadSourceLocation());
1983   C->setProcBindKindKwLoc(Reader->ReadSourceLocation());
1984 }
1985
1986 void OMPClauseReader::VisitOMPScheduleClause(OMPScheduleClause *C) {
1987   VisitOMPClauseWithPreInit(C);
1988   C->setScheduleKind(
1989        static_cast<OpenMPScheduleClauseKind>(Reader->Record.readInt()));
1990   C->setFirstScheduleModifier(
1991       static_cast<OpenMPScheduleClauseModifier>(Reader->Record.readInt()));
1992   C->setSecondScheduleModifier(
1993       static_cast<OpenMPScheduleClauseModifier>(Reader->Record.readInt()));
1994   C->setChunkSize(Reader->Record.readSubExpr());
1995   C->setLParenLoc(Reader->ReadSourceLocation());
1996   C->setFirstScheduleModifierLoc(Reader->ReadSourceLocation());
1997   C->setSecondScheduleModifierLoc(Reader->ReadSourceLocation());
1998   C->setScheduleKindLoc(Reader->ReadSourceLocation());
1999   C->setCommaLoc(Reader->ReadSourceLocation());
2000 }
2001
2002 void OMPClauseReader::VisitOMPOrderedClause(OMPOrderedClause *C) {
2003   C->setNumForLoops(Reader->Record.readSubExpr());
2004   C->setLParenLoc(Reader->ReadSourceLocation());
2005 }
2006
2007 void OMPClauseReader::VisitOMPNowaitClause(OMPNowaitClause *) {}
2008
2009 void OMPClauseReader::VisitOMPUntiedClause(OMPUntiedClause *) {}
2010
2011 void OMPClauseReader::VisitOMPMergeableClause(OMPMergeableClause *) {}
2012
2013 void OMPClauseReader::VisitOMPReadClause(OMPReadClause *) {}
2014
2015 void OMPClauseReader::VisitOMPWriteClause(OMPWriteClause *) {}
2016
2017 void OMPClauseReader::VisitOMPUpdateClause(OMPUpdateClause *) {}
2018
2019 void OMPClauseReader::VisitOMPCaptureClause(OMPCaptureClause *) {}
2020
2021 void OMPClauseReader::VisitOMPSeqCstClause(OMPSeqCstClause *) {}
2022
2023 void OMPClauseReader::VisitOMPThreadsClause(OMPThreadsClause *) {}
2024
2025 void OMPClauseReader::VisitOMPSIMDClause(OMPSIMDClause *) {}
2026
2027 void OMPClauseReader::VisitOMPNogroupClause(OMPNogroupClause *) {}
2028
2029 void OMPClauseReader::VisitOMPPrivateClause(OMPPrivateClause *C) {
2030   C->setLParenLoc(Reader->ReadSourceLocation());
2031   unsigned NumVars = C->varlist_size();
2032   SmallVector<Expr *, 16> Vars;
2033   Vars.reserve(NumVars);
2034   for (unsigned i = 0; i != NumVars; ++i)
2035     Vars.push_back(Reader->Record.readSubExpr());
2036   C->setVarRefs(Vars);
2037   Vars.clear();
2038   for (unsigned i = 0; i != NumVars; ++i)
2039     Vars.push_back(Reader->Record.readSubExpr());
2040   C->setPrivateCopies(Vars);
2041 }
2042
2043 void OMPClauseReader::VisitOMPFirstprivateClause(OMPFirstprivateClause *C) {
2044   VisitOMPClauseWithPreInit(C);
2045   C->setLParenLoc(Reader->ReadSourceLocation());
2046   unsigned NumVars = C->varlist_size();
2047   SmallVector<Expr *, 16> Vars;
2048   Vars.reserve(NumVars);
2049   for (unsigned i = 0; i != NumVars; ++i)
2050     Vars.push_back(Reader->Record.readSubExpr());
2051   C->setVarRefs(Vars);
2052   Vars.clear();
2053   for (unsigned i = 0; i != NumVars; ++i)
2054     Vars.push_back(Reader->Record.readSubExpr());
2055   C->setPrivateCopies(Vars);
2056   Vars.clear();
2057   for (unsigned i = 0; i != NumVars; ++i)
2058     Vars.push_back(Reader->Record.readSubExpr());
2059   C->setInits(Vars);
2060 }
2061
2062 void OMPClauseReader::VisitOMPLastprivateClause(OMPLastprivateClause *C) {
2063   VisitOMPClauseWithPostUpdate(C);
2064   C->setLParenLoc(Reader->ReadSourceLocation());
2065   unsigned NumVars = C->varlist_size();
2066   SmallVector<Expr *, 16> Vars;
2067   Vars.reserve(NumVars);
2068   for (unsigned i = 0; i != NumVars; ++i)
2069     Vars.push_back(Reader->Record.readSubExpr());
2070   C->setVarRefs(Vars);
2071   Vars.clear();
2072   for (unsigned i = 0; i != NumVars; ++i)
2073     Vars.push_back(Reader->Record.readSubExpr());
2074   C->setPrivateCopies(Vars);
2075   Vars.clear();
2076   for (unsigned i = 0; i != NumVars; ++i)
2077     Vars.push_back(Reader->Record.readSubExpr());
2078   C->setSourceExprs(Vars);
2079   Vars.clear();
2080   for (unsigned i = 0; i != NumVars; ++i)
2081     Vars.push_back(Reader->Record.readSubExpr());
2082   C->setDestinationExprs(Vars);
2083   Vars.clear();
2084   for (unsigned i = 0; i != NumVars; ++i)
2085     Vars.push_back(Reader->Record.readSubExpr());
2086   C->setAssignmentOps(Vars);
2087 }
2088
2089 void OMPClauseReader::VisitOMPSharedClause(OMPSharedClause *C) {
2090   C->setLParenLoc(Reader->ReadSourceLocation());
2091   unsigned NumVars = C->varlist_size();
2092   SmallVector<Expr *, 16> Vars;
2093   Vars.reserve(NumVars);
2094   for (unsigned i = 0; i != NumVars; ++i)
2095     Vars.push_back(Reader->Record.readSubExpr());
2096   C->setVarRefs(Vars);
2097 }
2098
2099 void OMPClauseReader::VisitOMPReductionClause(OMPReductionClause *C) {
2100   VisitOMPClauseWithPostUpdate(C);
2101   C->setLParenLoc(Reader->ReadSourceLocation());
2102   C->setColonLoc(Reader->ReadSourceLocation());
2103   NestedNameSpecifierLoc NNSL = Reader->Record.readNestedNameSpecifierLoc();
2104   DeclarationNameInfo DNI;
2105   Reader->ReadDeclarationNameInfo(DNI);
2106   C->setQualifierLoc(NNSL);
2107   C->setNameInfo(DNI);
2108
2109   unsigned NumVars = C->varlist_size();
2110   SmallVector<Expr *, 16> Vars;
2111   Vars.reserve(NumVars);
2112   for (unsigned i = 0; i != NumVars; ++i)
2113     Vars.push_back(Reader->Record.readSubExpr());
2114   C->setVarRefs(Vars);
2115   Vars.clear();
2116   for (unsigned i = 0; i != NumVars; ++i)
2117     Vars.push_back(Reader->Record.readSubExpr());
2118   C->setPrivates(Vars);
2119   Vars.clear();
2120   for (unsigned i = 0; i != NumVars; ++i)
2121     Vars.push_back(Reader->Record.readSubExpr());
2122   C->setLHSExprs(Vars);
2123   Vars.clear();
2124   for (unsigned i = 0; i != NumVars; ++i)
2125     Vars.push_back(Reader->Record.readSubExpr());
2126   C->setRHSExprs(Vars);
2127   Vars.clear();
2128   for (unsigned i = 0; i != NumVars; ++i)
2129     Vars.push_back(Reader->Record.readSubExpr());
2130   C->setReductionOps(Vars);
2131 }
2132
2133 void OMPClauseReader::VisitOMPLinearClause(OMPLinearClause *C) {
2134   VisitOMPClauseWithPostUpdate(C);
2135   C->setLParenLoc(Reader->ReadSourceLocation());
2136   C->setColonLoc(Reader->ReadSourceLocation());
2137   C->setModifier(static_cast<OpenMPLinearClauseKind>(Reader->Record.readInt()));
2138   C->setModifierLoc(Reader->ReadSourceLocation());
2139   unsigned NumVars = C->varlist_size();
2140   SmallVector<Expr *, 16> Vars;
2141   Vars.reserve(NumVars);
2142   for (unsigned i = 0; i != NumVars; ++i)
2143     Vars.push_back(Reader->Record.readSubExpr());
2144   C->setVarRefs(Vars);
2145   Vars.clear();
2146   for (unsigned i = 0; i != NumVars; ++i)
2147     Vars.push_back(Reader->Record.readSubExpr());
2148   C->setPrivates(Vars);
2149   Vars.clear();
2150   for (unsigned i = 0; i != NumVars; ++i)
2151     Vars.push_back(Reader->Record.readSubExpr());
2152   C->setInits(Vars);
2153   Vars.clear();
2154   for (unsigned i = 0; i != NumVars; ++i)
2155     Vars.push_back(Reader->Record.readSubExpr());
2156   C->setUpdates(Vars);
2157   Vars.clear();
2158   for (unsigned i = 0; i != NumVars; ++i)
2159     Vars.push_back(Reader->Record.readSubExpr());
2160   C->setFinals(Vars);
2161   C->setStep(Reader->Record.readSubExpr());
2162   C->setCalcStep(Reader->Record.readSubExpr());
2163 }
2164
2165 void OMPClauseReader::VisitOMPAlignedClause(OMPAlignedClause *C) {
2166   C->setLParenLoc(Reader->ReadSourceLocation());
2167   C->setColonLoc(Reader->ReadSourceLocation());
2168   unsigned NumVars = C->varlist_size();
2169   SmallVector<Expr *, 16> Vars;
2170   Vars.reserve(NumVars);
2171   for (unsigned i = 0; i != NumVars; ++i)
2172     Vars.push_back(Reader->Record.readSubExpr());
2173   C->setVarRefs(Vars);
2174   C->setAlignment(Reader->Record.readSubExpr());
2175 }
2176
2177 void OMPClauseReader::VisitOMPCopyinClause(OMPCopyinClause *C) {
2178   C->setLParenLoc(Reader->ReadSourceLocation());
2179   unsigned NumVars = C->varlist_size();
2180   SmallVector<Expr *, 16> Exprs;
2181   Exprs.reserve(NumVars);
2182   for (unsigned i = 0; i != NumVars; ++i)
2183     Exprs.push_back(Reader->Record.readSubExpr());
2184   C->setVarRefs(Exprs);
2185   Exprs.clear();
2186   for (unsigned i = 0; i != NumVars; ++i)
2187     Exprs.push_back(Reader->Record.readSubExpr());
2188   C->setSourceExprs(Exprs);
2189   Exprs.clear();
2190   for (unsigned i = 0; i != NumVars; ++i)
2191     Exprs.push_back(Reader->Record.readSubExpr());
2192   C->setDestinationExprs(Exprs);
2193   Exprs.clear();
2194   for (unsigned i = 0; i != NumVars; ++i)
2195     Exprs.push_back(Reader->Record.readSubExpr());
2196   C->setAssignmentOps(Exprs);
2197 }
2198
2199 void OMPClauseReader::VisitOMPCopyprivateClause(OMPCopyprivateClause *C) {
2200   C->setLParenLoc(Reader->ReadSourceLocation());
2201   unsigned NumVars = C->varlist_size();
2202   SmallVector<Expr *, 16> Exprs;
2203   Exprs.reserve(NumVars);
2204   for (unsigned i = 0; i != NumVars; ++i)
2205     Exprs.push_back(Reader->Record.readSubExpr());
2206   C->setVarRefs(Exprs);
2207   Exprs.clear();
2208   for (unsigned i = 0; i != NumVars; ++i)
2209     Exprs.push_back(Reader->Record.readSubExpr());
2210   C->setSourceExprs(Exprs);
2211   Exprs.clear();
2212   for (unsigned i = 0; i != NumVars; ++i)
2213     Exprs.push_back(Reader->Record.readSubExpr());
2214   C->setDestinationExprs(Exprs);
2215   Exprs.clear();
2216   for (unsigned i = 0; i != NumVars; ++i)
2217     Exprs.push_back(Reader->Record.readSubExpr());
2218   C->setAssignmentOps(Exprs);
2219 }
2220
2221 void OMPClauseReader::VisitOMPFlushClause(OMPFlushClause *C) {
2222   C->setLParenLoc(Reader->ReadSourceLocation());
2223   unsigned NumVars = C->varlist_size();
2224   SmallVector<Expr *, 16> Vars;
2225   Vars.reserve(NumVars);
2226   for (unsigned i = 0; i != NumVars; ++i)
2227     Vars.push_back(Reader->Record.readSubExpr());
2228   C->setVarRefs(Vars);
2229 }
2230
2231 void OMPClauseReader::VisitOMPDependClause(OMPDependClause *C) {
2232   C->setLParenLoc(Reader->ReadSourceLocation());
2233   C->setDependencyKind(
2234       static_cast<OpenMPDependClauseKind>(Reader->Record.readInt()));
2235   C->setDependencyLoc(Reader->ReadSourceLocation());
2236   C->setColonLoc(Reader->ReadSourceLocation());
2237   unsigned NumVars = C->varlist_size();
2238   SmallVector<Expr *, 16> Vars;
2239   Vars.reserve(NumVars);
2240   for (unsigned i = 0; i != NumVars; ++i)
2241     Vars.push_back(Reader->Record.readSubExpr());
2242   C->setVarRefs(Vars);
2243   C->setCounterValue(Reader->Record.readSubExpr());
2244 }
2245
2246 void OMPClauseReader::VisitOMPDeviceClause(OMPDeviceClause *C) {
2247   C->setDevice(Reader->Record.readSubExpr());
2248   C->setLParenLoc(Reader->ReadSourceLocation());
2249 }
2250
2251 void OMPClauseReader::VisitOMPMapClause(OMPMapClause *C) {
2252   C->setLParenLoc(Reader->ReadSourceLocation());
2253   C->setMapTypeModifier(
2254      static_cast<OpenMPMapClauseKind>(Reader->Record.readInt()));
2255   C->setMapType(
2256      static_cast<OpenMPMapClauseKind>(Reader->Record.readInt()));
2257   C->setMapLoc(Reader->ReadSourceLocation());
2258   C->setColonLoc(Reader->ReadSourceLocation());
2259   auto NumVars = C->varlist_size();
2260   auto UniqueDecls = C->getUniqueDeclarationsNum();
2261   auto TotalLists = C->getTotalComponentListNum();
2262   auto TotalComponents = C->getTotalComponentsNum();
2263
2264   SmallVector<Expr *, 16> Vars;
2265   Vars.reserve(NumVars);
2266   for (unsigned i = 0; i != NumVars; ++i)
2267     Vars.push_back(Reader->Record.readSubExpr());
2268   C->setVarRefs(Vars);
2269
2270   SmallVector<ValueDecl *, 16> Decls;
2271   Decls.reserve(UniqueDecls);
2272   for (unsigned i = 0; i < UniqueDecls; ++i)
2273     Decls.push_back(Reader->Record.readDeclAs<ValueDecl>());
2274   C->setUniqueDecls(Decls);
2275
2276   SmallVector<unsigned, 16> ListsPerDecl;
2277   ListsPerDecl.reserve(UniqueDecls);
2278   for (unsigned i = 0; i < UniqueDecls; ++i)
2279     ListsPerDecl.push_back(Reader->Record.readInt());
2280   C->setDeclNumLists(ListsPerDecl);
2281
2282   SmallVector<unsigned, 32> ListSizes;
2283   ListSizes.reserve(TotalLists);
2284   for (unsigned i = 0; i < TotalLists; ++i)
2285     ListSizes.push_back(Reader->Record.readInt());
2286   C->setComponentListSizes(ListSizes);
2287
2288   SmallVector<OMPClauseMappableExprCommon::MappableComponent, 32> Components;
2289   Components.reserve(TotalComponents);
2290   for (unsigned i = 0; i < TotalComponents; ++i) {
2291     Expr *AssociatedExpr = Reader->Record.readSubExpr();
2292     ValueDecl *AssociatedDecl = Reader->Record.readDeclAs<ValueDecl>();
2293     Components.push_back(OMPClauseMappableExprCommon::MappableComponent(
2294         AssociatedExpr, AssociatedDecl));
2295   }
2296   C->setComponents(Components, ListSizes);
2297 }
2298
2299 void OMPClauseReader::VisitOMPNumTeamsClause(OMPNumTeamsClause *C) {
2300   C->setNumTeams(Reader->Record.readSubExpr());
2301   C->setLParenLoc(Reader->ReadSourceLocation());
2302 }
2303
2304 void OMPClauseReader::VisitOMPThreadLimitClause(OMPThreadLimitClause *C) {
2305   C->setThreadLimit(Reader->Record.readSubExpr());
2306   C->setLParenLoc(Reader->ReadSourceLocation());
2307 }
2308
2309 void OMPClauseReader::VisitOMPPriorityClause(OMPPriorityClause *C) {
2310   C->setPriority(Reader->Record.readSubExpr());
2311   C->setLParenLoc(Reader->ReadSourceLocation());
2312 }
2313
2314 void OMPClauseReader::VisitOMPGrainsizeClause(OMPGrainsizeClause *C) {
2315   C->setGrainsize(Reader->Record.readSubExpr());
2316   C->setLParenLoc(Reader->ReadSourceLocation());
2317 }
2318
2319 void OMPClauseReader::VisitOMPNumTasksClause(OMPNumTasksClause *C) {
2320   C->setNumTasks(Reader->Record.readSubExpr());
2321   C->setLParenLoc(Reader->ReadSourceLocation());
2322 }
2323
2324 void OMPClauseReader::VisitOMPHintClause(OMPHintClause *C) {
2325   C->setHint(Reader->Record.readSubExpr());
2326   C->setLParenLoc(Reader->ReadSourceLocation());
2327 }
2328
2329 void OMPClauseReader::VisitOMPDistScheduleClause(OMPDistScheduleClause *C) {
2330   VisitOMPClauseWithPreInit(C);
2331   C->setDistScheduleKind(
2332       static_cast<OpenMPDistScheduleClauseKind>(Reader->Record.readInt()));
2333   C->setChunkSize(Reader->Record.readSubExpr());
2334   C->setLParenLoc(Reader->ReadSourceLocation());
2335   C->setDistScheduleKindLoc(Reader->ReadSourceLocation());
2336   C->setCommaLoc(Reader->ReadSourceLocation());
2337 }
2338
2339 void OMPClauseReader::VisitOMPDefaultmapClause(OMPDefaultmapClause *C) {
2340   C->setDefaultmapKind(
2341        static_cast<OpenMPDefaultmapClauseKind>(Reader->Record.readInt()));
2342   C->setDefaultmapModifier(
2343       static_cast<OpenMPDefaultmapClauseModifier>(Reader->Record.readInt()));
2344   C->setLParenLoc(Reader->ReadSourceLocation());
2345   C->setDefaultmapModifierLoc(Reader->ReadSourceLocation());
2346   C->setDefaultmapKindLoc(Reader->ReadSourceLocation());
2347 }
2348
2349 void OMPClauseReader::VisitOMPToClause(OMPToClause *C) {
2350   C->setLParenLoc(Reader->ReadSourceLocation());
2351   auto NumVars = C->varlist_size();
2352   auto UniqueDecls = C->getUniqueDeclarationsNum();
2353   auto TotalLists = C->getTotalComponentListNum();
2354   auto TotalComponents = C->getTotalComponentsNum();
2355
2356   SmallVector<Expr *, 16> Vars;
2357   Vars.reserve(NumVars);
2358   for (unsigned i = 0; i != NumVars; ++i)
2359     Vars.push_back(Reader->Record.readSubExpr());
2360   C->setVarRefs(Vars);
2361
2362   SmallVector<ValueDecl *, 16> Decls;
2363   Decls.reserve(UniqueDecls);
2364   for (unsigned i = 0; i < UniqueDecls; ++i)
2365     Decls.push_back(Reader->Record.readDeclAs<ValueDecl>());
2366   C->setUniqueDecls(Decls);
2367
2368   SmallVector<unsigned, 16> ListsPerDecl;
2369   ListsPerDecl.reserve(UniqueDecls);
2370   for (unsigned i = 0; i < UniqueDecls; ++i)
2371     ListsPerDecl.push_back(Reader->Record.readInt());
2372   C->setDeclNumLists(ListsPerDecl);
2373
2374   SmallVector<unsigned, 32> ListSizes;
2375   ListSizes.reserve(TotalLists);
2376   for (unsigned i = 0; i < TotalLists; ++i)
2377     ListSizes.push_back(Reader->Record.readInt());
2378   C->setComponentListSizes(ListSizes);
2379
2380   SmallVector<OMPClauseMappableExprCommon::MappableComponent, 32> Components;
2381   Components.reserve(TotalComponents);
2382   for (unsigned i = 0; i < TotalComponents; ++i) {
2383     Expr *AssociatedExpr = Reader->Record.readSubExpr();
2384     ValueDecl *AssociatedDecl = Reader->Record.readDeclAs<ValueDecl>();
2385     Components.push_back(OMPClauseMappableExprCommon::MappableComponent(
2386         AssociatedExpr, AssociatedDecl));
2387   }
2388   C->setComponents(Components, ListSizes);
2389 }
2390
2391 void OMPClauseReader::VisitOMPFromClause(OMPFromClause *C) {
2392   C->setLParenLoc(Reader->ReadSourceLocation());
2393   auto NumVars = C->varlist_size();
2394   auto UniqueDecls = C->getUniqueDeclarationsNum();
2395   auto TotalLists = C->getTotalComponentListNum();
2396   auto TotalComponents = C->getTotalComponentsNum();
2397
2398   SmallVector<Expr *, 16> Vars;
2399   Vars.reserve(NumVars);
2400   for (unsigned i = 0; i != NumVars; ++i)
2401     Vars.push_back(Reader->Record.readSubExpr());
2402   C->setVarRefs(Vars);
2403
2404   SmallVector<ValueDecl *, 16> Decls;
2405   Decls.reserve(UniqueDecls);
2406   for (unsigned i = 0; i < UniqueDecls; ++i)
2407     Decls.push_back(Reader->Record.readDeclAs<ValueDecl>());
2408   C->setUniqueDecls(Decls);
2409
2410   SmallVector<unsigned, 16> ListsPerDecl;
2411   ListsPerDecl.reserve(UniqueDecls);
2412   for (unsigned i = 0; i < UniqueDecls; ++i)
2413     ListsPerDecl.push_back(Reader->Record.readInt());
2414   C->setDeclNumLists(ListsPerDecl);
2415
2416   SmallVector<unsigned, 32> ListSizes;
2417   ListSizes.reserve(TotalLists);
2418   for (unsigned i = 0; i < TotalLists; ++i)
2419     ListSizes.push_back(Reader->Record.readInt());
2420   C->setComponentListSizes(ListSizes);
2421
2422   SmallVector<OMPClauseMappableExprCommon::MappableComponent, 32> Components;
2423   Components.reserve(TotalComponents);
2424   for (unsigned i = 0; i < TotalComponents; ++i) {
2425     Expr *AssociatedExpr = Reader->Record.readSubExpr();
2426     ValueDecl *AssociatedDecl = Reader->Record.readDeclAs<ValueDecl>();
2427     Components.push_back(OMPClauseMappableExprCommon::MappableComponent(
2428         AssociatedExpr, AssociatedDecl));
2429   }
2430   C->setComponents(Components, ListSizes);
2431 }
2432
2433 void OMPClauseReader::VisitOMPUseDevicePtrClause(OMPUseDevicePtrClause *C) {
2434   C->setLParenLoc(Reader->ReadSourceLocation());
2435   auto NumVars = C->varlist_size();
2436   auto UniqueDecls = C->getUniqueDeclarationsNum();
2437   auto TotalLists = C->getTotalComponentListNum();
2438   auto TotalComponents = C->getTotalComponentsNum();
2439
2440   SmallVector<Expr *, 16> Vars;
2441   Vars.reserve(NumVars);
2442   for (unsigned i = 0; i != NumVars; ++i)
2443     Vars.push_back(Reader->Record.readSubExpr());
2444   C->setVarRefs(Vars);
2445   Vars.clear();
2446   for (unsigned i = 0; i != NumVars; ++i)
2447     Vars.push_back(Reader->Record.readSubExpr());
2448   C->setPrivateCopies(Vars);
2449   Vars.clear();
2450   for (unsigned i = 0; i != NumVars; ++i)
2451     Vars.push_back(Reader->Record.readSubExpr());
2452   C->setInits(Vars);
2453
2454   SmallVector<ValueDecl *, 16> Decls;
2455   Decls.reserve(UniqueDecls);
2456   for (unsigned i = 0; i < UniqueDecls; ++i)
2457     Decls.push_back(Reader->Record.readDeclAs<ValueDecl>());
2458   C->setUniqueDecls(Decls);
2459
2460   SmallVector<unsigned, 16> ListsPerDecl;
2461   ListsPerDecl.reserve(UniqueDecls);
2462   for (unsigned i = 0; i < UniqueDecls; ++i)
2463     ListsPerDecl.push_back(Reader->Record.readInt());
2464   C->setDeclNumLists(ListsPerDecl);
2465
2466   SmallVector<unsigned, 32> ListSizes;
2467   ListSizes.reserve(TotalLists);
2468   for (unsigned i = 0; i < TotalLists; ++i)
2469     ListSizes.push_back(Reader->Record.readInt());
2470   C->setComponentListSizes(ListSizes);
2471
2472   SmallVector<OMPClauseMappableExprCommon::MappableComponent, 32> Components;
2473   Components.reserve(TotalComponents);
2474   for (unsigned i = 0; i < TotalComponents; ++i) {
2475     Expr *AssociatedExpr = Reader->Record.readSubExpr();
2476     ValueDecl *AssociatedDecl = Reader->Record.readDeclAs<ValueDecl>();
2477     Components.push_back(OMPClauseMappableExprCommon::MappableComponent(
2478         AssociatedExpr, AssociatedDecl));
2479   }
2480   C->setComponents(Components, ListSizes);
2481 }
2482
2483 void OMPClauseReader::VisitOMPIsDevicePtrClause(OMPIsDevicePtrClause *C) {
2484   C->setLParenLoc(Reader->ReadSourceLocation());
2485   auto NumVars = C->varlist_size();
2486   auto UniqueDecls = C->getUniqueDeclarationsNum();
2487   auto TotalLists = C->getTotalComponentListNum();
2488   auto TotalComponents = C->getTotalComponentsNum();
2489
2490   SmallVector<Expr *, 16> Vars;
2491   Vars.reserve(NumVars);
2492   for (unsigned i = 0; i != NumVars; ++i)
2493     Vars.push_back(Reader->Record.readSubExpr());
2494   C->setVarRefs(Vars);
2495   Vars.clear();
2496
2497   SmallVector<ValueDecl *, 16> Decls;
2498   Decls.reserve(UniqueDecls);
2499   for (unsigned i = 0; i < UniqueDecls; ++i)
2500     Decls.push_back(Reader->Record.readDeclAs<ValueDecl>());
2501   C->setUniqueDecls(Decls);
2502
2503   SmallVector<unsigned, 16> ListsPerDecl;
2504   ListsPerDecl.reserve(UniqueDecls);
2505   for (unsigned i = 0; i < UniqueDecls; ++i)
2506     ListsPerDecl.push_back(Reader->Record.readInt());
2507   C->setDeclNumLists(ListsPerDecl);
2508
2509   SmallVector<unsigned, 32> ListSizes;
2510   ListSizes.reserve(TotalLists);
2511   for (unsigned i = 0; i < TotalLists; ++i)
2512     ListSizes.push_back(Reader->Record.readInt());
2513   C->setComponentListSizes(ListSizes);
2514
2515   SmallVector<OMPClauseMappableExprCommon::MappableComponent, 32> Components;
2516   Components.reserve(TotalComponents);
2517   for (unsigned i = 0; i < TotalComponents; ++i) {
2518     Expr *AssociatedExpr = Reader->Record.readSubExpr();
2519     ValueDecl *AssociatedDecl = Reader->Record.readDeclAs<ValueDecl>();
2520     Components.push_back(OMPClauseMappableExprCommon::MappableComponent(
2521         AssociatedExpr, AssociatedDecl));
2522   }
2523   C->setComponents(Components, ListSizes);
2524 }
2525
2526 //===----------------------------------------------------------------------===//
2527 // OpenMP Directives.
2528 //===----------------------------------------------------------------------===//
2529 void ASTStmtReader::VisitOMPExecutableDirective(OMPExecutableDirective *E) {
2530   E->setLocStart(ReadSourceLocation());
2531   E->setLocEnd(ReadSourceLocation());
2532   OMPClauseReader ClauseReader(this, Record);
2533   SmallVector<OMPClause *, 5> Clauses;
2534   for (unsigned i = 0; i < E->getNumClauses(); ++i)
2535     Clauses.push_back(ClauseReader.readClause());
2536   E->setClauses(Clauses);
2537   if (E->hasAssociatedStmt())
2538     E->setAssociatedStmt(Record.readSubStmt());
2539 }
2540
2541 void ASTStmtReader::VisitOMPLoopDirective(OMPLoopDirective *D) {
2542   VisitStmt(D);
2543   // Two fields (NumClauses and CollapsedNum) were read in ReadStmtFromStream.
2544   Record.skipInts(2);
2545   VisitOMPExecutableDirective(D);
2546   D->setIterationVariable(Record.readSubExpr());
2547   D->setLastIteration(Record.readSubExpr());
2548   D->setCalcLastIteration(Record.readSubExpr());
2549   D->setPreCond(Record.readSubExpr());
2550   D->setCond(Record.readSubExpr());
2551   D->setInit(Record.readSubExpr());
2552   D->setInc(Record.readSubExpr());
2553   D->setPreInits(Record.readSubStmt());
2554   if (isOpenMPWorksharingDirective(D->getDirectiveKind()) ||
2555       isOpenMPTaskLoopDirective(D->getDirectiveKind()) ||
2556       isOpenMPDistributeDirective(D->getDirectiveKind())) {
2557     D->setIsLastIterVariable(Record.readSubExpr());
2558     D->setLowerBoundVariable(Record.readSubExpr());
2559     D->setUpperBoundVariable(Record.readSubExpr());
2560     D->setStrideVariable(Record.readSubExpr());
2561     D->setEnsureUpperBound(Record.readSubExpr());
2562     D->setNextLowerBound(Record.readSubExpr());
2563     D->setNextUpperBound(Record.readSubExpr());
2564     D->setNumIterations(Record.readSubExpr());
2565   }
2566   if (isOpenMPLoopBoundSharingDirective(D->getDirectiveKind())) {
2567     D->setPrevLowerBoundVariable(Record.readSubExpr());
2568     D->setPrevUpperBoundVariable(Record.readSubExpr());
2569   }
2570   SmallVector<Expr *, 4> Sub;
2571   unsigned CollapsedNum = D->getCollapsedNumber();
2572   Sub.reserve(CollapsedNum);
2573   for (unsigned i = 0; i < CollapsedNum; ++i)
2574     Sub.push_back(Record.readSubExpr());
2575   D->setCounters(Sub);
2576   Sub.clear();
2577   for (unsigned i = 0; i < CollapsedNum; ++i)
2578     Sub.push_back(Record.readSubExpr());
2579   D->setPrivateCounters(Sub);
2580   Sub.clear();
2581   for (unsigned i = 0; i < CollapsedNum; ++i)
2582     Sub.push_back(Record.readSubExpr());
2583   D->setInits(Sub);
2584   Sub.clear();
2585   for (unsigned i = 0; i < CollapsedNum; ++i)
2586     Sub.push_back(Record.readSubExpr());
2587   D->setUpdates(Sub);
2588   Sub.clear();
2589   for (unsigned i = 0; i < CollapsedNum; ++i)
2590     Sub.push_back(Record.readSubExpr());
2591   D->setFinals(Sub);
2592 }
2593
2594 void ASTStmtReader::VisitOMPParallelDirective(OMPParallelDirective *D) {
2595   VisitStmt(D);
2596   // The NumClauses field was read in ReadStmtFromStream.
2597   Record.skipInts(1);
2598   VisitOMPExecutableDirective(D);
2599   D->setHasCancel(Record.readInt());
2600 }
2601
2602 void ASTStmtReader::VisitOMPSimdDirective(OMPSimdDirective *D) {
2603   VisitOMPLoopDirective(D);
2604 }
2605
2606 void ASTStmtReader::VisitOMPForDirective(OMPForDirective *D) {
2607   VisitOMPLoopDirective(D);
2608   D->setHasCancel(Record.readInt());
2609 }
2610
2611 void ASTStmtReader::VisitOMPForSimdDirective(OMPForSimdDirective *D) {
2612   VisitOMPLoopDirective(D);
2613 }
2614
2615 void ASTStmtReader::VisitOMPSectionsDirective(OMPSectionsDirective *D) {
2616   VisitStmt(D);
2617   // The NumClauses field was read in ReadStmtFromStream.
2618   Record.skipInts(1);
2619   VisitOMPExecutableDirective(D);
2620   D->setHasCancel(Record.readInt());
2621 }
2622
2623 void ASTStmtReader::VisitOMPSectionDirective(OMPSectionDirective *D) {
2624   VisitStmt(D);
2625   VisitOMPExecutableDirective(D);
2626   D->setHasCancel(Record.readInt());
2627 }
2628
2629 void ASTStmtReader::VisitOMPSingleDirective(OMPSingleDirective *D) {
2630   VisitStmt(D);
2631   // The NumClauses field was read in ReadStmtFromStream.
2632   Record.skipInts(1);
2633   VisitOMPExecutableDirective(D);
2634 }
2635
2636 void ASTStmtReader::VisitOMPMasterDirective(OMPMasterDirective *D) {
2637   VisitStmt(D);
2638   VisitOMPExecutableDirective(D);
2639 }
2640
2641 void ASTStmtReader::VisitOMPCriticalDirective(OMPCriticalDirective *D) {
2642   VisitStmt(D);
2643   // The NumClauses field was read in ReadStmtFromStream.
2644   Record.skipInts(1);
2645   VisitOMPExecutableDirective(D);
2646   ReadDeclarationNameInfo(D->DirName);
2647 }
2648
2649 void ASTStmtReader::VisitOMPParallelForDirective(OMPParallelForDirective *D) {
2650   VisitOMPLoopDirective(D);
2651   D->setHasCancel(Record.readInt());
2652 }
2653
2654 void ASTStmtReader::VisitOMPParallelForSimdDirective(
2655     OMPParallelForSimdDirective *D) {
2656   VisitOMPLoopDirective(D);
2657 }
2658
2659 void ASTStmtReader::VisitOMPParallelSectionsDirective(
2660     OMPParallelSectionsDirective *D) {
2661   VisitStmt(D);
2662   // The NumClauses field was read in ReadStmtFromStream.
2663   Record.skipInts(1);
2664   VisitOMPExecutableDirective(D);
2665   D->setHasCancel(Record.readInt());
2666 }
2667
2668 void ASTStmtReader::VisitOMPTaskDirective(OMPTaskDirective *D) {
2669   VisitStmt(D);
2670   // The NumClauses field was read in ReadStmtFromStream.
2671   Record.skipInts(1);
2672   VisitOMPExecutableDirective(D);
2673   D->setHasCancel(Record.readInt());
2674 }
2675
2676 void ASTStmtReader::VisitOMPTaskyieldDirective(OMPTaskyieldDirective *D) {
2677   VisitStmt(D);
2678   VisitOMPExecutableDirective(D);
2679 }
2680
2681 void ASTStmtReader::VisitOMPBarrierDirective(OMPBarrierDirective *D) {
2682   VisitStmt(D);
2683   VisitOMPExecutableDirective(D);
2684 }
2685
2686 void ASTStmtReader::VisitOMPTaskwaitDirective(OMPTaskwaitDirective *D) {
2687   VisitStmt(D);
2688   VisitOMPExecutableDirective(D);
2689 }
2690
2691 void ASTStmtReader::VisitOMPTaskgroupDirective(OMPTaskgroupDirective *D) {
2692   VisitStmt(D);
2693   VisitOMPExecutableDirective(D);
2694 }
2695
2696 void ASTStmtReader::VisitOMPFlushDirective(OMPFlushDirective *D) {
2697   VisitStmt(D);
2698   // The NumClauses field was read in ReadStmtFromStream.
2699   Record.skipInts(1);
2700   VisitOMPExecutableDirective(D);
2701 }
2702
2703 void ASTStmtReader::VisitOMPOrderedDirective(OMPOrderedDirective *D) {
2704   VisitStmt(D);
2705   // The NumClauses field was read in ReadStmtFromStream.
2706   Record.skipInts(1);
2707   VisitOMPExecutableDirective(D);
2708 }
2709
2710 void ASTStmtReader::VisitOMPAtomicDirective(OMPAtomicDirective *D) {
2711   VisitStmt(D);
2712   // The NumClauses field was read in ReadStmtFromStream.
2713   Record.skipInts(1);
2714   VisitOMPExecutableDirective(D);
2715   D->setX(Record.readSubExpr());
2716   D->setV(Record.readSubExpr());
2717   D->setExpr(Record.readSubExpr());
2718   D->setUpdateExpr(Record.readSubExpr());
2719   D->IsXLHSInRHSPart = Record.readInt() != 0;
2720   D->IsPostfixUpdate = Record.readInt() != 0;
2721 }
2722
2723 void ASTStmtReader::VisitOMPTargetDirective(OMPTargetDirective *D) {
2724   VisitStmt(D);
2725   // The NumClauses field was read in ReadStmtFromStream.
2726   Record.skipInts(1);
2727   VisitOMPExecutableDirective(D);
2728 }
2729
2730 void ASTStmtReader::VisitOMPTargetDataDirective(OMPTargetDataDirective *D) {
2731   VisitStmt(D);
2732   Record.skipInts(1);
2733   VisitOMPExecutableDirective(D);
2734 }
2735
2736 void ASTStmtReader::VisitOMPTargetEnterDataDirective(
2737     OMPTargetEnterDataDirective *D) {
2738   VisitStmt(D);
2739   Record.skipInts(1);
2740   VisitOMPExecutableDirective(D);
2741 }
2742
2743 void ASTStmtReader::VisitOMPTargetExitDataDirective(
2744     OMPTargetExitDataDirective *D) {
2745   VisitStmt(D);
2746   Record.skipInts(1);
2747   VisitOMPExecutableDirective(D);
2748 }
2749
2750 void ASTStmtReader::VisitOMPTargetParallelDirective(
2751     OMPTargetParallelDirective *D) {
2752   VisitStmt(D);
2753   Record.skipInts(1);
2754   VisitOMPExecutableDirective(D);
2755 }
2756
2757 void ASTStmtReader::VisitOMPTargetParallelForDirective(
2758     OMPTargetParallelForDirective *D) {
2759   VisitOMPLoopDirective(D);
2760   D->setHasCancel(Record.readInt());
2761 }
2762
2763 void ASTStmtReader::VisitOMPTeamsDirective(OMPTeamsDirective *D) {
2764   VisitStmt(D);
2765   // The NumClauses field was read in ReadStmtFromStream.
2766   Record.skipInts(1);
2767   VisitOMPExecutableDirective(D);
2768 }
2769
2770 void ASTStmtReader::VisitOMPCancellationPointDirective(
2771     OMPCancellationPointDirective *D) {
2772   VisitStmt(D);
2773   VisitOMPExecutableDirective(D);
2774   D->setCancelRegion(static_cast<OpenMPDirectiveKind>(Record.readInt()));
2775 }
2776
2777 void ASTStmtReader::VisitOMPCancelDirective(OMPCancelDirective *D) {
2778   VisitStmt(D);
2779   // The NumClauses field was read in ReadStmtFromStream.
2780   Record.skipInts(1);
2781   VisitOMPExecutableDirective(D);
2782   D->setCancelRegion(static_cast<OpenMPDirectiveKind>(Record.readInt()));
2783 }
2784
2785 void ASTStmtReader::VisitOMPTaskLoopDirective(OMPTaskLoopDirective *D) {
2786   VisitOMPLoopDirective(D);
2787 }
2788
2789 void ASTStmtReader::VisitOMPTaskLoopSimdDirective(OMPTaskLoopSimdDirective *D) {
2790   VisitOMPLoopDirective(D);
2791 }
2792
2793 void ASTStmtReader::VisitOMPDistributeDirective(OMPDistributeDirective *D) {
2794   VisitOMPLoopDirective(D);
2795 }
2796
2797 void ASTStmtReader::VisitOMPTargetUpdateDirective(OMPTargetUpdateDirective *D) {
2798   VisitStmt(D);
2799   Record.skipInts(1);
2800   VisitOMPExecutableDirective(D);
2801 }
2802 void ASTStmtReader::VisitOMPDistributeParallelForDirective(
2803     OMPDistributeParallelForDirective *D) {
2804   VisitOMPLoopDirective(D);
2805 }
2806
2807 void ASTStmtReader::VisitOMPDistributeParallelForSimdDirective(
2808     OMPDistributeParallelForSimdDirective *D) {
2809   VisitOMPLoopDirective(D);
2810 }
2811
2812 void ASTStmtReader::VisitOMPDistributeSimdDirective(
2813     OMPDistributeSimdDirective *D) {
2814   VisitOMPLoopDirective(D);
2815 }
2816
2817 void ASTStmtReader::VisitOMPTargetParallelForSimdDirective(
2818     OMPTargetParallelForSimdDirective *D) {
2819   VisitOMPLoopDirective(D);
2820 }
2821
2822 void ASTStmtReader::VisitOMPTargetSimdDirective(OMPTargetSimdDirective *D) {
2823   VisitOMPLoopDirective(D);
2824 }
2825
2826 void ASTStmtReader::VisitOMPTeamsDistributeDirective(
2827     OMPTeamsDistributeDirective *D) {
2828   VisitOMPLoopDirective(D);
2829 }
2830
2831 void ASTStmtReader::VisitOMPTeamsDistributeSimdDirective(
2832     OMPTeamsDistributeSimdDirective *D) {
2833   VisitOMPLoopDirective(D);
2834 }
2835
2836 void ASTStmtReader::VisitOMPTeamsDistributeParallelForSimdDirective(
2837     OMPTeamsDistributeParallelForSimdDirective *D) {
2838   VisitOMPLoopDirective(D);
2839 }
2840
2841 void ASTStmtReader::VisitOMPTeamsDistributeParallelForDirective(
2842     OMPTeamsDistributeParallelForDirective *D) {
2843   VisitOMPLoopDirective(D);
2844 }
2845
2846 void ASTStmtReader::VisitOMPTargetTeamsDirective(OMPTargetTeamsDirective *D) {
2847   VisitStmt(D);
2848   // The NumClauses field was read in ReadStmtFromStream.
2849   Record.skipInts(1);
2850   VisitOMPExecutableDirective(D);
2851 }
2852
2853 void ASTStmtReader::VisitOMPTargetTeamsDistributeDirective(
2854     OMPTargetTeamsDistributeDirective *D) {
2855   VisitOMPLoopDirective(D);
2856 }
2857
2858 void ASTStmtReader::VisitOMPTargetTeamsDistributeParallelForDirective(
2859     OMPTargetTeamsDistributeParallelForDirective *D) {
2860   VisitOMPLoopDirective(D);
2861 }
2862
2863 void ASTStmtReader::VisitOMPTargetTeamsDistributeParallelForSimdDirective(
2864     OMPTargetTeamsDistributeParallelForSimdDirective *D) {
2865   VisitOMPLoopDirective(D);
2866 }
2867
2868 void ASTStmtReader::VisitOMPTargetTeamsDistributeSimdDirective(
2869     OMPTargetTeamsDistributeSimdDirective *D) {
2870   VisitOMPLoopDirective(D);
2871 }
2872
2873 //===----------------------------------------------------------------------===//
2874 // ASTReader Implementation
2875 //===----------------------------------------------------------------------===//
2876
2877 Stmt *ASTReader::ReadStmt(ModuleFile &F) {
2878   switch (ReadingKind) {
2879   case Read_None:
2880     llvm_unreachable("should not call this when not reading anything");
2881   case Read_Decl:
2882   case Read_Type:
2883     return ReadStmtFromStream(F);
2884   case Read_Stmt:
2885     return ReadSubStmt();
2886   }
2887
2888   llvm_unreachable("ReadingKind not set ?");
2889 }
2890
2891 Expr *ASTReader::ReadExpr(ModuleFile &F) {
2892   return cast_or_null<Expr>(ReadStmt(F));
2893 }
2894
2895 Expr *ASTReader::ReadSubExpr() {
2896   return cast_or_null<Expr>(ReadSubStmt());
2897 }
2898
2899 // Within the bitstream, expressions are stored in Reverse Polish
2900 // Notation, with each of the subexpressions preceding the
2901 // expression they are stored in. Subexpressions are stored from last to first.
2902 // To evaluate expressions, we continue reading expressions and placing them on
2903 // the stack, with expressions having operands removing those operands from the
2904 // stack. Evaluation terminates when we see a STMT_STOP record, and
2905 // the single remaining expression on the stack is our result.
2906 Stmt *ASTReader::ReadStmtFromStream(ModuleFile &F) {
2907
2908   ReadingKindTracker ReadingKind(Read_Stmt, *this);
2909   llvm::BitstreamCursor &Cursor = F.DeclsCursor;
2910
2911   // Map of offset to previously deserialized stmt. The offset points
2912   /// just after the stmt record.
2913   llvm::DenseMap<uint64_t, Stmt *> StmtEntries;
2914
2915 #ifndef NDEBUG
2916   unsigned PrevNumStmts = StmtStack.size();
2917 #endif
2918
2919   ASTRecordReader Record(*this, F);
2920   ASTStmtReader Reader(Record, Cursor);
2921   Stmt::EmptyShell Empty;
2922
2923   while (true) {
2924     llvm::BitstreamEntry Entry = Cursor.advanceSkippingSubblocks();
2925
2926     switch (Entry.Kind) {
2927     case llvm::BitstreamEntry::SubBlock: // Handled for us already.
2928     case llvm::BitstreamEntry::Error:
2929       Error("malformed block record in AST file");
2930       return nullptr;
2931     case llvm::BitstreamEntry::EndBlock:
2932       goto Done;
2933     case llvm::BitstreamEntry::Record:
2934       // The interesting case.
2935       break;
2936     }
2937
2938     Stmt *S = nullptr;
2939     bool Finished = false;
2940     bool IsStmtReference = false;
2941     switch ((StmtCode)Record.readRecord(Cursor, Entry.ID)) {
2942     case STMT_STOP:
2943       Finished = true;
2944       break;
2945
2946     case STMT_REF_PTR:
2947       IsStmtReference = true;
2948       assert(StmtEntries.find(Record[0]) != StmtEntries.end() &&
2949              "No stmt was recorded for this offset reference!");
2950       S = StmtEntries[Record.readInt()];
2951       break;
2952
2953     case STMT_NULL_PTR:
2954       S = nullptr;
2955       break;
2956
2957     case STMT_NULL:
2958       S = new (Context) NullStmt(Empty);
2959       break;
2960
2961     case STMT_COMPOUND:
2962       S = new (Context) CompoundStmt(Empty);
2963       break;
2964
2965     case STMT_CASE:
2966       S = new (Context) CaseStmt(Empty);
2967       break;
2968
2969     case STMT_DEFAULT:
2970       S = new (Context) DefaultStmt(Empty);
2971       break;
2972
2973     case STMT_LABEL:
2974       S = new (Context) LabelStmt(Empty);
2975       break;
2976
2977     case STMT_ATTRIBUTED:
2978       S = AttributedStmt::CreateEmpty(
2979         Context,
2980         /*NumAttrs*/Record[ASTStmtReader::NumStmtFields]);
2981       break;
2982
2983     case STMT_IF:
2984       S = new (Context) IfStmt(Empty);
2985       break;
2986
2987     case STMT_SWITCH:
2988       S = new (Context) SwitchStmt(Empty);
2989       break;
2990
2991     case STMT_WHILE:
2992       S = new (Context) WhileStmt(Empty);
2993       break;
2994
2995     case STMT_DO:
2996       S = new (Context) DoStmt(Empty);
2997       break;
2998
2999     case STMT_FOR:
3000       S = new (Context) ForStmt(Empty);
3001       break;
3002
3003     case STMT_GOTO:
3004       S = new (Context) GotoStmt(Empty);
3005       break;
3006
3007     case STMT_INDIRECT_GOTO:
3008       S = new (Context) IndirectGotoStmt(Empty);
3009       break;
3010
3011     case STMT_CONTINUE:
3012       S = new (Context) ContinueStmt(Empty);
3013       break;
3014
3015     case STMT_BREAK:
3016       S = new (Context) BreakStmt(Empty);
3017       break;
3018
3019     case STMT_RETURN:
3020       S = new (Context) ReturnStmt(Empty);
3021       break;
3022
3023     case STMT_DECL:
3024       S = new (Context) DeclStmt(Empty);
3025       break;
3026
3027     case STMT_GCCASM:
3028       S = new (Context) GCCAsmStmt(Empty);
3029       break;
3030
3031     case STMT_MSASM:
3032       S = new (Context) MSAsmStmt(Empty);
3033       break;
3034
3035     case STMT_CAPTURED:
3036       S = CapturedStmt::CreateDeserialized(Context,
3037                                            Record[ASTStmtReader::NumStmtFields]);
3038       break;
3039
3040     case EXPR_PREDEFINED:
3041       S = new (Context) PredefinedExpr(Empty);
3042       break;
3043
3044     case EXPR_DECL_REF:
3045       S = DeclRefExpr::CreateEmpty(
3046         Context,
3047         /*HasQualifier=*/Record[ASTStmtReader::NumExprFields],
3048         /*HasFoundDecl=*/Record[ASTStmtReader::NumExprFields + 1],
3049         /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields + 2],
3050         /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields + 2] ?
3051           Record[ASTStmtReader::NumExprFields + 5] : 0);
3052       break;
3053
3054     case EXPR_INTEGER_LITERAL:
3055       S = IntegerLiteral::Create(Context, Empty);
3056       break;
3057
3058     case EXPR_FLOATING_LITERAL:
3059       S = FloatingLiteral::Create(Context, Empty);
3060       break;
3061
3062     case EXPR_IMAGINARY_LITERAL:
3063       S = new (Context) ImaginaryLiteral(Empty);
3064       break;
3065
3066     case EXPR_STRING_LITERAL:
3067       S = StringLiteral::CreateEmpty(Context,
3068                                      Record[ASTStmtReader::NumExprFields + 1]);
3069       break;
3070
3071     case EXPR_CHARACTER_LITERAL:
3072       S = new (Context) CharacterLiteral(Empty);
3073       break;
3074
3075     case EXPR_PAREN:
3076       S = new (Context) ParenExpr(Empty);
3077       break;
3078
3079     case EXPR_PAREN_LIST:
3080       S = new (Context) ParenListExpr(Empty);
3081       break;
3082
3083     case EXPR_UNARY_OPERATOR:
3084       S = new (Context) UnaryOperator(Empty);
3085       break;
3086
3087     case EXPR_OFFSETOF:
3088       S = OffsetOfExpr::CreateEmpty(Context,
3089                                     Record[ASTStmtReader::NumExprFields],
3090                                     Record[ASTStmtReader::NumExprFields + 1]);
3091       break;
3092
3093     case EXPR_SIZEOF_ALIGN_OF:
3094       S = new (Context) UnaryExprOrTypeTraitExpr(Empty);
3095       break;
3096
3097     case EXPR_ARRAY_SUBSCRIPT:
3098       S = new (Context) ArraySubscriptExpr(Empty);
3099       break;
3100
3101     case EXPR_OMP_ARRAY_SECTION:
3102       S = new (Context) OMPArraySectionExpr(Empty);
3103       break;
3104
3105     case EXPR_CALL:
3106       S = new (Context) CallExpr(Context, Stmt::CallExprClass, Empty);
3107       break;
3108
3109     case EXPR_MEMBER: {
3110       // We load everything here and fully initialize it at creation.
3111       // That way we can use MemberExpr::Create and don't have to duplicate its
3112       // logic with a MemberExpr::CreateEmpty.
3113
3114       assert(Record.getIdx() == 0);
3115       NestedNameSpecifierLoc QualifierLoc;
3116       if (Record.readInt()) { // HasQualifier.
3117         QualifierLoc = Record.readNestedNameSpecifierLoc();
3118       }
3119
3120       SourceLocation TemplateKWLoc;
3121       TemplateArgumentListInfo ArgInfo;
3122       bool HasTemplateKWAndArgsInfo = Record.readInt();
3123       if (HasTemplateKWAndArgsInfo) {
3124         TemplateKWLoc = Record.readSourceLocation();
3125         unsigned NumTemplateArgs = Record.readInt();
3126         ArgInfo.setLAngleLoc(Record.readSourceLocation());
3127         ArgInfo.setRAngleLoc(Record.readSourceLocation());
3128         for (unsigned i = 0; i != NumTemplateArgs; ++i)
3129           ArgInfo.addArgument(Record.readTemplateArgumentLoc());
3130       }
3131
3132       bool HadMultipleCandidates = Record.readInt();
3133
3134       NamedDecl *FoundD = Record.readDeclAs<NamedDecl>();
3135       AccessSpecifier AS = (AccessSpecifier)Record.readInt();
3136       DeclAccessPair FoundDecl = DeclAccessPair::make(FoundD, AS);
3137
3138       QualType T = Record.readType();
3139       ExprValueKind VK = static_cast<ExprValueKind>(Record.readInt());
3140       ExprObjectKind OK = static_cast<ExprObjectKind>(Record.readInt());
3141       Expr *Base = ReadSubExpr();
3142       ValueDecl *MemberD = Record.readDeclAs<ValueDecl>();
3143       SourceLocation MemberLoc = Record.readSourceLocation();
3144       DeclarationNameInfo MemberNameInfo(MemberD->getDeclName(), MemberLoc);
3145       bool IsArrow = Record.readInt();
3146       SourceLocation OperatorLoc = Record.readSourceLocation();
3147
3148       S = MemberExpr::Create(Context, Base, IsArrow, OperatorLoc, QualifierLoc,
3149                              TemplateKWLoc, MemberD, FoundDecl, MemberNameInfo,
3150                              HasTemplateKWAndArgsInfo ? &ArgInfo : nullptr, T,
3151                              VK, OK);
3152       Record.readDeclarationNameLoc(cast<MemberExpr>(S)->MemberDNLoc,
3153                                     MemberD->getDeclName());
3154       if (HadMultipleCandidates)
3155         cast<MemberExpr>(S)->setHadMultipleCandidates(true);
3156       break;
3157     }
3158
3159     case EXPR_BINARY_OPERATOR:
3160       S = new (Context) BinaryOperator(Empty);
3161       break;
3162
3163     case EXPR_COMPOUND_ASSIGN_OPERATOR:
3164       S = new (Context) CompoundAssignOperator(Empty);
3165       break;
3166
3167     case EXPR_CONDITIONAL_OPERATOR:
3168       S = new (Context) ConditionalOperator(Empty);
3169       break;
3170
3171     case EXPR_BINARY_CONDITIONAL_OPERATOR:
3172       S = new (Context) BinaryConditionalOperator(Empty);
3173       break;
3174
3175     case EXPR_IMPLICIT_CAST:
3176       S = ImplicitCastExpr::CreateEmpty(Context,
3177                        /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
3178       break;
3179
3180     case EXPR_CSTYLE_CAST:
3181       S = CStyleCastExpr::CreateEmpty(Context,
3182                        /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
3183       break;
3184
3185     case EXPR_COMPOUND_LITERAL:
3186       S = new (Context) CompoundLiteralExpr(Empty);
3187       break;
3188
3189     case EXPR_EXT_VECTOR_ELEMENT:
3190       S = new (Context) ExtVectorElementExpr(Empty);
3191       break;
3192
3193     case EXPR_INIT_LIST:
3194       S = new (Context) InitListExpr(Empty);
3195       break;
3196
3197     case EXPR_DESIGNATED_INIT:
3198       S = DesignatedInitExpr::CreateEmpty(Context,
3199                                      Record[ASTStmtReader::NumExprFields] - 1);
3200
3201       break;
3202
3203     case EXPR_DESIGNATED_INIT_UPDATE:
3204       S = new (Context) DesignatedInitUpdateExpr(Empty);
3205       break;
3206
3207     case EXPR_IMPLICIT_VALUE_INIT:
3208       S = new (Context) ImplicitValueInitExpr(Empty);
3209       break;
3210
3211     case EXPR_NO_INIT:
3212       S = new (Context) NoInitExpr(Empty);
3213       break;
3214
3215     case EXPR_ARRAY_INIT_LOOP:
3216       S = new (Context) ArrayInitLoopExpr(Empty);
3217       break;
3218
3219     case EXPR_ARRAY_INIT_INDEX:
3220       S = new (Context) ArrayInitIndexExpr(Empty);
3221       break;
3222
3223     case EXPR_VA_ARG:
3224       S = new (Context) VAArgExpr(Empty);
3225       break;
3226
3227     case EXPR_ADDR_LABEL:
3228       S = new (Context) AddrLabelExpr(Empty);
3229       break;
3230
3231     case EXPR_STMT:
3232       S = new (Context) StmtExpr(Empty);
3233       break;
3234
3235     case EXPR_CHOOSE:
3236       S = new (Context) ChooseExpr(Empty);
3237       break;
3238
3239     case EXPR_GNU_NULL:
3240       S = new (Context) GNUNullExpr(Empty);
3241       break;
3242
3243     case EXPR_SHUFFLE_VECTOR:
3244       S = new (Context) ShuffleVectorExpr(Empty);
3245       break;
3246
3247     case EXPR_CONVERT_VECTOR:
3248       S = new (Context) ConvertVectorExpr(Empty);
3249       break;
3250
3251     case EXPR_BLOCK:
3252       S = new (Context) BlockExpr(Empty);
3253       break;
3254
3255     case EXPR_GENERIC_SELECTION:
3256       S = new (Context) GenericSelectionExpr(Empty);
3257       break;
3258
3259     case EXPR_OBJC_STRING_LITERAL:
3260       S = new (Context) ObjCStringLiteral(Empty);
3261       break;
3262     case EXPR_OBJC_BOXED_EXPRESSION:
3263       S = new (Context) ObjCBoxedExpr(Empty);
3264       break;
3265     case EXPR_OBJC_ARRAY_LITERAL:
3266       S = ObjCArrayLiteral::CreateEmpty(Context,
3267                                         Record[ASTStmtReader::NumExprFields]);
3268       break;
3269     case EXPR_OBJC_DICTIONARY_LITERAL:
3270       S = ObjCDictionaryLiteral::CreateEmpty(Context,
3271             Record[ASTStmtReader::NumExprFields],
3272             Record[ASTStmtReader::NumExprFields + 1]);
3273       break;
3274     case EXPR_OBJC_ENCODE:
3275       S = new (Context) ObjCEncodeExpr(Empty);
3276       break;
3277     case EXPR_OBJC_SELECTOR_EXPR:
3278       S = new (Context) ObjCSelectorExpr(Empty);
3279       break;
3280     case EXPR_OBJC_PROTOCOL_EXPR:
3281       S = new (Context) ObjCProtocolExpr(Empty);
3282       break;
3283     case EXPR_OBJC_IVAR_REF_EXPR:
3284       S = new (Context) ObjCIvarRefExpr(Empty);
3285       break;
3286     case EXPR_OBJC_PROPERTY_REF_EXPR:
3287       S = new (Context) ObjCPropertyRefExpr(Empty);
3288       break;
3289     case EXPR_OBJC_SUBSCRIPT_REF_EXPR:
3290       S = new (Context) ObjCSubscriptRefExpr(Empty);
3291       break;
3292     case EXPR_OBJC_KVC_REF_EXPR:
3293       llvm_unreachable("mismatching AST file");
3294     case EXPR_OBJC_MESSAGE_EXPR:
3295       S = ObjCMessageExpr::CreateEmpty(Context,
3296                                      Record[ASTStmtReader::NumExprFields],
3297                                      Record[ASTStmtReader::NumExprFields + 1]);
3298       break;
3299     case EXPR_OBJC_ISA:
3300       S = new (Context) ObjCIsaExpr(Empty);
3301       break;
3302     case EXPR_OBJC_INDIRECT_COPY_RESTORE:
3303       S = new (Context) ObjCIndirectCopyRestoreExpr(Empty);
3304       break;
3305     case EXPR_OBJC_BRIDGED_CAST:
3306       S = new (Context) ObjCBridgedCastExpr(Empty);
3307       break;
3308     case STMT_OBJC_FOR_COLLECTION:
3309       S = new (Context) ObjCForCollectionStmt(Empty);
3310       break;
3311     case STMT_OBJC_CATCH:
3312       S = new (Context) ObjCAtCatchStmt(Empty);
3313       break;
3314     case STMT_OBJC_FINALLY:
3315       S = new (Context) ObjCAtFinallyStmt(Empty);
3316       break;
3317     case STMT_OBJC_AT_TRY:
3318       S = ObjCAtTryStmt::CreateEmpty(Context,
3319                                      Record[ASTStmtReader::NumStmtFields],
3320                                      Record[ASTStmtReader::NumStmtFields + 1]);
3321       break;
3322     case STMT_OBJC_AT_SYNCHRONIZED:
3323       S = new (Context) ObjCAtSynchronizedStmt(Empty);
3324       break;
3325     case STMT_OBJC_AT_THROW:
3326       S = new (Context) ObjCAtThrowStmt(Empty);
3327       break;
3328     case STMT_OBJC_AUTORELEASE_POOL:
3329       S = new (Context) ObjCAutoreleasePoolStmt(Empty);
3330       break;
3331     case EXPR_OBJC_BOOL_LITERAL:
3332       S = new (Context) ObjCBoolLiteralExpr(Empty);
3333       break;
3334     case EXPR_OBJC_AVAILABILITY_CHECK:
3335       S = new (Context) ObjCAvailabilityCheckExpr(Empty);
3336       break;
3337     case STMT_SEH_LEAVE:
3338       S = new (Context) SEHLeaveStmt(Empty);
3339       break;
3340     case STMT_SEH_EXCEPT:
3341       S = new (Context) SEHExceptStmt(Empty);
3342       break;
3343     case STMT_SEH_FINALLY:
3344       S = new (Context) SEHFinallyStmt(Empty);
3345       break;
3346     case STMT_SEH_TRY:
3347       S = new (Context) SEHTryStmt(Empty);
3348       break;
3349     case STMT_CXX_CATCH:
3350       S = new (Context) CXXCatchStmt(Empty);
3351       break;
3352
3353     case STMT_CXX_TRY:
3354       S = CXXTryStmt::Create(Context, Empty,
3355              /*NumHandlers=*/Record[ASTStmtReader::NumStmtFields]);
3356       break;
3357
3358     case STMT_CXX_FOR_RANGE:
3359       S = new (Context) CXXForRangeStmt(Empty);
3360       break;
3361
3362     case STMT_MS_DEPENDENT_EXISTS:
3363       S = new (Context) MSDependentExistsStmt(SourceLocation(), true,
3364                                               NestedNameSpecifierLoc(),
3365                                               DeclarationNameInfo(),
3366                                               nullptr);
3367       break;
3368
3369     case STMT_OMP_PARALLEL_DIRECTIVE:
3370       S =
3371         OMPParallelDirective::CreateEmpty(Context,
3372                                           Record[ASTStmtReader::NumStmtFields],
3373                                           Empty);
3374       break;
3375
3376     case STMT_OMP_SIMD_DIRECTIVE: {
3377       unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3378       unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3379       S = OMPSimdDirective::CreateEmpty(Context, NumClauses,
3380                                         CollapsedNum, Empty);
3381       break;
3382     }
3383
3384     case STMT_OMP_FOR_DIRECTIVE: {
3385       unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3386       unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3387       S = OMPForDirective::CreateEmpty(Context, NumClauses, CollapsedNum,
3388                                        Empty);
3389       break;
3390     }
3391
3392     case STMT_OMP_FOR_SIMD_DIRECTIVE: {
3393       unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3394       unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3395       S = OMPForSimdDirective::CreateEmpty(Context, NumClauses, CollapsedNum,
3396                                            Empty);
3397       break;
3398     }
3399
3400     case STMT_OMP_SECTIONS_DIRECTIVE:
3401       S = OMPSectionsDirective::CreateEmpty(
3402           Context, Record[ASTStmtReader::NumStmtFields], Empty);
3403       break;
3404
3405     case STMT_OMP_SECTION_DIRECTIVE:
3406       S = OMPSectionDirective::CreateEmpty(Context, Empty);
3407       break;
3408
3409     case STMT_OMP_SINGLE_DIRECTIVE:
3410       S = OMPSingleDirective::CreateEmpty(
3411           Context, Record[ASTStmtReader::NumStmtFields], Empty);
3412       break;
3413
3414     case STMT_OMP_MASTER_DIRECTIVE:
3415       S = OMPMasterDirective::CreateEmpty(Context, Empty);
3416       break;
3417
3418     case STMT_OMP_CRITICAL_DIRECTIVE:
3419       S = OMPCriticalDirective::CreateEmpty(
3420           Context, Record[ASTStmtReader::NumStmtFields], Empty);
3421       break;
3422
3423     case STMT_OMP_PARALLEL_FOR_DIRECTIVE: {
3424       unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3425       unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3426       S = OMPParallelForDirective::CreateEmpty(Context, NumClauses,
3427                                                CollapsedNum, Empty);
3428       break;
3429     }
3430
3431     case STMT_OMP_PARALLEL_FOR_SIMD_DIRECTIVE: {
3432       unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3433       unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3434       S = OMPParallelForSimdDirective::CreateEmpty(Context, NumClauses,
3435                                                    CollapsedNum, Empty);
3436       break;
3437     }
3438
3439     case STMT_OMP_PARALLEL_SECTIONS_DIRECTIVE:
3440       S = OMPParallelSectionsDirective::CreateEmpty(
3441           Context, Record[ASTStmtReader::NumStmtFields], Empty);
3442       break;
3443
3444     case STMT_OMP_TASK_DIRECTIVE:
3445       S = OMPTaskDirective::CreateEmpty(
3446           Context, Record[ASTStmtReader::NumStmtFields], Empty);
3447       break;
3448
3449     case STMT_OMP_TASKYIELD_DIRECTIVE:
3450       S = OMPTaskyieldDirective::CreateEmpty(Context, Empty);
3451       break;
3452
3453     case STMT_OMP_BARRIER_DIRECTIVE:
3454       S = OMPBarrierDirective::CreateEmpty(Context, Empty);
3455       break;
3456
3457     case STMT_OMP_TASKWAIT_DIRECTIVE:
3458       S = OMPTaskwaitDirective::CreateEmpty(Context, Empty);
3459       break;
3460
3461     case STMT_OMP_TASKGROUP_DIRECTIVE:
3462       S = OMPTaskgroupDirective::CreateEmpty(Context, Empty);
3463       break;
3464
3465     case STMT_OMP_FLUSH_DIRECTIVE:
3466       S = OMPFlushDirective::CreateEmpty(
3467           Context, Record[ASTStmtReader::NumStmtFields], Empty);
3468       break;
3469
3470     case STMT_OMP_ORDERED_DIRECTIVE:
3471       S = OMPOrderedDirective::CreateEmpty(
3472           Context, Record[ASTStmtReader::NumStmtFields], Empty);
3473       break;
3474
3475     case STMT_OMP_ATOMIC_DIRECTIVE:
3476       S = OMPAtomicDirective::CreateEmpty(
3477           Context, Record[ASTStmtReader::NumStmtFields], Empty);
3478       break;
3479
3480     case STMT_OMP_TARGET_DIRECTIVE:
3481       S = OMPTargetDirective::CreateEmpty(
3482           Context, Record[ASTStmtReader::NumStmtFields], Empty);
3483       break;
3484
3485     case STMT_OMP_TARGET_DATA_DIRECTIVE:
3486       S = OMPTargetDataDirective::CreateEmpty(
3487           Context, Record[ASTStmtReader::NumStmtFields], Empty);
3488       break;
3489
3490     case STMT_OMP_TARGET_ENTER_DATA_DIRECTIVE:
3491       S = OMPTargetEnterDataDirective::CreateEmpty(
3492           Context, Record[ASTStmtReader::NumStmtFields], Empty);
3493       break;
3494
3495     case STMT_OMP_TARGET_EXIT_DATA_DIRECTIVE:
3496       S = OMPTargetExitDataDirective::CreateEmpty(
3497           Context, Record[ASTStmtReader::NumStmtFields], Empty);
3498       break;
3499
3500     case STMT_OMP_TARGET_PARALLEL_DIRECTIVE:
3501       S = OMPTargetParallelDirective::CreateEmpty(
3502           Context, Record[ASTStmtReader::NumStmtFields], Empty);
3503       break;
3504
3505     case STMT_OMP_TARGET_PARALLEL_FOR_DIRECTIVE: {
3506       unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3507       unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3508       S = OMPTargetParallelForDirective::CreateEmpty(Context, NumClauses,
3509                                                      CollapsedNum, Empty);
3510       break;
3511     }
3512
3513     case STMT_OMP_TARGET_UPDATE_DIRECTIVE:
3514       S = OMPTargetUpdateDirective::CreateEmpty(
3515           Context, Record[ASTStmtReader::NumStmtFields], Empty);
3516       break;
3517
3518     case STMT_OMP_TEAMS_DIRECTIVE:
3519       S = OMPTeamsDirective::CreateEmpty(
3520           Context, Record[ASTStmtReader::NumStmtFields], Empty);
3521       break;
3522
3523     case STMT_OMP_CANCELLATION_POINT_DIRECTIVE:
3524       S = OMPCancellationPointDirective::CreateEmpty(Context, Empty);
3525       break;
3526
3527     case STMT_OMP_CANCEL_DIRECTIVE:
3528       S = OMPCancelDirective::CreateEmpty(
3529           Context, Record[ASTStmtReader::NumStmtFields], Empty);
3530       break;
3531
3532     case STMT_OMP_TASKLOOP_DIRECTIVE: {
3533       unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3534       unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3535       S = OMPTaskLoopDirective::CreateEmpty(Context, NumClauses, CollapsedNum,
3536                                             Empty);
3537       break;
3538     }
3539
3540     case STMT_OMP_TASKLOOP_SIMD_DIRECTIVE: {
3541       unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3542       unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3543       S = OMPTaskLoopSimdDirective::CreateEmpty(Context, NumClauses,
3544                                                 CollapsedNum, Empty);
3545       break;
3546     }
3547
3548     case STMT_OMP_DISTRIBUTE_DIRECTIVE: {
3549       unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3550       unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3551       S = OMPDistributeDirective::CreateEmpty(Context, NumClauses, CollapsedNum,
3552                                               Empty);
3553       break;
3554     }
3555
3556     case STMT_OMP_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE: {
3557       unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3558       unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3559       S = OMPDistributeParallelForDirective::CreateEmpty(Context, NumClauses,
3560                                                          CollapsedNum, Empty);
3561       break;
3562     }
3563
3564     case STMT_OMP_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE: {
3565       unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3566       unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3567       S = OMPDistributeParallelForSimdDirective::CreateEmpty(Context, NumClauses,
3568                                                              CollapsedNum,
3569                                                              Empty);
3570       break;
3571     }
3572
3573     case STMT_OMP_DISTRIBUTE_SIMD_DIRECTIVE: {
3574       unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3575       unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3576       S = OMPDistributeSimdDirective::CreateEmpty(Context, NumClauses,
3577                                                   CollapsedNum, Empty);
3578       break;
3579     }
3580
3581     case STMT_OMP_TARGET_PARALLEL_FOR_SIMD_DIRECTIVE: {
3582       unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3583       unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3584       S = OMPTargetParallelForSimdDirective::CreateEmpty(Context, NumClauses,
3585                                                          CollapsedNum, Empty);
3586       break;
3587     }
3588
3589     case STMT_OMP_TARGET_SIMD_DIRECTIVE: {
3590       auto NumClauses = Record[ASTStmtReader::NumStmtFields];
3591       auto CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3592       S = OMPTargetSimdDirective::CreateEmpty(Context, NumClauses, CollapsedNum,
3593                                               Empty);
3594       break;
3595     }
3596
3597      case STMT_OMP_TEAMS_DISTRIBUTE_DIRECTIVE: {
3598       auto NumClauses = Record[ASTStmtReader::NumStmtFields];
3599       auto CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3600       S = OMPTeamsDistributeDirective::CreateEmpty(Context, NumClauses,
3601                                                    CollapsedNum, Empty);
3602       break;
3603     }
3604
3605     case STMT_OMP_TEAMS_DISTRIBUTE_SIMD_DIRECTIVE: {
3606       unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3607       unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3608       S = OMPTeamsDistributeSimdDirective::CreateEmpty(Context, NumClauses,
3609                                                        CollapsedNum, Empty);
3610       break;
3611     }
3612
3613     case STMT_OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE: {
3614       auto NumClauses = Record[ASTStmtReader::NumStmtFields];
3615       auto CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3616       S = OMPTeamsDistributeParallelForSimdDirective::CreateEmpty(
3617           Context, NumClauses, CollapsedNum, Empty);
3618       break;
3619     }
3620
3621     case STMT_OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE: {
3622       auto NumClauses = Record[ASTStmtReader::NumStmtFields];
3623       auto CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3624       S = OMPTeamsDistributeParallelForDirective::CreateEmpty(
3625           Context, NumClauses, CollapsedNum, Empty);
3626       break;
3627     }
3628
3629     case STMT_OMP_TARGET_TEAMS_DIRECTIVE: {
3630       S = OMPTargetTeamsDirective::CreateEmpty(
3631           Context, Record[ASTStmtReader::NumStmtFields], Empty);
3632       break;
3633     }
3634
3635     case STMT_OMP_TARGET_TEAMS_DISTRIBUTE_DIRECTIVE: {
3636       auto NumClauses = Record[ASTStmtReader::NumStmtFields];
3637       auto CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3638       S = OMPTargetTeamsDistributeDirective::CreateEmpty(Context, NumClauses,
3639                                                          CollapsedNum, Empty);
3640       break;
3641     }
3642
3643     case STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE: {
3644       auto NumClauses = Record[ASTStmtReader::NumStmtFields];
3645       auto CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3646       S = OMPTargetTeamsDistributeParallelForDirective::CreateEmpty(
3647           Context, NumClauses, CollapsedNum, Empty);
3648       break;
3649     }
3650
3651     case STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE: {
3652       auto NumClauses = Record[ASTStmtReader::NumStmtFields];
3653       auto CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3654       S = OMPTargetTeamsDistributeParallelForSimdDirective::CreateEmpty(
3655           Context, NumClauses, CollapsedNum, Empty);
3656       break;
3657     }
3658
3659     case STMT_OMP_TARGET_TEAMS_DISTRIBUTE_SIMD_DIRECTIVE: {
3660       auto NumClauses = Record[ASTStmtReader::NumStmtFields];
3661       auto CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3662       S = OMPTargetTeamsDistributeSimdDirective::CreateEmpty(
3663           Context, NumClauses, CollapsedNum, Empty);
3664       break;
3665     }
3666
3667     case EXPR_CXX_OPERATOR_CALL:
3668       S = new (Context) CXXOperatorCallExpr(Context, Empty);
3669       break;
3670
3671     case EXPR_CXX_MEMBER_CALL:
3672       S = new (Context) CXXMemberCallExpr(Context, Empty);
3673       break;
3674
3675     case EXPR_CXX_CONSTRUCT:
3676       S = new (Context) CXXConstructExpr(Empty);
3677       break;
3678
3679     case EXPR_CXX_INHERITED_CTOR_INIT:
3680       S = new (Context) CXXInheritedCtorInitExpr(Empty);
3681       break;
3682
3683     case EXPR_CXX_TEMPORARY_OBJECT:
3684       S = new (Context) CXXTemporaryObjectExpr(Empty);
3685       break;
3686
3687     case EXPR_CXX_STATIC_CAST:
3688       S = CXXStaticCastExpr::CreateEmpty(Context,
3689                        /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
3690       break;
3691
3692     case EXPR_CXX_DYNAMIC_CAST:
3693       S = CXXDynamicCastExpr::CreateEmpty(Context,
3694                        /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
3695       break;
3696
3697     case EXPR_CXX_REINTERPRET_CAST:
3698       S = CXXReinterpretCastExpr::CreateEmpty(Context,
3699                        /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
3700       break;
3701
3702     case EXPR_CXX_CONST_CAST:
3703       S = CXXConstCastExpr::CreateEmpty(Context);
3704       break;
3705
3706     case EXPR_CXX_FUNCTIONAL_CAST:
3707       S = CXXFunctionalCastExpr::CreateEmpty(Context,
3708                        /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
3709       break;
3710
3711     case EXPR_USER_DEFINED_LITERAL:
3712       S = new (Context) UserDefinedLiteral(Context, Empty);
3713       break;
3714
3715     case EXPR_CXX_STD_INITIALIZER_LIST:
3716       S = new (Context) CXXStdInitializerListExpr(Empty);
3717       break;
3718
3719     case EXPR_CXX_BOOL_LITERAL:
3720       S = new (Context) CXXBoolLiteralExpr(Empty);
3721       break;
3722
3723     case EXPR_CXX_NULL_PTR_LITERAL:
3724       S = new (Context) CXXNullPtrLiteralExpr(Empty);
3725       break;
3726     case EXPR_CXX_TYPEID_EXPR:
3727       S = new (Context) CXXTypeidExpr(Empty, true);
3728       break;
3729     case EXPR_CXX_TYPEID_TYPE:
3730       S = new (Context) CXXTypeidExpr(Empty, false);
3731       break;
3732     case EXPR_CXX_UUIDOF_EXPR:
3733       S = new (Context) CXXUuidofExpr(Empty, true);
3734       break;
3735     case EXPR_CXX_PROPERTY_REF_EXPR:
3736       S = new (Context) MSPropertyRefExpr(Empty);
3737       break;
3738     case EXPR_CXX_PROPERTY_SUBSCRIPT_EXPR:
3739       S = new (Context) MSPropertySubscriptExpr(Empty);
3740       break;
3741     case EXPR_CXX_UUIDOF_TYPE:
3742       S = new (Context) CXXUuidofExpr(Empty, false);
3743       break;
3744     case EXPR_CXX_THIS:
3745       S = new (Context) CXXThisExpr(Empty);
3746       break;
3747     case EXPR_CXX_THROW:
3748       S = new (Context) CXXThrowExpr(Empty);
3749       break;
3750     case EXPR_CXX_DEFAULT_ARG:
3751       S = new (Context) CXXDefaultArgExpr(Empty);
3752       break;
3753     case EXPR_CXX_DEFAULT_INIT:
3754       S = new (Context) CXXDefaultInitExpr(Empty);
3755       break;
3756     case EXPR_CXX_BIND_TEMPORARY:
3757       S = new (Context) CXXBindTemporaryExpr(Empty);
3758       break;
3759
3760     case EXPR_CXX_SCALAR_VALUE_INIT:
3761       S = new (Context) CXXScalarValueInitExpr(Empty);
3762       break;
3763     case EXPR_CXX_NEW:
3764       S = new (Context) CXXNewExpr(Empty);
3765       break;
3766     case EXPR_CXX_DELETE:
3767       S = new (Context) CXXDeleteExpr(Empty);
3768       break;
3769     case EXPR_CXX_PSEUDO_DESTRUCTOR:
3770       S = new (Context) CXXPseudoDestructorExpr(Empty);
3771       break;
3772
3773     case EXPR_EXPR_WITH_CLEANUPS:
3774       S = ExprWithCleanups::Create(Context, Empty,
3775                                    Record[ASTStmtReader::NumExprFields]);
3776       break;
3777
3778     case EXPR_CXX_DEPENDENT_SCOPE_MEMBER:
3779       S = CXXDependentScopeMemberExpr::CreateEmpty(Context,
3780          /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields],
3781                   /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]
3782                                    ? Record[ASTStmtReader::NumExprFields + 1]
3783                                    : 0);
3784       break;
3785
3786     case EXPR_CXX_DEPENDENT_SCOPE_DECL_REF:
3787       S = DependentScopeDeclRefExpr::CreateEmpty(Context,
3788          /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields],
3789                   /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]
3790                                    ? Record[ASTStmtReader::NumExprFields + 1]
3791                                    : 0);
3792       break;
3793
3794     case EXPR_CXX_UNRESOLVED_CONSTRUCT:
3795       S = CXXUnresolvedConstructExpr::CreateEmpty(Context,
3796                               /*NumArgs=*/Record[ASTStmtReader::NumExprFields]);
3797       break;
3798
3799     case EXPR_CXX_UNRESOLVED_MEMBER:
3800       S = UnresolvedMemberExpr::CreateEmpty(Context,
3801          /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields],
3802                   /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]
3803                                    ? Record[ASTStmtReader::NumExprFields + 1]
3804                                    : 0);
3805       break;
3806
3807     case EXPR_CXX_UNRESOLVED_LOOKUP:
3808       S = UnresolvedLookupExpr::CreateEmpty(Context,
3809          /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields],
3810                   /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]
3811                                    ? Record[ASTStmtReader::NumExprFields + 1]
3812                                    : 0);
3813       break;
3814
3815     case EXPR_TYPE_TRAIT:
3816       S = TypeTraitExpr::CreateDeserialized(Context,
3817             Record[ASTStmtReader::NumExprFields]);
3818       break;
3819
3820     case EXPR_ARRAY_TYPE_TRAIT:
3821       S = new (Context) ArrayTypeTraitExpr(Empty);
3822       break;
3823
3824     case EXPR_CXX_EXPRESSION_TRAIT:
3825       S = new (Context) ExpressionTraitExpr(Empty);
3826       break;
3827
3828     case EXPR_CXX_NOEXCEPT:
3829       S = new (Context) CXXNoexceptExpr(Empty);
3830       break;
3831
3832     case EXPR_PACK_EXPANSION:
3833       S = new (Context) PackExpansionExpr(Empty);
3834       break;
3835
3836     case EXPR_SIZEOF_PACK:
3837       S = SizeOfPackExpr::CreateDeserialized(
3838               Context,
3839               /*NumPartialArgs=*/Record[ASTStmtReader::NumExprFields]);
3840       break;
3841
3842     case EXPR_SUBST_NON_TYPE_TEMPLATE_PARM:
3843       S = new (Context) SubstNonTypeTemplateParmExpr(Empty);
3844       break;
3845
3846     case EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK:
3847       S = new (Context) SubstNonTypeTemplateParmPackExpr(Empty);
3848       break;
3849
3850     case EXPR_FUNCTION_PARM_PACK:
3851       S = FunctionParmPackExpr::CreateEmpty(Context,
3852                                           Record[ASTStmtReader::NumExprFields]);
3853       break;
3854
3855     case EXPR_MATERIALIZE_TEMPORARY:
3856       S = new (Context) MaterializeTemporaryExpr(Empty);
3857       break;
3858
3859     case EXPR_CXX_FOLD:
3860       S = new (Context) CXXFoldExpr(Empty);
3861       break;
3862
3863     case EXPR_OPAQUE_VALUE:
3864       S = new (Context) OpaqueValueExpr(Empty);
3865       break;
3866
3867     case EXPR_CUDA_KERNEL_CALL:
3868       S = new (Context) CUDAKernelCallExpr(Context, Empty);
3869       break;
3870
3871     case EXPR_ASTYPE:
3872       S = new (Context) AsTypeExpr(Empty);
3873       break;
3874
3875     case EXPR_PSEUDO_OBJECT: {
3876       unsigned numSemanticExprs = Record[ASTStmtReader::NumExprFields];
3877       S = PseudoObjectExpr::Create(Context, Empty, numSemanticExprs);
3878       break;
3879     }
3880
3881     case EXPR_ATOMIC:
3882       S = new (Context) AtomicExpr(Empty);
3883       break;
3884
3885     case EXPR_LAMBDA: {
3886       unsigned NumCaptures = Record[ASTStmtReader::NumExprFields];
3887       S = LambdaExpr::CreateDeserialized(Context, NumCaptures);
3888       break;
3889     }
3890     }
3891
3892     // We hit a STMT_STOP, so we're done with this expression.
3893     if (Finished)
3894       break;
3895
3896     ++NumStatementsRead;
3897
3898     if (S && !IsStmtReference) {
3899       Reader.Visit(S);
3900       StmtEntries[Cursor.GetCurrentBitNo()] = S;
3901     }
3902
3903     assert(Record.getIdx() == Record.size() &&
3904            "Invalid deserialization of statement");
3905     StmtStack.push_back(S);
3906   }
3907 Done:
3908   assert(StmtStack.size() > PrevNumStmts && "Read too many sub-stmts!");
3909   assert(StmtStack.size() == PrevNumStmts + 1 && "Extra expressions on stack!");
3910   return StmtStack.pop_back_val();
3911 }