lib/Serialization/ASTReaderStmt.cpp

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