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