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

   1 //===--- ASTReaderStmt.cpp - Stmt/Expr Deserialization ----------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // Statement/expression deserialization.  This implements the
  11 // ASTReader::ReadStmt method.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "clang/Serialization/ASTReader.h"
  16 #include "clang/AST/ASTContext.h"
  17 #include "clang/AST/DeclCXX.h"
  18 #include "clang/AST/DeclTemplate.h"
  19 #include "clang/AST/StmtVisitor.h"
  20 #include "clang/Lex/Token.h"
  21 #include "llvm/ADT/SmallString.h"
  22 using namespace clang;
  23 using namespace clang::serialization;
  24
  25 namespace clang {
  26
  27   class ASTStmtReader : public StmtVisitor<ASTStmtReader> {
  28     typedef ASTReader::RecordData RecordData;
  29
  30     ASTReader &Reader;
  31     ModuleFile &F;
  32     llvm::BitstreamCursor &DeclsCursor;
  33     const ASTReader::RecordData &Record;
  34     unsigned &Idx;
  35
  36     Token ReadToken(const RecordData &R, unsigned &I) {
  37       return Reader.ReadToken(F, R, I);
  38     }
  39
  40     SourceLocation ReadSourceLocation(const RecordData &R, unsigned &I) {
  41       return Reader.ReadSourceLocation(F, R, I);
  42     }
  43
  44     SourceRange ReadSourceRange(const RecordData &R, unsigned &I) {
  45       return Reader.ReadSourceRange(F, R, I);
  46     }
  47
  48     std::string ReadString(const RecordData &R, unsigned &I) {
  49       return Reader.ReadString(R, I);
  50     }
  51
  52     TypeSourceInfo *GetTypeSourceInfo(const RecordData &R, unsigned &I) {
  53       return Reader.GetTypeSourceInfo(F, R, I);
  54     }
  55
  56     serialization::DeclID ReadDeclID(const RecordData &R, unsigned &I) {
  57       return Reader.ReadDeclID(F, R, I);
  58     }
  59
  60     Decl *ReadDecl(const RecordData &R, unsigned &I) {
  61       return Reader.ReadDecl(F, R, I);
  62     }
  63
  64     template<typename T>
  65     T *ReadDeclAs(const RecordData &R, unsigned &I) {
  66       return Reader.ReadDeclAs<T>(F, R, I);
  67     }
  68
  69     void ReadDeclarationNameLoc(DeclarationNameLoc &DNLoc, DeclarationName Name,
  70                                 const ASTReader::RecordData &R, unsigned &I) {
  71       Reader.ReadDeclarationNameLoc(F, DNLoc, Name, R, I);
  72     }
  73
  74     void ReadDeclarationNameInfo(DeclarationNameInfo &NameInfo,
  75                                 const ASTReader::RecordData &R, unsigned &I) {
  76       Reader.ReadDeclarationNameInfo(F, NameInfo, R, I);
  77     }
  78
  79   public:
  80     ASTStmtReader(ASTReader &Reader, ModuleFile &F,
  81                   llvm::BitstreamCursor &Cursor,
  82                   const ASTReader::RecordData &Record, unsigned &Idx)
  83       : Reader(Reader), F(F), DeclsCursor(Cursor), Record(Record), Idx(Idx) { }
  84
  85     /// \brief The number of record fields required for the Stmt class
  86     /// itself.
  87     static const unsigned NumStmtFields = 0;
  88
  89     /// \brief The number of record fields required for the Expr class
  90     /// itself.
  91     static const unsigned NumExprFields = NumStmtFields + 7;
  92
  93     /// \brief Read and initialize a ExplicitTemplateArgumentList structure.
  94     void ReadTemplateKWAndArgsInfo(ASTTemplateKWAndArgsInfo &Args,
  95                                    unsigned NumTemplateArgs);
  96     /// \brief Read and initialize a ExplicitTemplateArgumentList structure.
  97     void ReadExplicitTemplateArgumentList(ASTTemplateArgumentListInfo &ArgList,
  98                                           unsigned NumTemplateArgs);
  99
 100     void VisitStmt(Stmt *S);
 101 #define STMT(Type, Base) \
 102     void Visit##Type(Type *);
 103 #include "clang/AST/StmtNodes.inc"
 104   };
 105 }
 106
 107 void ASTStmtReader::
 108 ReadTemplateKWAndArgsInfo(ASTTemplateKWAndArgsInfo &Args,
 109                           unsigned NumTemplateArgs) {
 110   SourceLocation TemplateKWLoc = ReadSourceLocation(Record, Idx);
 111   TemplateArgumentListInfo ArgInfo;
 112   ArgInfo.setLAngleLoc(ReadSourceLocation(Record, Idx));
 113   ArgInfo.setRAngleLoc(ReadSourceLocation(Record, Idx));
 114   for (unsigned i = 0; i != NumTemplateArgs; ++i)
 115     ArgInfo.addArgument(
 116         Reader.ReadTemplateArgumentLoc(F, Record, Idx));
 117   Args.initializeFrom(TemplateKWLoc, ArgInfo);
 118 }
 119
 120 void ASTStmtReader::VisitStmt(Stmt *S) {
 121   assert(Idx == NumStmtFields && "Incorrect statement field count");
 122 }
 123
 124 void ASTStmtReader::VisitNullStmt(NullStmt *S) {
 125   VisitStmt(S);
 126   S->setSemiLoc(ReadSourceLocation(Record, Idx));
 127   S->HasLeadingEmptyMacro = Record[Idx++];
 128 }
 129
 130 void ASTStmtReader::VisitCompoundStmt(CompoundStmt *S) {
 131   VisitStmt(S);
 132   SmallVector<Stmt *, 16> Stmts;
 133   unsigned NumStmts = Record[Idx++];
 134   while (NumStmts--)
 135     Stmts.push_back(Reader.ReadSubStmt());
 136   S->setStmts(Reader.getContext(), Stmts.data(), Stmts.size());
 137   S->setLBracLoc(ReadSourceLocation(Record, Idx));
 138   S->setRBracLoc(ReadSourceLocation(Record, Idx));
 139 }
 140
 141 void ASTStmtReader::VisitSwitchCase(SwitchCase *S) {
 142   VisitStmt(S);
 143   Reader.RecordSwitchCaseID(S, Record[Idx++]);
 144   S->setKeywordLoc(ReadSourceLocation(Record, Idx));
 145   S->setColonLoc(ReadSourceLocation(Record, Idx));
 146 }
 147
 148 void ASTStmtReader::VisitCaseStmt(CaseStmt *S) {
 149   VisitSwitchCase(S);
 150   S->setLHS(Reader.ReadSubExpr());
 151   S->setRHS(Reader.ReadSubExpr());
 152   S->setSubStmt(Reader.ReadSubStmt());
 153   S->setEllipsisLoc(ReadSourceLocation(Record, Idx));
 154 }
 155
 156 void ASTStmtReader::VisitDefaultStmt(DefaultStmt *S) {
 157   VisitSwitchCase(S);
 158   S->setSubStmt(Reader.ReadSubStmt());
 159 }
 160
 161 void ASTStmtReader::VisitLabelStmt(LabelStmt *S) {
 162   VisitStmt(S);
 163   LabelDecl *LD = ReadDeclAs<LabelDecl>(Record, Idx);
 164   LD->setStmt(S);
 165   S->setDecl(LD);
 166   S->setSubStmt(Reader.ReadSubStmt());
 167   S->setIdentLoc(ReadSourceLocation(Record, Idx));
 168 }
 169
 170 void ASTStmtReader::VisitAttributedStmt(AttributedStmt *S) {
 171   VisitStmt(S);
 172   uint64_t NumAttrs = Record[Idx++];
 173   AttrVec Attrs;
 174   Reader.ReadAttributes(F, Attrs, Record, Idx);
 175   (void)NumAttrs;
 176   assert(NumAttrs == S->NumAttrs);
 177   assert(NumAttrs == Attrs.size());
 178   std::copy(Attrs.begin(), Attrs.end(), S->Attrs);
 179   S->SubStmt = Reader.ReadSubStmt();
 180   S->AttrLoc = ReadSourceLocation(Record, Idx);
 181 }
 182
 183 void ASTStmtReader::VisitIfStmt(IfStmt *S) {
 184   VisitStmt(S);
 185   S->setConditionVariable(Reader.getContext(),
 186                           ReadDeclAs<VarDecl>(Record, Idx));
 187   S->setCond(Reader.ReadSubExpr());
 188   S->setThen(Reader.ReadSubStmt());
 189   S->setElse(Reader.ReadSubStmt());
 190   S->setIfLoc(ReadSourceLocation(Record, Idx));
 191   S->setElseLoc(ReadSourceLocation(Record, Idx));
 192 }
 193
 194 void ASTStmtReader::VisitSwitchStmt(SwitchStmt *S) {
 195   VisitStmt(S);
 196   S->setConditionVariable(Reader.getContext(),
 197                           ReadDeclAs<VarDecl>(Record, Idx));
 198   S->setCond(Reader.ReadSubExpr());
 199   S->setBody(Reader.ReadSubStmt());
 200   S->setSwitchLoc(ReadSourceLocation(Record, Idx));
 201   if (Record[Idx++])
 202     S->setAllEnumCasesCovered();
 203
 204   SwitchCase *PrevSC = 0;
 205   for (unsigned N = Record.size(); Idx != N; ++Idx) {
 206     SwitchCase *SC = Reader.getSwitchCaseWithID(Record[Idx]);
 207     if (PrevSC)
 208       PrevSC->setNextSwitchCase(SC);
 209     else
 210       S->setSwitchCaseList(SC);
 211
 212     PrevSC = SC;
 213   }
 214 }
 215
 216 void ASTStmtReader::VisitWhileStmt(WhileStmt *S) {
 217   VisitStmt(S);
 218   S->setConditionVariable(Reader.getContext(),
 219                           ReadDeclAs<VarDecl>(Record, Idx));
 220
 221   S->setCond(Reader.ReadSubExpr());
 222   S->setBody(Reader.ReadSubStmt());
 223   S->setWhileLoc(ReadSourceLocation(Record, Idx));
 224 }
 225
 226 void ASTStmtReader::VisitDoStmt(DoStmt *S) {
 227   VisitStmt(S);
 228   S->setCond(Reader.ReadSubExpr());
 229   S->setBody(Reader.ReadSubStmt());
 230   S->setDoLoc(ReadSourceLocation(Record, Idx));
 231   S->setWhileLoc(ReadSourceLocation(Record, Idx));
 232   S->setRParenLoc(ReadSourceLocation(Record, Idx));
 233 }
 234
 235 void ASTStmtReader::VisitForStmt(ForStmt *S) {
 236   VisitStmt(S);
 237   S->setInit(Reader.ReadSubStmt());
 238   S->setCond(Reader.ReadSubExpr());
 239   S->setConditionVariable(Reader.getContext(),
 240                           ReadDeclAs<VarDecl>(Record, Idx));
 241   S->setInc(Reader.ReadSubExpr());
 242   S->setBody(Reader.ReadSubStmt());
 243   S->setForLoc(ReadSourceLocation(Record, Idx));
 244   S->setLParenLoc(ReadSourceLocation(Record, Idx));
 245   S->setRParenLoc(ReadSourceLocation(Record, Idx));
 246 }
 247
 248 void ASTStmtReader::VisitGotoStmt(GotoStmt *S) {
 249   VisitStmt(S);
 250   S->setLabel(ReadDeclAs<LabelDecl>(Record, Idx));
 251   S->setGotoLoc(ReadSourceLocation(Record, Idx));
 252   S->setLabelLoc(ReadSourceLocation(Record, Idx));
 253 }
 254
 255 void ASTStmtReader::VisitIndirectGotoStmt(IndirectGotoStmt *S) {
 256   VisitStmt(S);
 257   S->setGotoLoc(ReadSourceLocation(Record, Idx));
 258   S->setStarLoc(ReadSourceLocation(Record, Idx));
 259   S->setTarget(Reader.ReadSubExpr());
 260 }
 261
 262 void ASTStmtReader::VisitContinueStmt(ContinueStmt *S) {
 263   VisitStmt(S);
 264   S->setContinueLoc(ReadSourceLocation(Record, Idx));
 265 }
 266
 267 void ASTStmtReader::VisitBreakStmt(BreakStmt *S) {
 268   VisitStmt(S);
 269   S->setBreakLoc(ReadSourceLocation(Record, Idx));
 270 }
 271
 272 void ASTStmtReader::VisitReturnStmt(ReturnStmt *S) {
 273   VisitStmt(S);
 274   S->setRetValue(Reader.ReadSubExpr());
 275   S->setReturnLoc(ReadSourceLocation(Record, Idx));
 276   S->setNRVOCandidate(ReadDeclAs<VarDecl>(Record, Idx));
 277 }
 278
 279 void ASTStmtReader::VisitDeclStmt(DeclStmt *S) {
 280   VisitStmt(S);
 281   S->setStartLoc(ReadSourceLocation(Record, Idx));
 282   S->setEndLoc(ReadSourceLocation(Record, Idx));
 283
 284   if (Idx + 1 == Record.size()) {
 285     // Single declaration
 286     S->setDeclGroup(DeclGroupRef(ReadDecl(Record, Idx)));
 287   } else {
 288     SmallVector<Decl *, 16> Decls;
 289     Decls.reserve(Record.size() - Idx);
 290     for (unsigned N = Record.size(); Idx != N; )
 291       Decls.push_back(ReadDecl(Record, Idx));
 292     S->setDeclGroup(DeclGroupRef(DeclGroup::Create(Reader.getContext(),
 293                                                    Decls.data(),
 294                                                    Decls.size())));
 295   }
 296 }
 297
 298 void ASTStmtReader::VisitAsmStmt(AsmStmt *S) {
 299   VisitStmt(S);
 300   S->NumOutputs = Record[Idx++];
 301   S->NumInputs = Record[Idx++];
 302   S->NumClobbers = Record[Idx++];
 303   S->setAsmLoc(ReadSourceLocation(Record, Idx));
 304   S->setVolatile(Record[Idx++]);
 305   S->setSimple(Record[Idx++]);
 306 }
 307
 308 void ASTStmtReader::VisitGCCAsmStmt(GCCAsmStmt *S) {
 309   VisitAsmStmt(S);
 310   S->setRParenLoc(ReadSourceLocation(Record, Idx));
 311   S->setAsmString(cast_or_null<StringLiteral>(Reader.ReadSubStmt()));
 312
 313   unsigned NumOutputs = S->getNumOutputs();
 314   unsigned NumInputs = S->getNumInputs();
 315   unsigned NumClobbers = S->getNumClobbers();
 316
 317   // Outputs and inputs
 318   SmallVector<IdentifierInfo *, 16> Names;
 319   SmallVector<StringLiteral*, 16> Constraints;
 320   SmallVector<Stmt*, 16> Exprs;
 321   for (unsigned I = 0, N = NumOutputs + NumInputs; I != N; ++I) {
 322     Names.push_back(Reader.GetIdentifierInfo(F, Record, Idx));
 323     Constraints.push_back(cast_or_null<StringLiteral>(Reader.ReadSubStmt()));
 324     Exprs.push_back(Reader.ReadSubStmt());
 325   }
 326
 327   // Constraints
 328   SmallVector<StringLiteral*, 16> Clobbers;
 329   for (unsigned I = 0; I != NumClobbers; ++I)
 330     Clobbers.push_back(cast_or_null<StringLiteral>(Reader.ReadSubStmt()));
 331
 332   S->setOutputsAndInputsAndClobbers(Reader.getContext(),
 333                                     Names.data(), Constraints.data(),
 334                                     Exprs.data(), NumOutputs, NumInputs,
 335                                     Clobbers.data(), NumClobbers);
 336 }
 337
 338 void ASTStmtReader::VisitMSAsmStmt(MSAsmStmt *S) {
 339   VisitAsmStmt(S);
 340   S->LBraceLoc = ReadSourceLocation(Record, Idx);
 341   S->EndLoc = ReadSourceLocation(Record, Idx);
 342   S->NumAsmToks = Record[Idx++];
 343   std::string AsmStr = ReadString(Record, Idx);
 344
 345   // Read the tokens.
 346   SmallVector<Token, 16> AsmToks;
 347   AsmToks.reserve(S->NumAsmToks);
 348   for (unsigned i = 0, e = S->NumAsmToks; i != e; ++i) {
 349     AsmToks.push_back(ReadToken(Record, Idx));
 350   }
 351
 352   // The calls to reserve() for the FooData vectors are mandatory to
 353   // prevent dead StringRefs in the Foo vectors.
 354
 355   // Read the clobbers.
 356   SmallVector<std::string, 16> ClobbersData;
 357   SmallVector<StringRef, 16> Clobbers;
 358   ClobbersData.reserve(S->NumClobbers);
 359   Clobbers.reserve(S->NumClobbers);
 360   for (unsigned i = 0, e = S->NumClobbers; i != e; ++i) {
 361     ClobbersData.push_back(ReadString(Record, Idx));
 362     Clobbers.push_back(ClobbersData.back());
 363   }
 364
 365   // Read the operands.
 366   unsigned NumOperands = S->NumOutputs + S->NumInputs;
 367   SmallVector<Expr*, 16> Exprs;
 368   SmallVector<std::string, 16> ConstraintsData;
 369   SmallVector<StringRef, 16> Constraints;
 370   Exprs.reserve(NumOperands);
 371   ConstraintsData.reserve(NumOperands);
 372   Constraints.reserve(NumOperands);
 373   for (unsigned i = 0; i != NumOperands; ++i) {
 374     Exprs.push_back(cast<Expr>(Reader.ReadSubStmt()));
 375     ConstraintsData.push_back(ReadString(Record, Idx));
 376     Constraints.push_back(ConstraintsData.back());
 377   }
 378
 379   S->initialize(Reader.getContext(), AsmStr, AsmToks,
 380                 Constraints, Exprs, Clobbers);
 381 }
 382
 383 void ASTStmtReader::VisitCapturedStmt(CapturedStmt *S) {
 384   VisitStmt(S);
 385   S->setCapturedDecl(ReadDeclAs<CapturedDecl>(Record, Idx));
 386   S->setCapturedRegionKind(static_cast<CapturedRegionKind>(Record[Idx++]));
 387   S->setCapturedRecordDecl(ReadDeclAs<RecordDecl>(Record, Idx));
 388
 389   // Capture inits
 390   for (CapturedStmt::capture_init_iterator I = S->capture_init_begin(),
 391                                            E = S->capture_init_end();
 392        I != E; ++I)
 393     *I = Reader.ReadSubExpr();
 394
 395   // Body
 396   S->setCapturedStmt(Reader.ReadSubStmt());
 397   S->getCapturedDecl()->setBody(S->getCapturedStmt());
 398
 399   // Captures
 400   for (CapturedStmt::capture_iterator I = S->capture_begin(),
 401                                       E = S->capture_end();
 402        I != E; ++I) {
 403     I->VarAndKind.setPointer(ReadDeclAs<VarDecl>(Record, Idx));
 404     I->VarAndKind
 405         .setInt(static_cast<CapturedStmt::VariableCaptureKind>(Record[Idx++]));
 406     I->Loc = ReadSourceLocation(Record, Idx);
 407   }
 408 }
 409
 410 void ASTStmtReader::VisitExpr(Expr *E) {
 411   VisitStmt(E);
 412   E->setType(Reader.readType(F, Record, Idx));
 413   E->setTypeDependent(Record[Idx++]);
 414   E->setValueDependent(Record[Idx++]);
 415   E->setInstantiationDependent(Record[Idx++]);
 416   E->ExprBits.ContainsUnexpandedParameterPack = Record[Idx++];
 417   E->setValueKind(static_cast<ExprValueKind>(Record[Idx++]));
 418   E->setObjectKind(static_cast<ExprObjectKind>(Record[Idx++]));
 419   assert(Idx == NumExprFields && "Incorrect expression field count");
 420 }
 421
 422 void ASTStmtReader::VisitPredefinedExpr(PredefinedExpr *E) {
 423   VisitExpr(E);
 424   E->setLocation(ReadSourceLocation(Record, Idx));
 425   E->setIdentType((PredefinedExpr::IdentType)Record[Idx++]);
 426 }
 427
 428 void ASTStmtReader::VisitDeclRefExpr(DeclRefExpr *E) {
 429   VisitExpr(E);
 430
 431   E->DeclRefExprBits.HasQualifier = Record[Idx++];
 432   E->DeclRefExprBits.HasFoundDecl = Record[Idx++];
 433   E->DeclRefExprBits.HasTemplateKWAndArgsInfo = Record[Idx++];
 434   E->DeclRefExprBits.HadMultipleCandidates = Record[Idx++];
 435   E->DeclRefExprBits.RefersToEnclosingLocal = Record[Idx++];
 436   unsigned NumTemplateArgs = 0;
 437   if (E->hasTemplateKWAndArgsInfo())
 438     NumTemplateArgs = Record[Idx++];
 439
 440   if (E->hasQualifier())
 441     E->getInternalQualifierLoc()
 442       = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
 443
 444   if (E->hasFoundDecl())
 445     E->getInternalFoundDecl() = ReadDeclAs<NamedDecl>(Record, Idx);
 446
 447   if (E->hasTemplateKWAndArgsInfo())
 448     ReadTemplateKWAndArgsInfo(*E->getTemplateKWAndArgsInfo(),
 449                               NumTemplateArgs);
 450
 451   E->setDecl(ReadDeclAs<ValueDecl>(Record, Idx));
 452   E->setLocation(ReadSourceLocation(Record, Idx));
 453   ReadDeclarationNameLoc(E->DNLoc, E->getDecl()->getDeclName(), Record, Idx);
 454 }
 455
 456 void ASTStmtReader::VisitIntegerLiteral(IntegerLiteral *E) {
 457   VisitExpr(E);
 458   E->setLocation(ReadSourceLocation(Record, Idx));
 459   E->setValue(Reader.getContext(), Reader.ReadAPInt(Record, Idx));
 460 }
 461
 462 void ASTStmtReader::VisitFloatingLiteral(FloatingLiteral *E) {
 463   VisitExpr(E);
 464   E->setRawSemantics(static_cast<Stmt::APFloatSemantics>(Record[Idx++]));
 465   E->setExact(Record[Idx++]);
 466   E->setValue(Reader.getContext(),
 467               Reader.ReadAPFloat(Record, E->getSemantics(), Idx));
 468   E->setLocation(ReadSourceLocation(Record, Idx));
 469 }
 470
 471 void ASTStmtReader::VisitImaginaryLiteral(ImaginaryLiteral *E) {
 472   VisitExpr(E);
 473   E->setSubExpr(Reader.ReadSubExpr());
 474 }
 475
 476 void ASTStmtReader::VisitStringLiteral(StringLiteral *E) {
 477   VisitExpr(E);
 478   unsigned Len = Record[Idx++];
 479   assert(Record[Idx] == E->getNumConcatenated() &&
 480          "Wrong number of concatenated tokens!");
 481   ++Idx;
 482   StringLiteral::StringKind kind =
 483         static_cast<StringLiteral::StringKind>(Record[Idx++]);
 484   bool isPascal = Record[Idx++];
 485
 486   // Read string data
 487   SmallString<16> Str(&Record[Idx], &Record[Idx] + Len);
 488   E->setString(Reader.getContext(), Str.str(), kind, isPascal);
 489   Idx += Len;
 490
 491   // Read source locations
 492   for (unsigned I = 0, N = E->getNumConcatenated(); I != N; ++I)
 493     E->setStrTokenLoc(I, ReadSourceLocation(Record, Idx));
 494 }
 495
 496 void ASTStmtReader::VisitCharacterLiteral(CharacterLiteral *E) {
 497   VisitExpr(E);
 498   E->setValue(Record[Idx++]);
 499   E->setLocation(ReadSourceLocation(Record, Idx));
 500   E->setKind(static_cast<CharacterLiteral::CharacterKind>(Record[Idx++]));
 501 }
 502
 503 void ASTStmtReader::VisitParenExpr(ParenExpr *E) {
 504   VisitExpr(E);
 505   E->setLParen(ReadSourceLocation(Record, Idx));
 506   E->setRParen(ReadSourceLocation(Record, Idx));
 507   E->setSubExpr(Reader.ReadSubExpr());
 508 }
 509
 510 void ASTStmtReader::VisitParenListExpr(ParenListExpr *E) {
 511   VisitExpr(E);
 512   unsigned NumExprs = Record[Idx++];
 513   E->Exprs = new (Reader.getContext()) Stmt*[NumExprs];
 514   for (unsigned i = 0; i != NumExprs; ++i)
 515     E->Exprs[i] = Reader.ReadSubStmt();
 516   E->NumExprs = NumExprs;
 517   E->LParenLoc = ReadSourceLocation(Record, Idx);
 518   E->RParenLoc = ReadSourceLocation(Record, Idx);
 519 }
 520
 521 void ASTStmtReader::VisitUnaryOperator(UnaryOperator *E) {
 522   VisitExpr(E);
 523   E->setSubExpr(Reader.ReadSubExpr());
 524   E->setOpcode((UnaryOperator::Opcode)Record[Idx++]);
 525   E->setOperatorLoc(ReadSourceLocation(Record, Idx));
 526 }
 527
 528 void ASTStmtReader::VisitOffsetOfExpr(OffsetOfExpr *E) {
 529   typedef OffsetOfExpr::OffsetOfNode Node;
 530   VisitExpr(E);
 531   assert(E->getNumComponents() == Record[Idx]);
 532   ++Idx;
 533   assert(E->getNumExpressions() == Record[Idx]);
 534   ++Idx;
 535   E->setOperatorLoc(ReadSourceLocation(Record, Idx));
 536   E->setRParenLoc(ReadSourceLocation(Record, Idx));
 537   E->setTypeSourceInfo(GetTypeSourceInfo(Record, Idx));
 538   for (unsigned I = 0, N = E->getNumComponents(); I != N; ++I) {
 539     Node::Kind Kind = static_cast<Node::Kind>(Record[Idx++]);
 540     SourceLocation Start = ReadSourceLocation(Record, Idx);
 541     SourceLocation End = ReadSourceLocation(Record, Idx);
 542     switch (Kind) {
 543     case Node::Array:
 544       E->setComponent(I, Node(Start, Record[Idx++], End));
 545       break;
 546
 547     case Node::Field:
 548       E->setComponent(I, Node(Start, ReadDeclAs<FieldDecl>(Record, Idx), End));
 549       break;
 550
 551     case Node::Identifier:
 552       E->setComponent(I,
 553                       Node(Start,
 554                            Reader.GetIdentifierInfo(F, Record, Idx),
 555                            End));
 556       break;
 557
 558     case Node::Base: {
 559       CXXBaseSpecifier *Base = new (Reader.getContext()) CXXBaseSpecifier();
 560       *Base = Reader.ReadCXXBaseSpecifier(F, Record, Idx);
 561       E->setComponent(I, Node(Base));
 562       break;
 563     }
 564     }
 565   }
 566
 567   for (unsigned I = 0, N = E->getNumExpressions(); I != N; ++I)
 568     E->setIndexExpr(I, Reader.ReadSubExpr());
 569 }
 570
 571 void ASTStmtReader::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E) {
 572   VisitExpr(E);
 573   E->setKind(static_cast<UnaryExprOrTypeTrait>(Record[Idx++]));
 574   if (Record[Idx] == 0) {
 575     E->setArgument(Reader.ReadSubExpr());
 576     ++Idx;
 577   } else {
 578     E->setArgument(GetTypeSourceInfo(Record, Idx));
 579   }
 580   E->setOperatorLoc(ReadSourceLocation(Record, Idx));
 581   E->setRParenLoc(ReadSourceLocation(Record, Idx));
 582 }
 583
 584 void ASTStmtReader::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
 585   VisitExpr(E);
 586   E->setLHS(Reader.ReadSubExpr());
 587   E->setRHS(Reader.ReadSubExpr());
 588   E->setRBracketLoc(ReadSourceLocation(Record, Idx));
 589 }
 590
 591 void ASTStmtReader::VisitCallExpr(CallExpr *E) {
 592   VisitExpr(E);
 593   E->setNumArgs(Reader.getContext(), Record[Idx++]);
 594   E->setRParenLoc(ReadSourceLocation(Record, Idx));
 595   E->setCallee(Reader.ReadSubExpr());
 596   for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
 597     E->setArg(I, Reader.ReadSubExpr());
 598 }
 599
 600 void ASTStmtReader::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
 601   VisitCallExpr(E);
 602 }
 603
 604 void ASTStmtReader::VisitMemberExpr(MemberExpr *E) {
 605   // Don't call VisitExpr, this is fully initialized at creation.
 606   assert(E->getStmtClass() == Stmt::MemberExprClass &&
 607          "It's a subclass, we must advance Idx!");
 608 }
 609
 610 void ASTStmtReader::VisitObjCIsaExpr(ObjCIsaExpr *E) {
 611   VisitExpr(E);
 612   E->setBase(Reader.ReadSubExpr());
 613   E->setIsaMemberLoc(ReadSourceLocation(Record, Idx));
 614   E->setOpLoc(ReadSourceLocation(Record, Idx));
 615   E->setArrow(Record[Idx++]);
 616 }
 617
 618 void ASTStmtReader::
 619 VisitObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *E) {
 620   VisitExpr(E);
 621   E->Operand = Reader.ReadSubExpr();
 622   E->setShouldCopy(Record[Idx++]);
 623 }
 624
 625 void ASTStmtReader::VisitObjCBridgedCastExpr(ObjCBridgedCastExpr *E) {
 626   VisitExplicitCastExpr(E);
 627   E->LParenLoc = ReadSourceLocation(Record, Idx);
 628   E->BridgeKeywordLoc = ReadSourceLocation(Record, Idx);
 629   E->Kind = Record[Idx++];
 630 }
 631
 632 void ASTStmtReader::VisitCastExpr(CastExpr *E) {
 633   VisitExpr(E);
 634   unsigned NumBaseSpecs = Record[Idx++];
 635   assert(NumBaseSpecs == E->path_size());
 636   E->setSubExpr(Reader.ReadSubExpr());
 637   E->setCastKind((CastExpr::CastKind)Record[Idx++]);
 638   CastExpr::path_iterator BaseI = E->path_begin();
 639   while (NumBaseSpecs--) {
 640     CXXBaseSpecifier *BaseSpec = new (Reader.getContext()) CXXBaseSpecifier;
 641     *BaseSpec = Reader.ReadCXXBaseSpecifier(F, Record, Idx);
 642     *BaseI++ = BaseSpec;
 643   }
 644 }
 645
 646 void ASTStmtReader::VisitBinaryOperator(BinaryOperator *E) {
 647   VisitExpr(E);
 648   E->setLHS(Reader.ReadSubExpr());
 649   E->setRHS(Reader.ReadSubExpr());
 650   E->setOpcode((BinaryOperator::Opcode)Record[Idx++]);
 651   E->setOperatorLoc(ReadSourceLocation(Record, Idx));
 652   E->setFPContractable((bool)Record[Idx++]);
 653 }
 654
 655 void ASTStmtReader::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
 656   VisitBinaryOperator(E);
 657   E->setComputationLHSType(Reader.readType(F, Record, Idx));
 658   E->setComputationResultType(Reader.readType(F, Record, Idx));
 659 }
 660
 661 void ASTStmtReader::VisitConditionalOperator(ConditionalOperator *E) {
 662   VisitExpr(E);
 663   E->SubExprs[ConditionalOperator::COND] = Reader.ReadSubExpr();
 664   E->SubExprs[ConditionalOperator::LHS] = Reader.ReadSubExpr();
 665   E->SubExprs[ConditionalOperator::RHS] = Reader.ReadSubExpr();
 666   E->QuestionLoc = ReadSourceLocation(Record, Idx);
 667   E->ColonLoc = ReadSourceLocation(Record, Idx);
 668 }
 669
 670 void
 671 ASTStmtReader::VisitBinaryConditionalOperator(BinaryConditionalOperator *E) {
 672   VisitExpr(E);
 673   E->OpaqueValue = cast<OpaqueValueExpr>(Reader.ReadSubExpr());
 674   E->SubExprs[BinaryConditionalOperator::COMMON] = Reader.ReadSubExpr();
 675   E->SubExprs[BinaryConditionalOperator::COND] = Reader.ReadSubExpr();
 676   E->SubExprs[BinaryConditionalOperator::LHS] = Reader.ReadSubExpr();
 677   E->SubExprs[BinaryConditionalOperator::RHS] = Reader.ReadSubExpr();
 678   E->QuestionLoc = ReadSourceLocation(Record, Idx);
 679   E->ColonLoc = ReadSourceLocation(Record, Idx);
 680 }
 681
 682 void ASTStmtReader::VisitImplicitCastExpr(ImplicitCastExpr *E) {
 683   VisitCastExpr(E);
 684 }
 685
 686 void ASTStmtReader::VisitExplicitCastExpr(ExplicitCastExpr *E) {
 687   VisitCastExpr(E);
 688   E->setTypeInfoAsWritten(GetTypeSourceInfo(Record, Idx));
 689 }
 690
 691 void ASTStmtReader::VisitCStyleCastExpr(CStyleCastExpr *E) {
 692   VisitExplicitCastExpr(E);
 693   E->setLParenLoc(ReadSourceLocation(Record, Idx));
 694   E->setRParenLoc(ReadSourceLocation(Record, Idx));
 695 }
 696
 697 void ASTStmtReader::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
 698   VisitExpr(E);
 699   E->setLParenLoc(ReadSourceLocation(Record, Idx));
 700   E->setTypeSourceInfo(GetTypeSourceInfo(Record, Idx));
 701   E->setInitializer(Reader.ReadSubExpr());
 702   E->setFileScope(Record[Idx++]);
 703 }
 704
 705 void ASTStmtReader::VisitExtVectorElementExpr(ExtVectorElementExpr *E) {
 706   VisitExpr(E);
 707   E->setBase(Reader.ReadSubExpr());
 708   E->setAccessor(Reader.GetIdentifierInfo(F, Record, Idx));
 709   E->setAccessorLoc(ReadSourceLocation(Record, Idx));
 710 }
 711
 712 void ASTStmtReader::VisitInitListExpr(InitListExpr *E) {
 713   VisitExpr(E);
 714   if (InitListExpr *SyntForm = cast_or_null<InitListExpr>(Reader.ReadSubStmt()))
 715     E->setSyntacticForm(SyntForm);
 716   E->setLBraceLoc(ReadSourceLocation(Record, Idx));
 717   E->setRBraceLoc(ReadSourceLocation(Record, Idx));
 718   bool isArrayFiller = Record[Idx++];
 719   Expr *filler = 0;
 720   if (isArrayFiller) {
 721     filler = Reader.ReadSubExpr();
 722     E->ArrayFillerOrUnionFieldInit = filler;
 723   } else
 724     E->ArrayFillerOrUnionFieldInit = ReadDeclAs<FieldDecl>(Record, Idx);
 725   E->sawArrayRangeDesignator(Record[Idx++]);
 726   E->setInitializesStdInitializerList(Record[Idx++]);
 727   unsigned NumInits = Record[Idx++];
 728   E->reserveInits(Reader.getContext(), NumInits);
 729   if (isArrayFiller) {
 730     for (unsigned I = 0; I != NumInits; ++I) {
 731       Expr *init = Reader.ReadSubExpr();
 732       E->updateInit(Reader.getContext(), I, init ? init : filler);
 733     }
 734   } else {
 735     for (unsigned I = 0; I != NumInits; ++I)
 736       E->updateInit(Reader.getContext(), I, Reader.ReadSubExpr());
 737   }
 738 }
 739
 740 void ASTStmtReader::VisitDesignatedInitExpr(DesignatedInitExpr *E) {
 741   typedef DesignatedInitExpr::Designator Designator;
 742
 743   VisitExpr(E);
 744   unsigned NumSubExprs = Record[Idx++];
 745   assert(NumSubExprs == E->getNumSubExprs() && "Wrong number of subexprs");
 746   for (unsigned I = 0; I != NumSubExprs; ++I)
 747     E->setSubExpr(I, Reader.ReadSubExpr());
 748   E->setEqualOrColonLoc(ReadSourceLocation(Record, Idx));
 749   E->setGNUSyntax(Record[Idx++]);
 750
 751   SmallVector<Designator, 4> Designators;
 752   while (Idx < Record.size()) {
 753     switch ((DesignatorTypes)Record[Idx++]) {
 754     case DESIG_FIELD_DECL: {
 755       FieldDecl *Field = ReadDeclAs<FieldDecl>(Record, Idx);
 756       SourceLocation DotLoc
 757         = ReadSourceLocation(Record, Idx);
 758       SourceLocation FieldLoc
 759         = ReadSourceLocation(Record, Idx);
 760       Designators.push_back(Designator(Field->getIdentifier(), DotLoc,
 761                                        FieldLoc));
 762       Designators.back().setField(Field);
 763       break;
 764     }
 765
 766     case DESIG_FIELD_NAME: {
 767       const IdentifierInfo *Name = Reader.GetIdentifierInfo(F, Record, Idx);
 768       SourceLocation DotLoc
 769         = ReadSourceLocation(Record, Idx);
 770       SourceLocation FieldLoc
 771         = ReadSourceLocation(Record, Idx);
 772       Designators.push_back(Designator(Name, DotLoc, FieldLoc));
 773       break;
 774     }
 775
 776     case DESIG_ARRAY: {
 777       unsigned Index = Record[Idx++];
 778       SourceLocation LBracketLoc
 779         = ReadSourceLocation(Record, Idx);
 780       SourceLocation RBracketLoc
 781         = ReadSourceLocation(Record, Idx);
 782       Designators.push_back(Designator(Index, LBracketLoc, RBracketLoc));
 783       break;
 784     }
 785
 786     case DESIG_ARRAY_RANGE: {
 787       unsigned Index = Record[Idx++];
 788       SourceLocation LBracketLoc
 789         = ReadSourceLocation(Record, Idx);
 790       SourceLocation EllipsisLoc
 791         = ReadSourceLocation(Record, Idx);
 792       SourceLocation RBracketLoc
 793         = ReadSourceLocation(Record, Idx);
 794       Designators.push_back(Designator(Index, LBracketLoc, EllipsisLoc,
 795                                        RBracketLoc));
 796       break;
 797     }
 798     }
 799   }
 800   E->setDesignators(Reader.getContext(),
 801                     Designators.data(), Designators.size());
 802 }
 803
 804 void ASTStmtReader::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
 805   VisitExpr(E);
 806 }
 807
 808 void ASTStmtReader::VisitVAArgExpr(VAArgExpr *E) {
 809   VisitExpr(E);
 810   E->setSubExpr(Reader.ReadSubExpr());
 811   E->setWrittenTypeInfo(GetTypeSourceInfo(Record, Idx));
 812   E->setBuiltinLoc(ReadSourceLocation(Record, Idx));
 813   E->setRParenLoc(ReadSourceLocation(Record, Idx));
 814 }
 815
 816 void ASTStmtReader::VisitAddrLabelExpr(AddrLabelExpr *E) {
 817   VisitExpr(E);
 818   E->setAmpAmpLoc(ReadSourceLocation(Record, Idx));
 819   E->setLabelLoc(ReadSourceLocation(Record, Idx));
 820   E->setLabel(ReadDeclAs<LabelDecl>(Record, Idx));
 821 }
 822
 823 void ASTStmtReader::VisitStmtExpr(StmtExpr *E) {
 824   VisitExpr(E);
 825   E->setLParenLoc(ReadSourceLocation(Record, Idx));
 826   E->setRParenLoc(ReadSourceLocation(Record, Idx));
 827   E->setSubStmt(cast_or_null<CompoundStmt>(Reader.ReadSubStmt()));
 828 }
 829
 830 void ASTStmtReader::VisitChooseExpr(ChooseExpr *E) {
 831   VisitExpr(E);
 832   E->setCond(Reader.ReadSubExpr());
 833   E->setLHS(Reader.ReadSubExpr());
 834   E->setRHS(Reader.ReadSubExpr());
 835   E->setBuiltinLoc(ReadSourceLocation(Record, Idx));
 836   E->setRParenLoc(ReadSourceLocation(Record, Idx));
 837 }
 838
 839 void ASTStmtReader::VisitGNUNullExpr(GNUNullExpr *E) {
 840   VisitExpr(E);
 841   E->setTokenLocation(ReadSourceLocation(Record, Idx));
 842 }
 843
 844 void ASTStmtReader::VisitShuffleVectorExpr(ShuffleVectorExpr *E) {
 845   VisitExpr(E);
 846   SmallVector<Expr *, 16> Exprs;
 847   unsigned NumExprs = Record[Idx++];
 848   while (NumExprs--)
 849     Exprs.push_back(Reader.ReadSubExpr());
 850   E->setExprs(Reader.getContext(), Exprs.data(), Exprs.size());
 851   E->setBuiltinLoc(ReadSourceLocation(Record, Idx));
 852   E->setRParenLoc(ReadSourceLocation(Record, Idx));
 853 }
 854
 855 void ASTStmtReader::VisitBlockExpr(BlockExpr *E) {
 856   VisitExpr(E);
 857   E->setBlockDecl(ReadDeclAs<BlockDecl>(Record, Idx));
 858 }
 859
 860 void ASTStmtReader::VisitGenericSelectionExpr(GenericSelectionExpr *E) {
 861   VisitExpr(E);
 862   E->NumAssocs = Record[Idx++];
 863   E->AssocTypes = new (Reader.getContext()) TypeSourceInfo*[E->NumAssocs];
 864   E->SubExprs =
 865    new(Reader.getContext()) Stmt*[GenericSelectionExpr::END_EXPR+E->NumAssocs];
 866
 867   E->SubExprs[GenericSelectionExpr::CONTROLLING] = Reader.ReadSubExpr();
 868   for (unsigned I = 0, N = E->getNumAssocs(); I != N; ++I) {
 869     E->AssocTypes[I] = GetTypeSourceInfo(Record, Idx);
 870     E->SubExprs[GenericSelectionExpr::END_EXPR+I] = Reader.ReadSubExpr();
 871   }
 872   E->ResultIndex = Record[Idx++];
 873
 874   E->GenericLoc = ReadSourceLocation(Record, Idx);
 875   E->DefaultLoc = ReadSourceLocation(Record, Idx);
 876   E->RParenLoc = ReadSourceLocation(Record, Idx);
 877 }
 878
 879 void ASTStmtReader::VisitPseudoObjectExpr(PseudoObjectExpr *E) {
 880   VisitExpr(E);
 881   unsigned numSemanticExprs = Record[Idx++];
 882   assert(numSemanticExprs + 1 == E->PseudoObjectExprBits.NumSubExprs);
 883   E->PseudoObjectExprBits.ResultIndex = Record[Idx++];
 884
 885   // Read the syntactic expression.
 886   E->getSubExprsBuffer()[0] = Reader.ReadSubExpr();
 887
 888   // Read all the semantic expressions.
 889   for (unsigned i = 0; i != numSemanticExprs; ++i) {
 890     Expr *subExpr = Reader.ReadSubExpr();
 891     E->getSubExprsBuffer()[i+1] = subExpr;
 892   }
 893 }
 894
 895 void ASTStmtReader::VisitAtomicExpr(AtomicExpr *E) {
 896   VisitExpr(E);
 897   E->Op = AtomicExpr::AtomicOp(Record[Idx++]);
 898   E->NumSubExprs = AtomicExpr::getNumSubExprs(E->Op);
 899   for (unsigned I = 0; I != E->NumSubExprs; ++I)
 900     E->SubExprs[I] = Reader.ReadSubExpr();
 901   E->BuiltinLoc = ReadSourceLocation(Record, Idx);
 902   E->RParenLoc = ReadSourceLocation(Record, Idx);
 903 }
 904
 905 //===----------------------------------------------------------------------===//
 906 // Objective-C Expressions and Statements
 907
 908 void ASTStmtReader::VisitObjCStringLiteral(ObjCStringLiteral *E) {
 909   VisitExpr(E);
 910   E->setString(cast<StringLiteral>(Reader.ReadSubStmt()));
 911   E->setAtLoc(ReadSourceLocation(Record, Idx));
 912 }
 913
 914 void ASTStmtReader::VisitObjCBoxedExpr(ObjCBoxedExpr *E) {
 915   VisitExpr(E);
 916   // could be one of several IntegerLiteral, FloatLiteral, etc.
 917   E->SubExpr = Reader.ReadSubStmt();
 918   E->BoxingMethod = ReadDeclAs<ObjCMethodDecl>(Record, Idx);
 919   E->Range = ReadSourceRange(Record, Idx);
 920 }
 921
 922 void ASTStmtReader::VisitObjCArrayLiteral(ObjCArrayLiteral *E) {
 923   VisitExpr(E);
 924   unsigned NumElements = Record[Idx++];
 925   assert(NumElements == E->getNumElements() && "Wrong number of elements");
 926   Expr **Elements = E->getElements();
 927   for (unsigned I = 0, N = NumElements; I != N; ++I)
 928     Elements[I] = Reader.ReadSubExpr();
 929   E->ArrayWithObjectsMethod = ReadDeclAs<ObjCMethodDecl>(Record, Idx);
 930   E->Range = ReadSourceRange(Record, Idx);
 931 }
 932
 933 void ASTStmtReader::VisitObjCDictionaryLiteral(ObjCDictionaryLiteral *E) {
 934   VisitExpr(E);
 935   unsigned NumElements = Record[Idx++];
 936   assert(NumElements == E->getNumElements() && "Wrong number of elements");
 937   bool HasPackExpansions = Record[Idx++];
 938   assert(HasPackExpansions == E->HasPackExpansions &&"Pack expansion mismatch");
 939   ObjCDictionaryLiteral::KeyValuePair *KeyValues = E->getKeyValues();
 940   ObjCDictionaryLiteral::ExpansionData *Expansions = E->getExpansionData();
 941   for (unsigned I = 0; I != NumElements; ++I) {
 942     KeyValues[I].Key = Reader.ReadSubExpr();
 943     KeyValues[I].Value = Reader.ReadSubExpr();
 944     if (HasPackExpansions) {
 945       Expansions[I].EllipsisLoc = ReadSourceLocation(Record, Idx);
 946       Expansions[I].NumExpansionsPlusOne = Record[Idx++];
 947     }
 948   }
 949   E->DictWithObjectsMethod = ReadDeclAs<ObjCMethodDecl>(Record, Idx);
 950   E->Range = ReadSourceRange(Record, Idx);
 951 }
 952
 953 void ASTStmtReader::VisitObjCEncodeExpr(ObjCEncodeExpr *E) {
 954   VisitExpr(E);
 955   E->setEncodedTypeSourceInfo(GetTypeSourceInfo(Record, Idx));
 956   E->setAtLoc(ReadSourceLocation(Record, Idx));
 957   E->setRParenLoc(ReadSourceLocation(Record, Idx));
 958 }
 959
 960 void ASTStmtReader::VisitObjCSelectorExpr(ObjCSelectorExpr *E) {
 961   VisitExpr(E);
 962   E->setSelector(Reader.ReadSelector(F, Record, Idx));
 963   E->setAtLoc(ReadSourceLocation(Record, Idx));
 964   E->setRParenLoc(ReadSourceLocation(Record, Idx));
 965 }
 966
 967 void ASTStmtReader::VisitObjCProtocolExpr(ObjCProtocolExpr *E) {
 968   VisitExpr(E);
 969   E->setProtocol(ReadDeclAs<ObjCProtocolDecl>(Record, Idx));
 970   E->setAtLoc(ReadSourceLocation(Record, Idx));
 971   E->ProtoLoc = ReadSourceLocation(Record, Idx);
 972   E->setRParenLoc(ReadSourceLocation(Record, Idx));
 973 }
 974
 975 void ASTStmtReader::VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
 976   VisitExpr(E);
 977   E->setDecl(ReadDeclAs<ObjCIvarDecl>(Record, Idx));
 978   E->setLocation(ReadSourceLocation(Record, Idx));
 979   E->setOpLoc(ReadSourceLocation(Record, Idx));
 980   E->setBase(Reader.ReadSubExpr());
 981   E->setIsArrow(Record[Idx++]);
 982   E->setIsFreeIvar(Record[Idx++]);
 983 }
 984
 985 void ASTStmtReader::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
 986   VisitExpr(E);
 987   unsigned MethodRefFlags = Record[Idx++];
 988   bool Implicit = Record[Idx++] != 0;
 989   if (Implicit) {
 990     ObjCMethodDecl *Getter = ReadDeclAs<ObjCMethodDecl>(Record, Idx);
 991     ObjCMethodDecl *Setter = ReadDeclAs<ObjCMethodDecl>(Record, Idx);
 992     E->setImplicitProperty(Getter, Setter, MethodRefFlags);
 993   } else {
 994     E->setExplicitProperty(ReadDeclAs<ObjCPropertyDecl>(Record, Idx),
 995                            MethodRefFlags);
 996   }
 997   E->setLocation(ReadSourceLocation(Record, Idx));
 998   E->setReceiverLocation(ReadSourceLocation(Record, Idx));
 999   switch (Record[Idx++]) {
1000   case 0:
1001     E->setBase(Reader.ReadSubExpr());
1002     break;
1003   case 1:
1004     E->setSuperReceiver(Reader.readType(F, Record, Idx));
1005     break;
1006   case 2:
1007     E->setClassReceiver(ReadDeclAs<ObjCInterfaceDecl>(Record, Idx));
1008     break;
1009   }
1010 }
1011
1012 void ASTStmtReader::VisitObjCSubscriptRefExpr(ObjCSubscriptRefExpr *E) {
1013   VisitExpr(E);
1014   E->setRBracket(ReadSourceLocation(Record, Idx));
1015   E->setBaseExpr(Reader.ReadSubExpr());
1016   E->setKeyExpr(Reader.ReadSubExpr());
1017   E->GetAtIndexMethodDecl = ReadDeclAs<ObjCMethodDecl>(Record, Idx);
1018   E->SetAtIndexMethodDecl = ReadDeclAs<ObjCMethodDecl>(Record, Idx);
1019 }
1020
1021 void ASTStmtReader::VisitObjCMessageExpr(ObjCMessageExpr *E) {
1022   VisitExpr(E);
1023   assert(Record[Idx] == E->getNumArgs());
1024   ++Idx;
1025   unsigned NumStoredSelLocs = Record[Idx++];
1026   E->SelLocsKind = Record[Idx++];
1027   E->setDelegateInitCall(Record[Idx++]);
1028   E->IsImplicit = Record[Idx++];
1029   ObjCMessageExpr::ReceiverKind Kind
1030     = static_cast<ObjCMessageExpr::ReceiverKind>(Record[Idx++]);
1031   switch (Kind) {
1032   case ObjCMessageExpr::Instance:
1033     E->setInstanceReceiver(Reader.ReadSubExpr());
1034     break;
1035
1036   case ObjCMessageExpr::Class:
1037     E->setClassReceiver(GetTypeSourceInfo(Record, Idx));
1038     break;
1039
1040   case ObjCMessageExpr::SuperClass:
1041   case ObjCMessageExpr::SuperInstance: {
1042     QualType T = Reader.readType(F, Record, Idx);
1043     SourceLocation SuperLoc = ReadSourceLocation(Record, Idx);
1044     E->setSuper(SuperLoc, T, Kind == ObjCMessageExpr::SuperInstance);
1045     break;
1046   }
1047   }
1048
1049   assert(Kind == E->getReceiverKind());
1050
1051   if (Record[Idx++])
1052     E->setMethodDecl(ReadDeclAs<ObjCMethodDecl>(Record, Idx));
1053   else
1054     E->setSelector(Reader.ReadSelector(F, Record, Idx));
1055
1056   E->LBracLoc = ReadSourceLocation(Record, Idx);
1057   E->RBracLoc = ReadSourceLocation(Record, Idx);
1058
1059   for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
1060     E->setArg(I, Reader.ReadSubExpr());
1061
1062   SourceLocation *Locs = E->getStoredSelLocs();
1063   for (unsigned I = 0; I != NumStoredSelLocs; ++I)
1064     Locs[I] = ReadSourceLocation(Record, Idx);
1065 }
1066
1067 void ASTStmtReader::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) {
1068   VisitStmt(S);
1069   S->setElement(Reader.ReadSubStmt());
1070   S->setCollection(Reader.ReadSubExpr());
1071   S->setBody(Reader.ReadSubStmt());
1072   S->setForLoc(ReadSourceLocation(Record, Idx));
1073   S->setRParenLoc(ReadSourceLocation(Record, Idx));
1074 }
1075
1076 void ASTStmtReader::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) {
1077   VisitStmt(S);
1078   S->setCatchBody(Reader.ReadSubStmt());
1079   S->setCatchParamDecl(ReadDeclAs<VarDecl>(Record, Idx));
1080   S->setAtCatchLoc(ReadSourceLocation(Record, Idx));
1081   S->setRParenLoc(ReadSourceLocation(Record, Idx));
1082 }
1083
1084 void ASTStmtReader::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
1085   VisitStmt(S);
1086   S->setFinallyBody(Reader.ReadSubStmt());
1087   S->setAtFinallyLoc(ReadSourceLocation(Record, Idx));
1088 }
1089
1090 void ASTStmtReader::VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S) {
1091   VisitStmt(S);
1092   S->setSubStmt(Reader.ReadSubStmt());
1093   S->setAtLoc(ReadSourceLocation(Record, Idx));
1094 }
1095
1096 void ASTStmtReader::VisitObjCAtTryStmt(ObjCAtTryStmt *S) {
1097   VisitStmt(S);
1098   assert(Record[Idx] == S->getNumCatchStmts());
1099   ++Idx;
1100   bool HasFinally = Record[Idx++];
1101   S->setTryBody(Reader.ReadSubStmt());
1102   for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I)
1103     S->setCatchStmt(I, cast_or_null<ObjCAtCatchStmt>(Reader.ReadSubStmt()));
1104
1105   if (HasFinally)
1106     S->setFinallyStmt(Reader.ReadSubStmt());
1107   S->setAtTryLoc(ReadSourceLocation(Record, Idx));
1108 }
1109
1110 void ASTStmtReader::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S) {
1111   VisitStmt(S);
1112   S->setSynchExpr(Reader.ReadSubStmt());
1113   S->setSynchBody(Reader.ReadSubStmt());
1114   S->setAtSynchronizedLoc(ReadSourceLocation(Record, Idx));
1115 }
1116
1117 void ASTStmtReader::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) {
1118   VisitStmt(S);
1119   S->setThrowExpr(Reader.ReadSubStmt());
1120   S->setThrowLoc(ReadSourceLocation(Record, Idx));
1121 }
1122
1123 void ASTStmtReader::VisitObjCBoolLiteralExpr(ObjCBoolLiteralExpr *E) {
1124   VisitExpr(E);
1125   E->setValue(Record[Idx++]);
1126   E->setLocation(ReadSourceLocation(Record, Idx));
1127 }
1128
1129 //===----------------------------------------------------------------------===//
1130 // C++ Expressions and Statements
1131 //===----------------------------------------------------------------------===//
1132
1133 void ASTStmtReader::VisitCXXCatchStmt(CXXCatchStmt *S) {
1134   VisitStmt(S);
1135   S->CatchLoc = ReadSourceLocation(Record, Idx);
1136   S->ExceptionDecl = ReadDeclAs<VarDecl>(Record, Idx);
1137   S->HandlerBlock = Reader.ReadSubStmt();
1138 }
1139
1140 void ASTStmtReader::VisitCXXTryStmt(CXXTryStmt *S) {
1141   VisitStmt(S);
1142   assert(Record[Idx] == S->getNumHandlers() && "NumStmtFields is wrong ?");
1143   ++Idx;
1144   S->TryLoc = ReadSourceLocation(Record, Idx);
1145   S->getStmts()[0] = Reader.ReadSubStmt();
1146   for (unsigned i = 0, e = S->getNumHandlers(); i != e; ++i)
1147     S->getStmts()[i + 1] = Reader.ReadSubStmt();
1148 }
1149
1150 void ASTStmtReader::VisitCXXForRangeStmt(CXXForRangeStmt *S) {
1151   VisitStmt(S);
1152   S->setForLoc(ReadSourceLocation(Record, Idx));
1153   S->setColonLoc(ReadSourceLocation(Record, Idx));
1154   S->setRParenLoc(ReadSourceLocation(Record, Idx));
1155   S->setRangeStmt(Reader.ReadSubStmt());
1156   S->setBeginEndStmt(Reader.ReadSubStmt());
1157   S->setCond(Reader.ReadSubExpr());
1158   S->setInc(Reader.ReadSubExpr());
1159   S->setLoopVarStmt(Reader.ReadSubStmt());
1160   S->setBody(Reader.ReadSubStmt());
1161 }
1162
1163 void ASTStmtReader::VisitMSDependentExistsStmt(MSDependentExistsStmt *S) {
1164   VisitStmt(S);
1165   S->KeywordLoc = ReadSourceLocation(Record, Idx);
1166   S->IsIfExists = Record[Idx++];
1167   S->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1168   ReadDeclarationNameInfo(S->NameInfo, Record, Idx);
1169   S->SubStmt = Reader.ReadSubStmt();
1170 }
1171
1172 void ASTStmtReader::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
1173   VisitCallExpr(E);
1174   E->Operator = (OverloadedOperatorKind)Record[Idx++];
1175   E->Range = Reader.ReadSourceRange(F, Record, Idx);
1176   E->setFPContractable((bool)Record[Idx++]);
1177 }
1178
1179 void ASTStmtReader::VisitCXXConstructExpr(CXXConstructExpr *E) {
1180   VisitExpr(E);
1181   E->NumArgs = Record[Idx++];
1182   if (E->NumArgs)
1183     E->Args = new (Reader.getContext()) Stmt*[E->NumArgs];
1184   for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
1185     E->setArg(I, Reader.ReadSubExpr());
1186   E->setConstructor(ReadDeclAs<CXXConstructorDecl>(Record, Idx));
1187   E->setLocation(ReadSourceLocation(Record, Idx));
1188   E->setElidable(Record[Idx++]);
1189   E->setHadMultipleCandidates(Record[Idx++]);
1190   E->setListInitialization(Record[Idx++]);
1191   E->setRequiresZeroInitialization(Record[Idx++]);
1192   E->setConstructionKind((CXXConstructExpr::ConstructionKind)Record[Idx++]);
1193   E->ParenRange = ReadSourceRange(Record, Idx);
1194 }
1195
1196 void ASTStmtReader::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E) {
1197   VisitCXXConstructExpr(E);
1198   E->Type = GetTypeSourceInfo(Record, Idx);
1199 }
1200
1201 void ASTStmtReader::VisitLambdaExpr(LambdaExpr *E) {
1202   VisitExpr(E);
1203   unsigned NumCaptures = Record[Idx++];
1204   assert(NumCaptures == E->NumCaptures);(void)NumCaptures;
1205   unsigned NumArrayIndexVars = Record[Idx++];
1206   E->IntroducerRange = ReadSourceRange(Record, Idx);
1207   E->CaptureDefault = static_cast<LambdaCaptureDefault>(Record[Idx++]);
1208   E->ExplicitParams = Record[Idx++];
1209   E->ExplicitResultType = Record[Idx++];
1210   E->ClosingBrace = ReadSourceLocation(Record, Idx);
1211
1212   // Read capture initializers.
1213   for (LambdaExpr::capture_init_iterator C = E->capture_init_begin(),
1214                                       CEnd = E->capture_init_end();
1215        C != CEnd; ++C)
1216     *C = Reader.ReadSubExpr();
1217
1218   // Read array capture index variables.
1219   if (NumArrayIndexVars > 0) {
1220     unsigned *ArrayIndexStarts = E->getArrayIndexStarts();
1221     for (unsigned I = 0; I != NumCaptures + 1; ++I)
1222       ArrayIndexStarts[I] = Record[Idx++];
1223
1224     VarDecl **ArrayIndexVars = E->getArrayIndexVars();
1225     for (unsigned I = 0; I != NumArrayIndexVars; ++I)
1226       ArrayIndexVars[I] = ReadDeclAs<VarDecl>(Record, Idx);
1227   }
1228 }
1229
1230 void ASTStmtReader::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) {
1231   VisitExplicitCastExpr(E);
1232   SourceRange R = ReadSourceRange(Record, Idx);
1233   E->Loc = R.getBegin();
1234   E->RParenLoc = R.getEnd();
1235   R = ReadSourceRange(Record, Idx);
1236   E->AngleBrackets = R;
1237 }
1238
1239 void ASTStmtReader::VisitCXXStaticCastExpr(CXXStaticCastExpr *E) {
1240   return VisitCXXNamedCastExpr(E);
1241 }
1242
1243 void ASTStmtReader::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *E) {
1244   return VisitCXXNamedCastExpr(E);
1245 }
1246
1247 void ASTStmtReader::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *E) {
1248   return VisitCXXNamedCastExpr(E);
1249 }
1250
1251 void ASTStmtReader::VisitCXXConstCastExpr(CXXConstCastExpr *E) {
1252   return VisitCXXNamedCastExpr(E);
1253 }
1254
1255 void ASTStmtReader::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E) {
1256   VisitExplicitCastExpr(E);
1257   E->setTypeBeginLoc(ReadSourceLocation(Record, Idx));
1258   E->setRParenLoc(ReadSourceLocation(Record, Idx));
1259 }
1260
1261 void ASTStmtReader::VisitUserDefinedLiteral(UserDefinedLiteral *E) {
1262   VisitCallExpr(E);
1263   E->UDSuffixLoc = ReadSourceLocation(Record, Idx);
1264 }
1265
1266 void ASTStmtReader::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
1267   VisitExpr(E);
1268   E->setValue(Record[Idx++]);
1269   E->setLocation(ReadSourceLocation(Record, Idx));
1270 }
1271
1272 void ASTStmtReader::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) {
1273   VisitExpr(E);
1274   E->setLocation(ReadSourceLocation(Record, Idx));
1275 }
1276
1277 void ASTStmtReader::VisitCXXTypeidExpr(CXXTypeidExpr *E) {
1278   VisitExpr(E);
1279   E->setSourceRange(ReadSourceRange(Record, Idx));
1280   if (E->isTypeOperand()) { // typeid(int)
1281     E->setTypeOperandSourceInfo(
1282         GetTypeSourceInfo(Record, Idx));
1283     return;
1284   }
1285
1286   // typeid(42+2)
1287   E->setExprOperand(Reader.ReadSubExpr());
1288 }
1289
1290 void ASTStmtReader::VisitCXXThisExpr(CXXThisExpr *E) {
1291   VisitExpr(E);
1292   E->setLocation(ReadSourceLocation(Record, Idx));
1293   E->setImplicit(Record[Idx++]);
1294 }
1295
1296 void ASTStmtReader::VisitCXXThrowExpr(CXXThrowExpr *E) {
1297   VisitExpr(E);
1298   E->ThrowLoc = ReadSourceLocation(Record, Idx);
1299   E->Op = Reader.ReadSubExpr();
1300   E->IsThrownVariableInScope = Record[Idx++];
1301 }
1302
1303 void ASTStmtReader::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
1304   VisitExpr(E);
1305
1306   assert((bool)Record[Idx] == E->Param.getInt() && "We messed up at creation ?");
1307   ++Idx; // HasOtherExprStored and SubExpr was handled during creation.
1308   E->Param.setPointer(ReadDeclAs<ParmVarDecl>(Record, Idx));
1309   E->Loc = ReadSourceLocation(Record, Idx);
1310 }
1311
1312 void ASTStmtReader::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E) {
1313   VisitExpr(E);
1314   E->Field = ReadDeclAs<FieldDecl>(Record, Idx);
1315   E->Loc = ReadSourceLocation(Record, Idx);
1316 }
1317
1318 void ASTStmtReader::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
1319   VisitExpr(E);
1320   E->setTemporary(Reader.ReadCXXTemporary(F, Record, Idx));
1321   E->setSubExpr(Reader.ReadSubExpr());
1322 }
1323
1324 void ASTStmtReader::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
1325   VisitExpr(E);
1326   E->TypeInfo = GetTypeSourceInfo(Record, Idx);
1327   E->RParenLoc = ReadSourceLocation(Record, Idx);
1328 }
1329
1330 void ASTStmtReader::VisitCXXNewExpr(CXXNewExpr *E) {
1331   VisitExpr(E);
1332   E->GlobalNew = Record[Idx++];
1333   bool isArray = Record[Idx++];
1334   E->UsualArrayDeleteWantsSize = Record[Idx++];
1335   unsigned NumPlacementArgs = Record[Idx++];
1336   E->StoredInitializationStyle = Record[Idx++];
1337   E->setOperatorNew(ReadDeclAs<FunctionDecl>(Record, Idx));
1338   E->setOperatorDelete(ReadDeclAs<FunctionDecl>(Record, Idx));
1339   E->AllocatedTypeInfo = GetTypeSourceInfo(Record, Idx);
1340   E->TypeIdParens = ReadSourceRange(Record, Idx);
1341   E->Range = ReadSourceRange(Record, Idx);
1342   E->DirectInitRange = ReadSourceRange(Record, Idx);
1343
1344   E->AllocateArgsArray(Reader.getContext(), isArray, NumPlacementArgs,
1345                        E->StoredInitializationStyle != 0);
1346
1347   // Install all the subexpressions.
1348   for (CXXNewExpr::raw_arg_iterator I = E->raw_arg_begin(),e = E->raw_arg_end();
1349        I != e; ++I)
1350     *I = Reader.ReadSubStmt();
1351 }
1352
1353 void ASTStmtReader::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
1354   VisitExpr(E);
1355   E->GlobalDelete = Record[Idx++];
1356   E->ArrayForm = Record[Idx++];
1357   E->ArrayFormAsWritten = Record[Idx++];
1358   E->UsualArrayDeleteWantsSize = Record[Idx++];
1359   E->OperatorDelete = ReadDeclAs<FunctionDecl>(Record, Idx);
1360   E->Argument = Reader.ReadSubExpr();
1361   E->Loc = ReadSourceLocation(Record, Idx);
1362 }
1363
1364 void ASTStmtReader::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) {
1365   VisitExpr(E);
1366
1367   E->Base = Reader.ReadSubExpr();
1368   E->IsArrow = Record[Idx++];
1369   E->OperatorLoc = ReadSourceLocation(Record, Idx);
1370   E->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1371   E->ScopeType = GetTypeSourceInfo(Record, Idx);
1372   E->ColonColonLoc = ReadSourceLocation(Record, Idx);
1373   E->TildeLoc = ReadSourceLocation(Record, Idx);
1374
1375   IdentifierInfo *II = Reader.GetIdentifierInfo(F, Record, Idx);
1376   if (II)
1377     E->setDestroyedType(II, ReadSourceLocation(Record, Idx));
1378   else
1379     E->setDestroyedType(GetTypeSourceInfo(Record, Idx));
1380 }
1381
1382 void ASTStmtReader::VisitExprWithCleanups(ExprWithCleanups *E) {
1383   VisitExpr(E);
1384
1385   unsigned NumObjects = Record[Idx++];
1386   assert(NumObjects == E->getNumObjects());
1387   for (unsigned i = 0; i != NumObjects; ++i)
1388     E->getObjectsBuffer()[i] = ReadDeclAs<BlockDecl>(Record, Idx);
1389
1390   E->SubExpr = Reader.ReadSubExpr();
1391 }
1392
1393 void
1394 ASTStmtReader::VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E){
1395   VisitExpr(E);
1396
1397   if (Record[Idx++]) // HasTemplateKWAndArgsInfo
1398     ReadTemplateKWAndArgsInfo(*E->getTemplateKWAndArgsInfo(),
1399                               /*NumTemplateArgs=*/Record[Idx++]);
1400
1401   E->Base = Reader.ReadSubExpr();
1402   E->BaseType = Reader.readType(F, Record, Idx);
1403   E->IsArrow = Record[Idx++];
1404   E->OperatorLoc = ReadSourceLocation(Record, Idx);
1405   E->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1406   E->FirstQualifierFoundInScope = ReadDeclAs<NamedDecl>(Record, Idx);
1407   ReadDeclarationNameInfo(E->MemberNameInfo, Record, Idx);
1408 }
1409
1410 void
1411 ASTStmtReader::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) {
1412   VisitExpr(E);
1413
1414   if (Record[Idx++]) // HasTemplateKWAndArgsInfo
1415     ReadTemplateKWAndArgsInfo(*E->getTemplateKWAndArgsInfo(),
1416                               /*NumTemplateArgs=*/Record[Idx++]);
1417
1418   E->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1419   ReadDeclarationNameInfo(E->NameInfo, Record, Idx);
1420 }
1421
1422 void
1423 ASTStmtReader::VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E) {
1424   VisitExpr(E);
1425   assert(Record[Idx] == E->arg_size() && "Read wrong record during creation ?");
1426   ++Idx; // NumArgs;
1427   for (unsigned I = 0, N = E->arg_size(); I != N; ++I)
1428     E->setArg(I, Reader.ReadSubExpr());
1429   E->Type = GetTypeSourceInfo(Record, Idx);
1430   E->setLParenLoc(ReadSourceLocation(Record, Idx));
1431   E->setRParenLoc(ReadSourceLocation(Record, Idx));
1432 }
1433
1434 void ASTStmtReader::VisitOverloadExpr(OverloadExpr *E) {
1435   VisitExpr(E);
1436
1437   if (Record[Idx++]) // HasTemplateKWAndArgsInfo
1438     ReadTemplateKWAndArgsInfo(*E->getTemplateKWAndArgsInfo(),
1439                               /*NumTemplateArgs=*/Record[Idx++]);
1440
1441   unsigned NumDecls = Record[Idx++];
1442   UnresolvedSet<8> Decls;
1443   for (unsigned i = 0; i != NumDecls; ++i) {
1444     NamedDecl *D = ReadDeclAs<NamedDecl>(Record, Idx);
1445     AccessSpecifier AS = (AccessSpecifier)Record[Idx++];
1446     Decls.addDecl(D, AS);
1447   }
1448   E->initializeResults(Reader.getContext(), Decls.begin(), Decls.end());
1449
1450   ReadDeclarationNameInfo(E->NameInfo, Record, Idx);
1451   E->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1452 }
1453
1454 void ASTStmtReader::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) {
1455   VisitOverloadExpr(E);
1456   E->IsArrow = Record[Idx++];
1457   E->HasUnresolvedUsing = Record[Idx++];
1458   E->Base = Reader.ReadSubExpr();
1459   E->BaseType = Reader.readType(F, Record, Idx);
1460   E->OperatorLoc = ReadSourceLocation(Record, Idx);
1461 }
1462
1463 void ASTStmtReader::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) {
1464   VisitOverloadExpr(E);
1465   E->RequiresADL = Record[Idx++];
1466   E->Overloaded = Record[Idx++];
1467   E->NamingClass = ReadDeclAs<CXXRecordDecl>(Record, Idx);
1468 }
1469
1470 void ASTStmtReader::VisitUnaryTypeTraitExpr(UnaryTypeTraitExpr *E) {
1471   VisitExpr(E);
1472   E->UTT = (UnaryTypeTrait)Record[Idx++];
1473   E->Value = (bool)Record[Idx++];
1474   SourceRange Range = ReadSourceRange(Record, Idx);
1475   E->Loc = Range.getBegin();
1476   E->RParen = Range.getEnd();
1477   E->QueriedType = GetTypeSourceInfo(Record, Idx);
1478 }
1479
1480 void ASTStmtReader::VisitBinaryTypeTraitExpr(BinaryTypeTraitExpr *E) {
1481   VisitExpr(E);
1482   E->BTT = (BinaryTypeTrait)Record[Idx++];
1483   E->Value = (bool)Record[Idx++];
1484   SourceRange Range = ReadSourceRange(Record, Idx);
1485   E->Loc = Range.getBegin();
1486   E->RParen = Range.getEnd();
1487   E->LhsType = GetTypeSourceInfo(Record, Idx);
1488   E->RhsType = GetTypeSourceInfo(Record, Idx);
1489 }
1490
1491 void ASTStmtReader::VisitTypeTraitExpr(TypeTraitExpr *E) {
1492   VisitExpr(E);
1493   E->TypeTraitExprBits.NumArgs = Record[Idx++];
1494   E->TypeTraitExprBits.Kind = Record[Idx++];
1495   E->TypeTraitExprBits.Value = Record[Idx++];
1496
1497   TypeSourceInfo **Args = E->getTypeSourceInfos();
1498   for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
1499     Args[I] = GetTypeSourceInfo(Record, Idx);
1500 }
1501
1502 void ASTStmtReader::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
1503   VisitExpr(E);
1504   E->ATT = (ArrayTypeTrait)Record[Idx++];
1505   E->Value = (unsigned int)Record[Idx++];
1506   SourceRange Range = ReadSourceRange(Record, Idx);
1507   E->Loc = Range.getBegin();
1508   E->RParen = Range.getEnd();
1509   E->QueriedType = GetTypeSourceInfo(Record, Idx);
1510 }
1511
1512 void ASTStmtReader::VisitExpressionTraitExpr(ExpressionTraitExpr *E) {
1513   VisitExpr(E);
1514   E->ET = (ExpressionTrait)Record[Idx++];
1515   E->Value = (bool)Record[Idx++];
1516   SourceRange Range = ReadSourceRange(Record, Idx);
1517   E->QueriedExpression = Reader.ReadSubExpr();
1518   E->Loc = Range.getBegin();
1519   E->RParen = Range.getEnd();
1520 }
1521
1522 void ASTStmtReader::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) {
1523   VisitExpr(E);
1524   E->Value = (bool)Record[Idx++];
1525   E->Range = ReadSourceRange(Record, Idx);
1526   E->Operand = Reader.ReadSubExpr();
1527 }
1528
1529 void ASTStmtReader::VisitPackExpansionExpr(PackExpansionExpr *E) {
1530   VisitExpr(E);
1531   E->EllipsisLoc = ReadSourceLocation(Record, Idx);
1532   E->NumExpansions = Record[Idx++];
1533   E->Pattern = Reader.ReadSubExpr();
1534 }
1535
1536 void ASTStmtReader::VisitSizeOfPackExpr(SizeOfPackExpr *E) {
1537   VisitExpr(E);
1538   E->OperatorLoc = ReadSourceLocation(Record, Idx);
1539   E->PackLoc = ReadSourceLocation(Record, Idx);
1540   E->RParenLoc = ReadSourceLocation(Record, Idx);
1541   E->Length = Record[Idx++];
1542   E->Pack = ReadDeclAs<NamedDecl>(Record, Idx);
1543 }
1544
1545 void ASTStmtReader::VisitSubstNonTypeTemplateParmExpr(
1546                                               SubstNonTypeTemplateParmExpr *E) {
1547   VisitExpr(E);
1548   E->Param = ReadDeclAs<NonTypeTemplateParmDecl>(Record, Idx);
1549   E->NameLoc = ReadSourceLocation(Record, Idx);
1550   E->Replacement = Reader.ReadSubExpr();
1551 }
1552
1553 void ASTStmtReader::VisitSubstNonTypeTemplateParmPackExpr(
1554                                           SubstNonTypeTemplateParmPackExpr *E) {
1555   VisitExpr(E);
1556   E->Param = ReadDeclAs<NonTypeTemplateParmDecl>(Record, Idx);
1557   TemplateArgument ArgPack = Reader.ReadTemplateArgument(F, Record, Idx);
1558   if (ArgPack.getKind() != TemplateArgument::Pack)
1559     return;
1560
1561   E->Arguments = ArgPack.pack_begin();
1562   E->NumArguments = ArgPack.pack_size();
1563   E->NameLoc = ReadSourceLocation(Record, Idx);
1564 }
1565
1566 void ASTStmtReader::VisitFunctionParmPackExpr(FunctionParmPackExpr *E) {
1567   VisitExpr(E);
1568   E->NumParameters = Record[Idx++];
1569   E->ParamPack = ReadDeclAs<ParmVarDecl>(Record, Idx);
1570   E->NameLoc = ReadSourceLocation(Record, Idx);
1571   ParmVarDecl **Parms = reinterpret_cast<ParmVarDecl**>(E+1);
1572   for (unsigned i = 0, n = E->NumParameters; i != n; ++i)
1573     Parms[i] = ReadDeclAs<ParmVarDecl>(Record, Idx);
1574 }
1575
1576 void ASTStmtReader::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) {
1577   VisitExpr(E);
1578   E->Temporary = Reader.ReadSubExpr();
1579 }
1580
1581 void ASTStmtReader::VisitOpaqueValueExpr(OpaqueValueExpr *E) {
1582   VisitExpr(E);
1583   E->SourceExpr = Reader.ReadSubExpr();
1584   E->Loc = ReadSourceLocation(Record, Idx);
1585 }
1586
1587 //===----------------------------------------------------------------------===//
1588 // Microsoft Expressions and Statements
1589 //===----------------------------------------------------------------------===//
1590 void ASTStmtReader::VisitMSPropertyRefExpr(MSPropertyRefExpr *E) {
1591   VisitExpr(E);
1592   E->IsArrow = (Record[Idx++] != 0);
1593   E->BaseExpr = Reader.ReadSubExpr();
1594   E->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1595   E->MemberLoc = ReadSourceLocation(Record, Idx);
1596   E->TheDecl = ReadDeclAs<MSPropertyDecl>(Record, Idx);
1597 }
1598
1599 void ASTStmtReader::VisitCXXUuidofExpr(CXXUuidofExpr *E) {
1600   VisitExpr(E);
1601   E->setSourceRange(ReadSourceRange(Record, Idx));
1602   if (E->isTypeOperand()) { // __uuidof(ComType)
1603     E->setTypeOperandSourceInfo(
1604         GetTypeSourceInfo(Record, Idx));
1605     return;
1606   }
1607
1608   // __uuidof(expr)
1609   E->setExprOperand(Reader.ReadSubExpr());
1610 }
1611
1612 void ASTStmtReader::VisitSEHExceptStmt(SEHExceptStmt *S) {
1613   VisitStmt(S);
1614   S->Loc = ReadSourceLocation(Record, Idx);
1615   S->Children[SEHExceptStmt::FILTER_EXPR] = Reader.ReadSubStmt();
1616   S->Children[SEHExceptStmt::BLOCK] = Reader.ReadSubStmt();
1617 }
1618
1619 void ASTStmtReader::VisitSEHFinallyStmt(SEHFinallyStmt *S) {
1620   VisitStmt(S);
1621   S->Loc = ReadSourceLocation(Record, Idx);
1622   S->Block = Reader.ReadSubStmt();
1623 }
1624
1625 void ASTStmtReader::VisitSEHTryStmt(SEHTryStmt *S) {
1626   VisitStmt(S);
1627   S->IsCXXTry = Record[Idx++];
1628   S->TryLoc = ReadSourceLocation(Record, Idx);
1629   S->Children[SEHTryStmt::TRY] = Reader.ReadSubStmt();
1630   S->Children[SEHTryStmt::HANDLER] = Reader.ReadSubStmt();
1631 }
1632
1633 //===----------------------------------------------------------------------===//
1634 // CUDA Expressions and Statements
1635 //===----------------------------------------------------------------------===//
1636
1637 void ASTStmtReader::VisitCUDAKernelCallExpr(CUDAKernelCallExpr *E) {
1638   VisitCallExpr(E);
1639   E->setConfig(cast<CallExpr>(Reader.ReadSubExpr()));
1640 }
1641
1642 //===----------------------------------------------------------------------===//
1643 // OpenCL Expressions and Statements.
1644 //===----------------------------------------------------------------------===//
1645 void ASTStmtReader::VisitAsTypeExpr(AsTypeExpr *E) {
1646   VisitExpr(E);
1647   E->BuiltinLoc = ReadSourceLocation(Record, Idx);
1648   E->RParenLoc = ReadSourceLocation(Record, Idx);
1649   E->SrcExpr = Reader.ReadSubExpr();
1650 }
1651
1652 //===----------------------------------------------------------------------===//
1653 // ASTReader Implementation
1654 //===----------------------------------------------------------------------===//
1655
1656 Stmt *ASTReader::ReadStmt(ModuleFile &F) {
1657   switch (ReadingKind) {
1658   case Read_Decl:
1659   case Read_Type:
1660     return ReadStmtFromStream(F);
1661   case Read_Stmt:
1662     return ReadSubStmt();
1663   }
1664
1665   llvm_unreachable("ReadingKind not set ?");
1666 }
1667
1668 Expr *ASTReader::ReadExpr(ModuleFile &F) {
1669   return cast_or_null<Expr>(ReadStmt(F));
1670 }
1671
1672 Expr *ASTReader::ReadSubExpr() {
1673   return cast_or_null<Expr>(ReadSubStmt());
1674 }
1675
1676 // Within the bitstream, expressions are stored in Reverse Polish
1677 // Notation, with each of the subexpressions preceding the
1678 // expression they are stored in. Subexpressions are stored from last to first.
1679 // To evaluate expressions, we continue reading expressions and placing them on
1680 // the stack, with expressions having operands removing those operands from the
1681 // stack. Evaluation terminates when we see a STMT_STOP record, and
1682 // the single remaining expression on the stack is our result.
1683 Stmt *ASTReader::ReadStmtFromStream(ModuleFile &F) {
1684
1685   ReadingKindTracker ReadingKind(Read_Stmt, *this);
1686   llvm::BitstreamCursor &Cursor = F.DeclsCursor;
1687
1688   // Map of offset to previously deserialized stmt. The offset points
1689   /// just after the stmt record.
1690   llvm::DenseMap<uint64_t, Stmt *> StmtEntries;
1691
1692 #ifndef NDEBUG
1693   unsigned PrevNumStmts = StmtStack.size();
1694 #endif
1695
1696   RecordData Record;
1697   unsigned Idx;
1698   ASTStmtReader Reader(*this, F, Cursor, Record, Idx);
1699   Stmt::EmptyShell Empty;
1700
1701   while (true) {
1702     llvm::BitstreamEntry Entry = Cursor.advanceSkippingSubblocks();
1703
1704     switch (Entry.Kind) {
1705     case llvm::BitstreamEntry::SubBlock: // Handled for us already.
1706     case llvm::BitstreamEntry::Error:
1707       Error("malformed block record in AST file");
1708       return 0;
1709     case llvm::BitstreamEntry::EndBlock:
1710       goto Done;
1711     case llvm::BitstreamEntry::Record:
1712       // The interesting case.
1713       break;
1714     }
1715
1716
1717     Stmt *S = 0;
1718     Idx = 0;
1719     Record.clear();
1720     bool Finished = false;
1721     bool IsStmtReference = false;
1722     switch ((StmtCode)Cursor.readRecord(Entry.ID, Record)) {
1723     case STMT_STOP:
1724       Finished = true;
1725       break;
1726
1727     case STMT_REF_PTR:
1728       IsStmtReference = true;
1729       assert(StmtEntries.find(Record[0]) != StmtEntries.end() &&
1730              "No stmt was recorded for this offset reference!");
1731       S = StmtEntries[Record[Idx++]];
1732       break;
1733
1734     case STMT_NULL_PTR:
1735       S = 0;
1736       break;
1737
1738     case STMT_NULL:
1739       S = new (Context) NullStmt(Empty);
1740       break;
1741
1742     case STMT_COMPOUND:
1743       S = new (Context) CompoundStmt(Empty);
1744       break;
1745
1746     case STMT_CASE:
1747       S = new (Context) CaseStmt(Empty);
1748       break;
1749
1750     case STMT_DEFAULT:
1751       S = new (Context) DefaultStmt(Empty);
1752       break;
1753
1754     case STMT_LABEL:
1755       S = new (Context) LabelStmt(Empty);
1756       break;
1757
1758     case STMT_ATTRIBUTED:
1759       S = AttributedStmt::CreateEmpty(
1760         Context,
1761         /*NumAttrs*/Record[ASTStmtReader::NumStmtFields]);
1762       break;
1763
1764     case STMT_IF:
1765       S = new (Context) IfStmt(Empty);
1766       break;
1767
1768     case STMT_SWITCH:
1769       S = new (Context) SwitchStmt(Empty);
1770       break;
1771
1772     case STMT_WHILE:
1773       S = new (Context) WhileStmt(Empty);
1774       break;
1775
1776     case STMT_DO:
1777       S = new (Context) DoStmt(Empty);
1778       break;
1779
1780     case STMT_FOR:
1781       S = new (Context) ForStmt(Empty);
1782       break;
1783
1784     case STMT_GOTO:
1785       S = new (Context) GotoStmt(Empty);
1786       break;
1787
1788     case STMT_INDIRECT_GOTO:
1789       S = new (Context) IndirectGotoStmt(Empty);
1790       break;
1791
1792     case STMT_CONTINUE:
1793       S = new (Context) ContinueStmt(Empty);
1794       break;
1795
1796     case STMT_BREAK:
1797       S = new (Context) BreakStmt(Empty);
1798       break;
1799
1800     case STMT_RETURN:
1801       S = new (Context) ReturnStmt(Empty);
1802       break;
1803
1804     case STMT_DECL:
1805       S = new (Context) DeclStmt(Empty);
1806       break;
1807
1808     case STMT_GCCASM:
1809       S = new (Context) GCCAsmStmt(Empty);
1810       break;
1811
1812     case STMT_MSASM:
1813       S = new (Context) MSAsmStmt(Empty);
1814       break;
1815
1816     case STMT_CAPTURED:
1817       S = CapturedStmt::CreateDeserialized(Context,
1818                                            Record[ASTStmtReader::NumExprFields]);
1819       break;
1820
1821     case EXPR_PREDEFINED:
1822       S = new (Context) PredefinedExpr(Empty);
1823       break;
1824
1825     case EXPR_DECL_REF:
1826       S = DeclRefExpr::CreateEmpty(
1827         Context,
1828         /*HasQualifier=*/Record[ASTStmtReader::NumExprFields],
1829         /*HasFoundDecl=*/Record[ASTStmtReader::NumExprFields + 1],
1830         /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields + 2],
1831         /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields + 2] ?
1832           Record[ASTStmtReader::NumExprFields + 5] : 0);
1833       break;
1834
1835     case EXPR_INTEGER_LITERAL:
1836       S = IntegerLiteral::Create(Context, Empty);
1837       break;
1838
1839     case EXPR_FLOATING_LITERAL:
1840       S = FloatingLiteral::Create(Context, Empty);
1841       break;
1842
1843     case EXPR_IMAGINARY_LITERAL:
1844       S = new (Context) ImaginaryLiteral(Empty);
1845       break;
1846
1847     case EXPR_STRING_LITERAL:
1848       S = StringLiteral::CreateEmpty(Context,
1849                                      Record[ASTStmtReader::NumExprFields + 1]);
1850       break;
1851
1852     case EXPR_CHARACTER_LITERAL:
1853       S = new (Context) CharacterLiteral(Empty);
1854       break;
1855
1856     case EXPR_PAREN:
1857       S = new (Context) ParenExpr(Empty);
1858       break;
1859
1860     case EXPR_PAREN_LIST:
1861       S = new (Context) ParenListExpr(Empty);
1862       break;
1863
1864     case EXPR_UNARY_OPERATOR:
1865       S = new (Context) UnaryOperator(Empty);
1866       break;
1867
1868     case EXPR_OFFSETOF:
1869       S = OffsetOfExpr::CreateEmpty(Context,
1870                                     Record[ASTStmtReader::NumExprFields],
1871                                     Record[ASTStmtReader::NumExprFields + 1]);
1872       break;
1873
1874     case EXPR_SIZEOF_ALIGN_OF:
1875       S = new (Context) UnaryExprOrTypeTraitExpr(Empty);
1876       break;
1877
1878     case EXPR_ARRAY_SUBSCRIPT:
1879       S = new (Context) ArraySubscriptExpr(Empty);
1880       break;
1881
1882     case EXPR_CALL:
1883       S = new (Context) CallExpr(Context, Stmt::CallExprClass, Empty);
1884       break;
1885
1886     case EXPR_MEMBER: {
1887       // We load everything here and fully initialize it at creation.
1888       // That way we can use MemberExpr::Create and don't have to duplicate its
1889       // logic with a MemberExpr::CreateEmpty.
1890
1891       assert(Idx == 0);
1892       NestedNameSpecifierLoc QualifierLoc;
1893       if (Record[Idx++]) { // HasQualifier.
1894         QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, Idx);
1895       }
1896
1897       SourceLocation TemplateKWLoc;
1898       TemplateArgumentListInfo ArgInfo;
1899       bool HasTemplateKWAndArgsInfo = Record[Idx++];
1900       if (HasTemplateKWAndArgsInfo) {
1901         TemplateKWLoc = ReadSourceLocation(F, Record, Idx);
1902         unsigned NumTemplateArgs = Record[Idx++];
1903         ArgInfo.setLAngleLoc(ReadSourceLocation(F, Record, Idx));
1904         ArgInfo.setRAngleLoc(ReadSourceLocation(F, Record, Idx));
1905         for (unsigned i = 0; i != NumTemplateArgs; ++i)
1906           ArgInfo.addArgument(ReadTemplateArgumentLoc(F, Record, Idx));
1907       }
1908
1909       bool HadMultipleCandidates = Record[Idx++];
1910
1911       NamedDecl *FoundD = ReadDeclAs<NamedDecl>(F, Record, Idx);
1912       AccessSpecifier AS = (AccessSpecifier)Record[Idx++];
1913       DeclAccessPair FoundDecl = DeclAccessPair::make(FoundD, AS);
1914
1915       QualType T = readType(F, Record, Idx);
1916       ExprValueKind VK = static_cast<ExprValueKind>(Record[Idx++]);
1917       ExprObjectKind OK = static_cast<ExprObjectKind>(Record[Idx++]);
1918       Expr *Base = ReadSubExpr();
1919       ValueDecl *MemberD = ReadDeclAs<ValueDecl>(F, Record, Idx);
1920       SourceLocation MemberLoc = ReadSourceLocation(F, Record, Idx);
1921       DeclarationNameInfo MemberNameInfo(MemberD->getDeclName(), MemberLoc);
1922       bool IsArrow = Record[Idx++];
1923
1924       S = MemberExpr::Create(Context, Base, IsArrow, QualifierLoc,
1925                              TemplateKWLoc, MemberD, FoundDecl, MemberNameInfo,
1926                              HasTemplateKWAndArgsInfo ? &ArgInfo : 0,
1927                              T, VK, OK);
1928       ReadDeclarationNameLoc(F, cast<MemberExpr>(S)->MemberDNLoc,
1929                              MemberD->getDeclName(), Record, Idx);
1930       if (HadMultipleCandidates)
1931         cast<MemberExpr>(S)->setHadMultipleCandidates(true);
1932       break;
1933     }
1934
1935     case EXPR_BINARY_OPERATOR:
1936       S = new (Context) BinaryOperator(Empty);
1937       break;
1938
1939     case EXPR_COMPOUND_ASSIGN_OPERATOR:
1940       S = new (Context) CompoundAssignOperator(Empty);
1941       break;
1942
1943     case EXPR_CONDITIONAL_OPERATOR:
1944       S = new (Context) ConditionalOperator(Empty);
1945       break;
1946
1947     case EXPR_BINARY_CONDITIONAL_OPERATOR:
1948       S = new (Context) BinaryConditionalOperator(Empty);
1949       break;
1950
1951     case EXPR_IMPLICIT_CAST:
1952       S = ImplicitCastExpr::CreateEmpty(Context,
1953                        /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
1954       break;
1955
1956     case EXPR_CSTYLE_CAST:
1957       S = CStyleCastExpr::CreateEmpty(Context,
1958                        /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
1959       break;
1960
1961     case EXPR_COMPOUND_LITERAL:
1962       S = new (Context) CompoundLiteralExpr(Empty);
1963       break;
1964
1965     case EXPR_EXT_VECTOR_ELEMENT:
1966       S = new (Context) ExtVectorElementExpr(Empty);
1967       break;
1968
1969     case EXPR_INIT_LIST:
1970       S = new (Context) InitListExpr(Empty);
1971       break;
1972
1973     case EXPR_DESIGNATED_INIT:
1974       S = DesignatedInitExpr::CreateEmpty(Context,
1975                                      Record[ASTStmtReader::NumExprFields] - 1);
1976
1977       break;
1978
1979     case EXPR_IMPLICIT_VALUE_INIT:
1980       S = new (Context) ImplicitValueInitExpr(Empty);
1981       break;
1982
1983     case EXPR_VA_ARG:
1984       S = new (Context) VAArgExpr(Empty);
1985       break;
1986
1987     case EXPR_ADDR_LABEL:
1988       S = new (Context) AddrLabelExpr(Empty);
1989       break;
1990
1991     case EXPR_STMT:
1992       S = new (Context) StmtExpr(Empty);
1993       break;
1994
1995     case EXPR_CHOOSE:
1996       S = new (Context) ChooseExpr(Empty);
1997       break;
1998
1999     case EXPR_GNU_NULL:
2000       S = new (Context) GNUNullExpr(Empty);
2001       break;
2002
2003     case EXPR_SHUFFLE_VECTOR:
2004       S = new (Context) ShuffleVectorExpr(Empty);
2005       break;
2006
2007     case EXPR_BLOCK:
2008       S = new (Context) BlockExpr(Empty);
2009       break;
2010
2011     case EXPR_GENERIC_SELECTION:
2012       S = new (Context) GenericSelectionExpr(Empty);
2013       break;
2014
2015     case EXPR_OBJC_STRING_LITERAL:
2016       S = new (Context) ObjCStringLiteral(Empty);
2017       break;
2018     case EXPR_OBJC_BOXED_EXPRESSION:
2019       S = new (Context) ObjCBoxedExpr(Empty);
2020       break;
2021     case EXPR_OBJC_ARRAY_LITERAL:
2022       S = ObjCArrayLiteral::CreateEmpty(Context,
2023                                         Record[ASTStmtReader::NumExprFields]);
2024       break;
2025     case EXPR_OBJC_DICTIONARY_LITERAL:
2026       S = ObjCDictionaryLiteral::CreateEmpty(Context,
2027             Record[ASTStmtReader::NumExprFields],
2028             Record[ASTStmtReader::NumExprFields + 1]);
2029       break;
2030     case EXPR_OBJC_ENCODE:
2031       S = new (Context) ObjCEncodeExpr(Empty);
2032       break;
2033     case EXPR_OBJC_SELECTOR_EXPR:
2034       S = new (Context) ObjCSelectorExpr(Empty);
2035       break;
2036     case EXPR_OBJC_PROTOCOL_EXPR:
2037       S = new (Context) ObjCProtocolExpr(Empty);
2038       break;
2039     case EXPR_OBJC_IVAR_REF_EXPR:
2040       S = new (Context) ObjCIvarRefExpr(Empty);
2041       break;
2042     case EXPR_OBJC_PROPERTY_REF_EXPR:
2043       S = new (Context) ObjCPropertyRefExpr(Empty);
2044       break;
2045     case EXPR_OBJC_SUBSCRIPT_REF_EXPR:
2046       S = new (Context) ObjCSubscriptRefExpr(Empty);
2047       break;
2048     case EXPR_OBJC_KVC_REF_EXPR:
2049       llvm_unreachable("mismatching AST file");
2050     case EXPR_OBJC_MESSAGE_EXPR:
2051       S = ObjCMessageExpr::CreateEmpty(Context,
2052                                      Record[ASTStmtReader::NumExprFields],
2053                                      Record[ASTStmtReader::NumExprFields + 1]);
2054       break;
2055     case EXPR_OBJC_ISA:
2056       S = new (Context) ObjCIsaExpr(Empty);
2057       break;
2058     case EXPR_OBJC_INDIRECT_COPY_RESTORE:
2059       S = new (Context) ObjCIndirectCopyRestoreExpr(Empty);
2060       break;
2061     case EXPR_OBJC_BRIDGED_CAST:
2062       S = new (Context) ObjCBridgedCastExpr(Empty);
2063       break;
2064     case STMT_OBJC_FOR_COLLECTION:
2065       S = new (Context) ObjCForCollectionStmt(Empty);
2066       break;
2067     case STMT_OBJC_CATCH:
2068       S = new (Context) ObjCAtCatchStmt(Empty);
2069       break;
2070     case STMT_OBJC_FINALLY:
2071       S = new (Context) ObjCAtFinallyStmt(Empty);
2072       break;
2073     case STMT_OBJC_AT_TRY:
2074       S = ObjCAtTryStmt::CreateEmpty(Context,
2075                                      Record[ASTStmtReader::NumStmtFields],
2076                                      Record[ASTStmtReader::NumStmtFields + 1]);
2077       break;
2078     case STMT_OBJC_AT_SYNCHRONIZED:
2079       S = new (Context) ObjCAtSynchronizedStmt(Empty);
2080       break;
2081     case STMT_OBJC_AT_THROW:
2082       S = new (Context) ObjCAtThrowStmt(Empty);
2083       break;
2084     case STMT_OBJC_AUTORELEASE_POOL:
2085       S = new (Context) ObjCAutoreleasePoolStmt(Empty);
2086       break;
2087     case EXPR_OBJC_BOOL_LITERAL:
2088       S = new (Context) ObjCBoolLiteralExpr(Empty);
2089       break;
2090     case STMT_SEH_EXCEPT:
2091       S = new (Context) SEHExceptStmt(Empty);
2092       break;
2093     case STMT_SEH_FINALLY:
2094       S = new (Context) SEHFinallyStmt(Empty);
2095       break;
2096     case STMT_SEH_TRY:
2097       S = new (Context) SEHTryStmt(Empty);
2098       break;
2099     case STMT_CXX_CATCH:
2100       S = new (Context) CXXCatchStmt(Empty);
2101       break;
2102
2103     case STMT_CXX_TRY:
2104       S = CXXTryStmt::Create(Context, Empty,
2105              /*NumHandlers=*/Record[ASTStmtReader::NumStmtFields]);
2106       break;
2107
2108     case STMT_CXX_FOR_RANGE:
2109       S = new (Context) CXXForRangeStmt(Empty);
2110       break;
2111
2112     case STMT_MS_DEPENDENT_EXISTS:
2113       S = new (Context) MSDependentExistsStmt(SourceLocation(), true,
2114                                               NestedNameSpecifierLoc(),
2115                                               DeclarationNameInfo(),
2116                                               0);
2117       break;
2118
2119     case EXPR_CXX_OPERATOR_CALL:
2120       S = new (Context) CXXOperatorCallExpr(Context, Empty);
2121       break;
2122
2123     case EXPR_CXX_MEMBER_CALL:
2124       S = new (Context) CXXMemberCallExpr(Context, Empty);
2125       break;
2126
2127     case EXPR_CXX_CONSTRUCT:
2128       S = new (Context) CXXConstructExpr(Empty);
2129       break;
2130
2131     case EXPR_CXX_TEMPORARY_OBJECT:
2132       S = new (Context) CXXTemporaryObjectExpr(Empty);
2133       break;
2134
2135     case EXPR_CXX_STATIC_CAST:
2136       S = CXXStaticCastExpr::CreateEmpty(Context,
2137                        /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
2138       break;
2139
2140     case EXPR_CXX_DYNAMIC_CAST:
2141       S = CXXDynamicCastExpr::CreateEmpty(Context,
2142                        /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
2143       break;
2144
2145     case EXPR_CXX_REINTERPRET_CAST:
2146       S = CXXReinterpretCastExpr::CreateEmpty(Context,
2147                        /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
2148       break;
2149
2150     case EXPR_CXX_CONST_CAST:
2151       S = CXXConstCastExpr::CreateEmpty(Context);
2152       break;
2153
2154     case EXPR_CXX_FUNCTIONAL_CAST:
2155       S = CXXFunctionalCastExpr::CreateEmpty(Context,
2156                        /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
2157       break;
2158
2159     case EXPR_USER_DEFINED_LITERAL:
2160       S = new (Context) UserDefinedLiteral(Context, Empty);
2161       break;
2162
2163     case EXPR_CXX_BOOL_LITERAL:
2164       S = new (Context) CXXBoolLiteralExpr(Empty);
2165       break;
2166
2167     case EXPR_CXX_NULL_PTR_LITERAL:
2168       S = new (Context) CXXNullPtrLiteralExpr(Empty);
2169       break;
2170     case EXPR_CXX_TYPEID_EXPR:
2171       S = new (Context) CXXTypeidExpr(Empty, true);
2172       break;
2173     case EXPR_CXX_TYPEID_TYPE:
2174       S = new (Context) CXXTypeidExpr(Empty, false);
2175       break;
2176     case EXPR_CXX_UUIDOF_EXPR:
2177       S = new (Context) CXXUuidofExpr(Empty, true);
2178       break;
2179     case EXPR_CXX_PROPERTY_REF_EXPR:
2180       S = new (Context) MSPropertyRefExpr(Empty);
2181       break;
2182     case EXPR_CXX_UUIDOF_TYPE:
2183       S = new (Context) CXXUuidofExpr(Empty, false);
2184       break;
2185     case EXPR_CXX_THIS:
2186       S = new (Context) CXXThisExpr(Empty);
2187       break;
2188     case EXPR_CXX_THROW:
2189       S = new (Context) CXXThrowExpr(Empty);
2190       break;
2191     case EXPR_CXX_DEFAULT_ARG: {
2192       bool HasOtherExprStored = Record[ASTStmtReader::NumExprFields];
2193       if (HasOtherExprStored) {
2194         Expr *SubExpr = ReadSubExpr();
2195         S = CXXDefaultArgExpr::Create(Context, SourceLocation(), 0, SubExpr);
2196       } else
2197         S = new (Context) CXXDefaultArgExpr(Empty);
2198       break;
2199     }
2200     case EXPR_CXX_DEFAULT_INIT:
2201       S = new (Context) CXXDefaultInitExpr(Empty);
2202       break;
2203     case EXPR_CXX_BIND_TEMPORARY:
2204       S = new (Context) CXXBindTemporaryExpr(Empty);
2205       break;
2206
2207     case EXPR_CXX_SCALAR_VALUE_INIT:
2208       S = new (Context) CXXScalarValueInitExpr(Empty);
2209       break;
2210     case EXPR_CXX_NEW:
2211       S = new (Context) CXXNewExpr(Empty);
2212       break;
2213     case EXPR_CXX_DELETE:
2214       S = new (Context) CXXDeleteExpr(Empty);
2215       break;
2216     case EXPR_CXX_PSEUDO_DESTRUCTOR:
2217       S = new (Context) CXXPseudoDestructorExpr(Empty);
2218       break;
2219
2220     case EXPR_EXPR_WITH_CLEANUPS:
2221       S = ExprWithCleanups::Create(Context, Empty,
2222                                    Record[ASTStmtReader::NumExprFields]);
2223       break;
2224
2225     case EXPR_CXX_DEPENDENT_SCOPE_MEMBER:
2226       S = CXXDependentScopeMemberExpr::CreateEmpty(Context,
2227          /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields],
2228                   /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]
2229                                    ? Record[ASTStmtReader::NumExprFields + 1]
2230                                    : 0);
2231       break;
2232
2233     case EXPR_CXX_DEPENDENT_SCOPE_DECL_REF:
2234       S = DependentScopeDeclRefExpr::CreateEmpty(Context,
2235          /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields],
2236                   /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]
2237                                    ? Record[ASTStmtReader::NumExprFields + 1]
2238                                    : 0);
2239       break;
2240
2241     case EXPR_CXX_UNRESOLVED_CONSTRUCT:
2242       S = CXXUnresolvedConstructExpr::CreateEmpty(Context,
2243                               /*NumArgs=*/Record[ASTStmtReader::NumExprFields]);
2244       break;
2245
2246     case EXPR_CXX_UNRESOLVED_MEMBER:
2247       S = UnresolvedMemberExpr::CreateEmpty(Context,
2248          /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields],
2249                   /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]
2250                                    ? Record[ASTStmtReader::NumExprFields + 1]
2251                                    : 0);
2252       break;
2253
2254     case EXPR_CXX_UNRESOLVED_LOOKUP:
2255       S = UnresolvedLookupExpr::CreateEmpty(Context,
2256          /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields],
2257                   /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]
2258                                    ? Record[ASTStmtReader::NumExprFields + 1]
2259                                    : 0);
2260       break;
2261
2262     case EXPR_CXX_UNARY_TYPE_TRAIT:
2263       S = new (Context) UnaryTypeTraitExpr(Empty);
2264       break;
2265
2266     case EXPR_BINARY_TYPE_TRAIT:
2267       S = new (Context) BinaryTypeTraitExpr(Empty);
2268       break;
2269
2270     case EXPR_TYPE_TRAIT:
2271       S = TypeTraitExpr::CreateDeserialized(Context,
2272             Record[ASTStmtReader::NumExprFields]);
2273       break;
2274
2275     case EXPR_ARRAY_TYPE_TRAIT:
2276       S = new (Context) ArrayTypeTraitExpr(Empty);
2277       break;
2278
2279     case EXPR_CXX_EXPRESSION_TRAIT:
2280       S = new (Context) ExpressionTraitExpr(Empty);
2281       break;
2282
2283     case EXPR_CXX_NOEXCEPT:
2284       S = new (Context) CXXNoexceptExpr(Empty);
2285       break;
2286
2287     case EXPR_PACK_EXPANSION:
2288       S = new (Context) PackExpansionExpr(Empty);
2289       break;
2290
2291     case EXPR_SIZEOF_PACK:
2292       S = new (Context) SizeOfPackExpr(Empty);
2293       break;
2294
2295     case EXPR_SUBST_NON_TYPE_TEMPLATE_PARM:
2296       S = new (Context) SubstNonTypeTemplateParmExpr(Empty);
2297       break;
2298
2299     case EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK:
2300       S = new (Context) SubstNonTypeTemplateParmPackExpr(Empty);
2301       break;
2302
2303     case EXPR_FUNCTION_PARM_PACK:
2304       S = FunctionParmPackExpr::CreateEmpty(Context,
2305                                           Record[ASTStmtReader::NumExprFields]);
2306       break;
2307
2308     case EXPR_MATERIALIZE_TEMPORARY:
2309       S = new (Context) MaterializeTemporaryExpr(Empty);
2310       break;
2311
2312     case EXPR_OPAQUE_VALUE:
2313       S = new (Context) OpaqueValueExpr(Empty);
2314       break;
2315
2316     case EXPR_CUDA_KERNEL_CALL:
2317       S = new (Context) CUDAKernelCallExpr(Context, Empty);
2318       break;
2319
2320     case EXPR_ASTYPE:
2321       S = new (Context) AsTypeExpr(Empty);
2322       break;
2323
2324     case EXPR_PSEUDO_OBJECT: {
2325       unsigned numSemanticExprs = Record[ASTStmtReader::NumExprFields];
2326       S = PseudoObjectExpr::Create(Context, Empty, numSemanticExprs);
2327       break;
2328     }
2329
2330     case EXPR_ATOMIC:
2331       S = new (Context) AtomicExpr(Empty);
2332       break;
2333
2334     case EXPR_LAMBDA: {
2335       unsigned NumCaptures = Record[ASTStmtReader::NumExprFields];
2336       unsigned NumArrayIndexVars = Record[ASTStmtReader::NumExprFields + 1];
2337       S = LambdaExpr::CreateDeserialized(Context, NumCaptures,
2338                                          NumArrayIndexVars);
2339       break;
2340     }
2341     }
2342
2343     // We hit a STMT_STOP, so we're done with this expression.
2344     if (Finished)
2345       break;
2346
2347     ++NumStatementsRead;
2348
2349     if (S && !IsStmtReference) {
2350       Reader.Visit(S);
2351       StmtEntries[Cursor.GetCurrentBitNo()] = S;
2352     }
2353
2354
2355     assert(Idx == Record.size() && "Invalid deserialization of statement");
2356     StmtStack.push_back(S);
2357   }
2358 Done:
2359   assert(StmtStack.size() > PrevNumStmts && "Read too many sub stmts!");
2360   assert(StmtStack.size() == PrevNumStmts + 1 && "Extra expressions on stack!");
2361   return StmtStack.pop_back_val();
2362 }