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