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