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/StmtVisitor.h"
  18 using namespace clang;
  19 using namespace clang::serialization;
  20
  21 namespace clang {
  22
  23   class ASTStmtReader : public StmtVisitor<ASTStmtReader> {
  24     ASTReader &Reader;
  25     ASTReader::PerFileData &F;
  26     llvm::BitstreamCursor &DeclsCursor;
  27     const ASTReader::RecordData &Record;
  28     unsigned &Idx;
  29
  30     SourceLocation ReadSourceLocation(const ASTReader::RecordData &R,
  31                                       unsigned &I) {
  32       return Reader.ReadSourceLocation(F, R, I);
  33     }
  34     SourceRange ReadSourceRange(const ASTReader::RecordData &R, unsigned &I) {
  35       return Reader.ReadSourceRange(F, R, I);
  36     }
  37     TypeSourceInfo *GetTypeSourceInfo(const ASTReader::RecordData &R,
  38                                       unsigned &I) {
  39       return Reader.GetTypeSourceInfo(F, R, I);
  40     }
  41     void ReadDeclarationNameLoc(DeclarationNameLoc &DNLoc, DeclarationName Name,
  42                                 const ASTReader::RecordData &R, unsigned &I) {
  43       Reader.ReadDeclarationNameLoc(F, DNLoc, Name, R, I);
  44     }
  45     void ReadDeclarationNameInfo(DeclarationNameInfo &NameInfo,
  46                                 const ASTReader::RecordData &R, unsigned &I) {
  47       Reader.ReadDeclarationNameInfo(F, NameInfo, R, I);
  48     }
  49
  50   public:
  51     ASTStmtReader(ASTReader &Reader, ASTReader::PerFileData &F,
  52                   llvm::BitstreamCursor &Cursor,
  53                   const ASTReader::RecordData &Record, unsigned &Idx)
  54       : Reader(Reader), F(F), DeclsCursor(Cursor), Record(Record), Idx(Idx) { }
  55
  56     /// \brief The number of record fields required for the Stmt class
  57     /// itself.
  58     static const unsigned NumStmtFields = 0;
  59
  60     /// \brief The number of record fields required for the Expr class
  61     /// itself.
  62     static const unsigned NumExprFields = NumStmtFields + 5;
  63
  64     /// \brief Read and initialize a ExplicitTemplateArgumentList structure.
  65     void ReadExplicitTemplateArgumentList(ExplicitTemplateArgumentList &ArgList,
  66                                           unsigned NumTemplateArgs);
  67
  68     void VisitStmt(Stmt *S);
  69     void VisitNullStmt(NullStmt *S);
  70     void VisitCompoundStmt(CompoundStmt *S);
  71     void VisitSwitchCase(SwitchCase *S);
  72     void VisitCaseStmt(CaseStmt *S);
  73     void VisitDefaultStmt(DefaultStmt *S);
  74     void VisitLabelStmt(LabelStmt *S);
  75     void VisitIfStmt(IfStmt *S);
  76     void VisitSwitchStmt(SwitchStmt *S);
  77     void VisitWhileStmt(WhileStmt *S);
  78     void VisitDoStmt(DoStmt *S);
  79     void VisitForStmt(ForStmt *S);
  80     void VisitGotoStmt(GotoStmt *S);
  81     void VisitIndirectGotoStmt(IndirectGotoStmt *S);
  82     void VisitContinueStmt(ContinueStmt *S);
  83     void VisitBreakStmt(BreakStmt *S);
  84     void VisitReturnStmt(ReturnStmt *S);
  85     void VisitDeclStmt(DeclStmt *S);
  86     void VisitAsmStmt(AsmStmt *S);
  87     void VisitExpr(Expr *E);
  88     void VisitPredefinedExpr(PredefinedExpr *E);
  89     void VisitDeclRefExpr(DeclRefExpr *E);
  90     void VisitIntegerLiteral(IntegerLiteral *E);
  91     void VisitFloatingLiteral(FloatingLiteral *E);
  92     void VisitImaginaryLiteral(ImaginaryLiteral *E);
  93     void VisitStringLiteral(StringLiteral *E);
  94     void VisitCharacterLiteral(CharacterLiteral *E);
  95     void VisitParenExpr(ParenExpr *E);
  96     void VisitParenListExpr(ParenListExpr *E);
  97     void VisitUnaryOperator(UnaryOperator *E);
  98     void VisitOffsetOfExpr(OffsetOfExpr *E);
  99     void VisitSizeOfAlignOfExpr(SizeOfAlignOfExpr *E);
 100     void VisitArraySubscriptExpr(ArraySubscriptExpr *E);
 101     void VisitCallExpr(CallExpr *E);
 102     void VisitMemberExpr(MemberExpr *E);
 103     void VisitCastExpr(CastExpr *E);
 104     void VisitBinaryOperator(BinaryOperator *E);
 105     void VisitCompoundAssignOperator(CompoundAssignOperator *E);
 106     void VisitConditionalOperator(ConditionalOperator *E);
 107     void VisitImplicitCastExpr(ImplicitCastExpr *E);
 108     void VisitExplicitCastExpr(ExplicitCastExpr *E);
 109     void VisitCStyleCastExpr(CStyleCastExpr *E);
 110     void VisitCompoundLiteralExpr(CompoundLiteralExpr *E);
 111     void VisitExtVectorElementExpr(ExtVectorElementExpr *E);
 112     void VisitInitListExpr(InitListExpr *E);
 113     void VisitDesignatedInitExpr(DesignatedInitExpr *E);
 114     void VisitImplicitValueInitExpr(ImplicitValueInitExpr *E);
 115     void VisitVAArgExpr(VAArgExpr *E);
 116     void VisitAddrLabelExpr(AddrLabelExpr *E);
 117     void VisitStmtExpr(StmtExpr *E);
 118     void VisitChooseExpr(ChooseExpr *E);
 119     void VisitGNUNullExpr(GNUNullExpr *E);
 120     void VisitShuffleVectorExpr(ShuffleVectorExpr *E);
 121     void VisitBlockExpr(BlockExpr *E);
 122     void VisitBlockDeclRefExpr(BlockDeclRefExpr *E);
 123     void VisitObjCStringLiteral(ObjCStringLiteral *E);
 124     void VisitObjCEncodeExpr(ObjCEncodeExpr *E);
 125     void VisitObjCSelectorExpr(ObjCSelectorExpr *E);
 126     void VisitObjCProtocolExpr(ObjCProtocolExpr *E);
 127     void VisitObjCIvarRefExpr(ObjCIvarRefExpr *E);
 128     void VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E);
 129     void VisitObjCMessageExpr(ObjCMessageExpr *E);
 130     void VisitObjCIsaExpr(ObjCIsaExpr *E);
 131
 132     void VisitObjCForCollectionStmt(ObjCForCollectionStmt *);
 133     void VisitObjCAtCatchStmt(ObjCAtCatchStmt *);
 134     void VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *);
 135     void VisitObjCAtTryStmt(ObjCAtTryStmt *);
 136     void VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *);
 137     void VisitObjCAtThrowStmt(ObjCAtThrowStmt *);
 138
 139     // C++ Statements
 140     void VisitCXXCatchStmt(CXXCatchStmt *S);
 141     void VisitCXXTryStmt(CXXTryStmt *S);
 142
 143     void VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E);
 144     void VisitCXXConstructExpr(CXXConstructExpr *E);
 145     void VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E);
 146     void VisitCXXNamedCastExpr(CXXNamedCastExpr *E);
 147     void VisitCXXStaticCastExpr(CXXStaticCastExpr *E);
 148     void VisitCXXDynamicCastExpr(CXXDynamicCastExpr *E);
 149     void VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *E);
 150     void VisitCXXConstCastExpr(CXXConstCastExpr *E);
 151     void VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E);
 152     void VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E);
 153     void VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E);
 154     void VisitCXXTypeidExpr(CXXTypeidExpr *E);
 155     void VisitCXXUuidofExpr(CXXUuidofExpr *E);
 156     void VisitCXXThisExpr(CXXThisExpr *E);
 157     void VisitCXXThrowExpr(CXXThrowExpr *E);
 158     void VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E);
 159     void VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E);
 160
 161     void VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E);
 162     void VisitCXXNewExpr(CXXNewExpr *E);
 163     void VisitCXXDeleteExpr(CXXDeleteExpr *E);
 164     void VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E);
 165
 166     void VisitExprWithCleanups(ExprWithCleanups *E);
 167
 168     void VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E);
 169     void VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E);
 170     void VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E);
 171
 172     void VisitOverloadExpr(OverloadExpr *E);
 173     void VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E);
 174     void VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E);
 175
 176     void VisitUnaryTypeTraitExpr(UnaryTypeTraitExpr *E);
 177     void VisitBinaryTypeTraitExpr(BinaryTypeTraitExpr *E);
 178     void VisitCXXNoexceptExpr(CXXNoexceptExpr *E);
 179
 180     void VisitOpaqueValueExpr(OpaqueValueExpr *E);
 181   };
 182 }
 183
 184 void ASTStmtReader::
 185 ReadExplicitTemplateArgumentList(ExplicitTemplateArgumentList &ArgList,
 186                                  unsigned NumTemplateArgs) {
 187   TemplateArgumentListInfo ArgInfo;
 188   ArgInfo.setLAngleLoc(ReadSourceLocation(Record, Idx));
 189   ArgInfo.setRAngleLoc(ReadSourceLocation(Record, Idx));
 190   for (unsigned i = 0; i != NumTemplateArgs; ++i)
 191     ArgInfo.addArgument(
 192         Reader.ReadTemplateArgumentLoc(F, Record, Idx));
 193   ArgList.initializeFrom(ArgInfo);
 194 }
 195
 196 void ASTStmtReader::VisitStmt(Stmt *S) {
 197   assert(Idx == NumStmtFields && "Incorrect statement field count");
 198 }
 199
 200 void ASTStmtReader::VisitNullStmt(NullStmt *S) {
 201   VisitStmt(S);
 202   S->setSemiLoc(ReadSourceLocation(Record, Idx));
 203   S->LeadingEmptyMacro = Record[Idx++];
 204 }
 205
 206 void ASTStmtReader::VisitCompoundStmt(CompoundStmt *S) {
 207   VisitStmt(S);
 208   llvm::SmallVector<Stmt *, 16> Stmts;
 209   unsigned NumStmts = Record[Idx++];
 210   while (NumStmts--)
 211     Stmts.push_back(Reader.ReadSubStmt());
 212   S->setStmts(*Reader.getContext(), Stmts.data(), Stmts.size());
 213   S->setLBracLoc(ReadSourceLocation(Record, Idx));
 214   S->setRBracLoc(ReadSourceLocation(Record, Idx));
 215 }
 216
 217 void ASTStmtReader::VisitSwitchCase(SwitchCase *S) {
 218   VisitStmt(S);
 219   Reader.RecordSwitchCaseID(S, Record[Idx++]);
 220 }
 221
 222 void ASTStmtReader::VisitCaseStmt(CaseStmt *S) {
 223   VisitSwitchCase(S);
 224   S->setLHS(Reader.ReadSubExpr());
 225   S->setRHS(Reader.ReadSubExpr());
 226   S->setSubStmt(Reader.ReadSubStmt());
 227   S->setCaseLoc(ReadSourceLocation(Record, Idx));
 228   S->setEllipsisLoc(ReadSourceLocation(Record, Idx));
 229   S->setColonLoc(ReadSourceLocation(Record, Idx));
 230 }
 231
 232 void ASTStmtReader::VisitDefaultStmt(DefaultStmt *S) {
 233   VisitSwitchCase(S);
 234   S->setSubStmt(Reader.ReadSubStmt());
 235   S->setDefaultLoc(ReadSourceLocation(Record, Idx));
 236   S->setColonLoc(ReadSourceLocation(Record, Idx));
 237 }
 238
 239 void ASTStmtReader::VisitLabelStmt(LabelStmt *S) {
 240   VisitStmt(S);
 241   S->setID(Reader.GetIdentifierInfo(Record, Idx));
 242   S->setSubStmt(Reader.ReadSubStmt());
 243   S->setIdentLoc(ReadSourceLocation(Record, Idx));
 244   S->setUsed(Record[Idx++]);
 245   S->setUnusedAttribute(Record[Idx++]);
 246   Reader.RecordLabelStmt(S, Record[Idx++]);
 247 }
 248
 249 void ASTStmtReader::VisitIfStmt(IfStmt *S) {
 250   VisitStmt(S);
 251   S->setConditionVariable(*Reader.getContext(),
 252                           cast_or_null<VarDecl>(Reader.GetDecl(Record[Idx++])));
 253   S->setCond(Reader.ReadSubExpr());
 254   S->setThen(Reader.ReadSubStmt());
 255   S->setElse(Reader.ReadSubStmt());
 256   S->setIfLoc(ReadSourceLocation(Record, Idx));
 257   S->setElseLoc(ReadSourceLocation(Record, Idx));
 258 }
 259
 260 void ASTStmtReader::VisitSwitchStmt(SwitchStmt *S) {
 261   VisitStmt(S);
 262   S->setConditionVariable(*Reader.getContext(),
 263                           cast_or_null<VarDecl>(Reader.GetDecl(Record[Idx++])));
 264   S->setCond(Reader.ReadSubExpr());
 265   S->setBody(Reader.ReadSubStmt());
 266   S->setSwitchLoc(ReadSourceLocation(Record, Idx));
 267   if (Record[Idx++])
 268     S->setAllEnumCasesCovered();
 269
 270   SwitchCase *PrevSC = 0;
 271   for (unsigned N = Record.size(); Idx != N; ++Idx) {
 272     SwitchCase *SC = Reader.getSwitchCaseWithID(Record[Idx]);
 273     if (PrevSC)
 274       PrevSC->setNextSwitchCase(SC);
 275     else
 276       S->setSwitchCaseList(SC);
 277
 278     PrevSC = SC;
 279   }
 280 }
 281
 282 void ASTStmtReader::VisitWhileStmt(WhileStmt *S) {
 283   VisitStmt(S);
 284   S->setConditionVariable(*Reader.getContext(),
 285                           cast_or_null<VarDecl>(Reader.GetDecl(Record[Idx++])));
 286   S->setCond(Reader.ReadSubExpr());
 287   S->setBody(Reader.ReadSubStmt());
 288   S->setWhileLoc(ReadSourceLocation(Record, Idx));
 289 }
 290
 291 void ASTStmtReader::VisitDoStmt(DoStmt *S) {
 292   VisitStmt(S);
 293   S->setCond(Reader.ReadSubExpr());
 294   S->setBody(Reader.ReadSubStmt());
 295   S->setDoLoc(ReadSourceLocation(Record, Idx));
 296   S->setWhileLoc(ReadSourceLocation(Record, Idx));
 297   S->setRParenLoc(ReadSourceLocation(Record, Idx));
 298 }
 299
 300 void ASTStmtReader::VisitForStmt(ForStmt *S) {
 301   VisitStmt(S);
 302   S->setInit(Reader.ReadSubStmt());
 303   S->setCond(Reader.ReadSubExpr());
 304   S->setConditionVariable(*Reader.getContext(),
 305                           cast_or_null<VarDecl>(Reader.GetDecl(Record[Idx++])));
 306   S->setInc(Reader.ReadSubExpr());
 307   S->setBody(Reader.ReadSubStmt());
 308   S->setForLoc(ReadSourceLocation(Record, Idx));
 309   S->setLParenLoc(ReadSourceLocation(Record, Idx));
 310   S->setRParenLoc(ReadSourceLocation(Record, Idx));
 311 }
 312
 313 void ASTStmtReader::VisitGotoStmt(GotoStmt *S) {
 314   VisitStmt(S);
 315   Reader.SetLabelOf(S, Record[Idx++]);
 316   S->setGotoLoc(ReadSourceLocation(Record, Idx));
 317   S->setLabelLoc(ReadSourceLocation(Record, Idx));
 318 }
 319
 320 void ASTStmtReader::VisitIndirectGotoStmt(IndirectGotoStmt *S) {
 321   VisitStmt(S);
 322   S->setGotoLoc(ReadSourceLocation(Record, Idx));
 323   S->setStarLoc(ReadSourceLocation(Record, Idx));
 324   S->setTarget(Reader.ReadSubExpr());
 325 }
 326
 327 void ASTStmtReader::VisitContinueStmt(ContinueStmt *S) {
 328   VisitStmt(S);
 329   S->setContinueLoc(ReadSourceLocation(Record, Idx));
 330 }
 331
 332 void ASTStmtReader::VisitBreakStmt(BreakStmt *S) {
 333   VisitStmt(S);
 334   S->setBreakLoc(ReadSourceLocation(Record, Idx));
 335 }
 336
 337 void ASTStmtReader::VisitReturnStmt(ReturnStmt *S) {
 338   VisitStmt(S);
 339   S->setRetValue(Reader.ReadSubExpr());
 340   S->setReturnLoc(ReadSourceLocation(Record, Idx));
 341   S->setNRVOCandidate(cast_or_null<VarDecl>(Reader.GetDecl(Record[Idx++])));
 342 }
 343
 344 void ASTStmtReader::VisitDeclStmt(DeclStmt *S) {
 345   VisitStmt(S);
 346   S->setStartLoc(ReadSourceLocation(Record, Idx));
 347   S->setEndLoc(ReadSourceLocation(Record, Idx));
 348
 349   if (Idx + 1 == Record.size()) {
 350     // Single declaration
 351     S->setDeclGroup(DeclGroupRef(Reader.GetDecl(Record[Idx++])));
 352   } else {
 353     llvm::SmallVector<Decl *, 16> Decls;
 354     Decls.reserve(Record.size() - Idx);
 355     for (unsigned N = Record.size(); Idx != N; ++Idx)
 356       Decls.push_back(Reader.GetDecl(Record[Idx]));
 357     S->setDeclGroup(DeclGroupRef(DeclGroup::Create(*Reader.getContext(),
 358                                                    Decls.data(),
 359                                                    Decls.size())));
 360   }
 361 }
 362
 363 void ASTStmtReader::VisitAsmStmt(AsmStmt *S) {
 364   VisitStmt(S);
 365   unsigned NumOutputs = Record[Idx++];
 366   unsigned NumInputs = Record[Idx++];
 367   unsigned NumClobbers = Record[Idx++];
 368   S->setAsmLoc(ReadSourceLocation(Record, Idx));
 369   S->setRParenLoc(ReadSourceLocation(Record, Idx));
 370   S->setVolatile(Record[Idx++]);
 371   S->setSimple(Record[Idx++]);
 372   S->setMSAsm(Record[Idx++]);
 373
 374   S->setAsmString(cast_or_null<StringLiteral>(Reader.ReadSubStmt()));
 375
 376   // Outputs and inputs
 377   llvm::SmallVector<IdentifierInfo *, 16> Names;
 378   llvm::SmallVector<StringLiteral*, 16> Constraints;
 379   llvm::SmallVector<Stmt*, 16> Exprs;
 380   for (unsigned I = 0, N = NumOutputs + NumInputs; I != N; ++I) {
 381     Names.push_back(Reader.GetIdentifierInfo(Record, Idx));
 382     Constraints.push_back(cast_or_null<StringLiteral>(Reader.ReadSubStmt()));
 383     Exprs.push_back(Reader.ReadSubStmt());
 384   }
 385
 386   // Constraints
 387   llvm::SmallVector<StringLiteral*, 16> Clobbers;
 388   for (unsigned I = 0; I != NumClobbers; ++I)
 389     Clobbers.push_back(cast_or_null<StringLiteral>(Reader.ReadSubStmt()));
 390
 391   S->setOutputsAndInputsAndClobbers(*Reader.getContext(),
 392                                     Names.data(), Constraints.data(),
 393                                     Exprs.data(), NumOutputs, NumInputs,
 394                                     Clobbers.data(), NumClobbers);
 395 }
 396
 397 void ASTStmtReader::VisitExpr(Expr *E) {
 398   VisitStmt(E);
 399   E->setType(Reader.GetType(Record[Idx++]));
 400   E->setTypeDependent(Record[Idx++]);
 401   E->setValueDependent(Record[Idx++]);
 402   E->setValueKind(static_cast<ExprValueKind>(Record[Idx++]));
 403   E->setObjectKind(static_cast<ExprObjectKind>(Record[Idx++]));
 404   assert(Idx == NumExprFields && "Incorrect expression field count");
 405 }
 406
 407 void ASTStmtReader::VisitPredefinedExpr(PredefinedExpr *E) {
 408   VisitExpr(E);
 409   E->setLocation(ReadSourceLocation(Record, Idx));
 410   E->setIdentType((PredefinedExpr::IdentType)Record[Idx++]);
 411 }
 412
 413 void ASTStmtReader::VisitDeclRefExpr(DeclRefExpr *E) {
 414   VisitExpr(E);
 415
 416   bool HasQualifier = Record[Idx++];
 417   unsigned NumTemplateArgs = Record[Idx++];
 418
 419   E->DecoratedD.setInt((HasQualifier? DeclRefExpr::HasQualifierFlag : 0) |
 420       (NumTemplateArgs ? DeclRefExpr::HasExplicitTemplateArgumentListFlag : 0));
 421
 422   if (HasQualifier) {
 423     E->getNameQualifier()->NNS = Reader.ReadNestedNameSpecifier(Record, Idx);
 424     E->getNameQualifier()->Range = ReadSourceRange(Record, Idx);
 425   }
 426
 427   if (NumTemplateArgs)
 428     ReadExplicitTemplateArgumentList(E->getExplicitTemplateArgs(),
 429                                      NumTemplateArgs);
 430
 431   E->setDecl(cast<ValueDecl>(Reader.GetDecl(Record[Idx++])));
 432   E->setLocation(ReadSourceLocation(Record, Idx));
 433   ReadDeclarationNameLoc(E->DNLoc, E->getDecl()->getDeclName(), Record, Idx);
 434 }
 435
 436 void ASTStmtReader::VisitIntegerLiteral(IntegerLiteral *E) {
 437   VisitExpr(E);
 438   E->setLocation(ReadSourceLocation(Record, Idx));
 439   E->setValue(*Reader.getContext(), Reader.ReadAPInt(Record, Idx));
 440 }
 441
 442 void ASTStmtReader::VisitFloatingLiteral(FloatingLiteral *E) {
 443   VisitExpr(E);
 444   E->setValue(*Reader.getContext(), Reader.ReadAPFloat(Record, Idx));
 445   E->setExact(Record[Idx++]);
 446   E->setLocation(ReadSourceLocation(Record, Idx));
 447 }
 448
 449 void ASTStmtReader::VisitImaginaryLiteral(ImaginaryLiteral *E) {
 450   VisitExpr(E);
 451   E->setSubExpr(Reader.ReadSubExpr());
 452 }
 453
 454 void ASTStmtReader::VisitStringLiteral(StringLiteral *E) {
 455   VisitExpr(E);
 456   unsigned Len = Record[Idx++];
 457   assert(Record[Idx] == E->getNumConcatenated() &&
 458          "Wrong number of concatenated tokens!");
 459   ++Idx;
 460   E->setWide(Record[Idx++]);
 461
 462   // Read string data
 463   llvm::SmallString<16> Str(&Record[Idx], &Record[Idx] + Len);
 464   E->setString(*Reader.getContext(), Str.str());
 465   Idx += Len;
 466
 467   // Read source locations
 468   for (unsigned I = 0, N = E->getNumConcatenated(); I != N; ++I)
 469     E->setStrTokenLoc(I, ReadSourceLocation(Record, Idx));
 470 }
 471
 472 void ASTStmtReader::VisitCharacterLiteral(CharacterLiteral *E) {
 473   VisitExpr(E);
 474   E->setValue(Record[Idx++]);
 475   E->setLocation(ReadSourceLocation(Record, Idx));
 476   E->setWide(Record[Idx++]);
 477 }
 478
 479 void ASTStmtReader::VisitParenExpr(ParenExpr *E) {
 480   VisitExpr(E);
 481   E->setLParen(ReadSourceLocation(Record, Idx));
 482   E->setRParen(ReadSourceLocation(Record, Idx));
 483   E->setSubExpr(Reader.ReadSubExpr());
 484 }
 485
 486 void ASTStmtReader::VisitParenListExpr(ParenListExpr *E) {
 487   VisitExpr(E);
 488   unsigned NumExprs = Record[Idx++];
 489   E->Exprs = new (*Reader.getContext()) Stmt*[NumExprs];
 490   for (unsigned i = 0; i != NumExprs; ++i)
 491     E->Exprs[i] = Reader.ReadSubStmt();
 492   E->NumExprs = NumExprs;
 493   E->LParenLoc = ReadSourceLocation(Record, Idx);
 494   E->RParenLoc = ReadSourceLocation(Record, Idx);
 495 }
 496
 497 void ASTStmtReader::VisitUnaryOperator(UnaryOperator *E) {
 498   VisitExpr(E);
 499   E->setSubExpr(Reader.ReadSubExpr());
 500   E->setOpcode((UnaryOperator::Opcode)Record[Idx++]);
 501   E->setOperatorLoc(ReadSourceLocation(Record, Idx));
 502 }
 503
 504 void ASTStmtReader::VisitOffsetOfExpr(OffsetOfExpr *E) {
 505   typedef OffsetOfExpr::OffsetOfNode Node;
 506   VisitExpr(E);
 507   assert(E->getNumComponents() == Record[Idx]);
 508   ++Idx;
 509   assert(E->getNumExpressions() == Record[Idx]);
 510   ++Idx;
 511   E->setOperatorLoc(ReadSourceLocation(Record, Idx));
 512   E->setRParenLoc(ReadSourceLocation(Record, Idx));
 513   E->setTypeSourceInfo(GetTypeSourceInfo(Record, Idx));
 514   for (unsigned I = 0, N = E->getNumComponents(); I != N; ++I) {
 515     Node::Kind Kind = static_cast<Node::Kind>(Record[Idx++]);
 516     SourceLocation Start = ReadSourceLocation(Record, Idx);
 517     SourceLocation End = ReadSourceLocation(Record, Idx);
 518     switch (Kind) {
 519     case Node::Array:
 520       E->setComponent(I, Node(Start, Record[Idx++], End));
 521       break;
 522
 523     case Node::Field:
 524       E->setComponent(I,
 525              Node(Start,
 526                   dyn_cast_or_null<FieldDecl>(Reader.GetDecl(Record[Idx++])),
 527                   End));
 528       break;
 529
 530     case Node::Identifier:
 531       E->setComponent(I, Node(Start, Reader.GetIdentifier(Record[Idx++]), End));
 532       break;
 533
 534     case Node::Base: {
 535       CXXBaseSpecifier *Base = new (*Reader.getContext()) CXXBaseSpecifier();
 536       *Base = Reader.ReadCXXBaseSpecifier(F, Record, Idx);
 537       E->setComponent(I, Node(Base));
 538       break;
 539     }
 540     }
 541   }
 542
 543   for (unsigned I = 0, N = E->getNumExpressions(); I != N; ++I)
 544     E->setIndexExpr(I, Reader.ReadSubExpr());
 545 }
 546
 547 void ASTStmtReader::VisitSizeOfAlignOfExpr(SizeOfAlignOfExpr *E) {
 548   VisitExpr(E);
 549   E->setSizeof(Record[Idx++]);
 550   if (Record[Idx] == 0) {
 551     E->setArgument(Reader.ReadSubExpr());
 552     ++Idx;
 553   } else {
 554     E->setArgument(GetTypeSourceInfo(Record, Idx));
 555   }
 556   E->setOperatorLoc(ReadSourceLocation(Record, Idx));
 557   E->setRParenLoc(ReadSourceLocation(Record, Idx));
 558 }
 559
 560 void ASTStmtReader::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
 561   VisitExpr(E);
 562   E->setLHS(Reader.ReadSubExpr());
 563   E->setRHS(Reader.ReadSubExpr());
 564   E->setRBracketLoc(ReadSourceLocation(Record, Idx));
 565 }
 566
 567 void ASTStmtReader::VisitCallExpr(CallExpr *E) {
 568   VisitExpr(E);
 569   E->setNumArgs(*Reader.getContext(), Record[Idx++]);
 570   E->setRParenLoc(ReadSourceLocation(Record, Idx));
 571   E->setCallee(Reader.ReadSubExpr());
 572   for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
 573     E->setArg(I, Reader.ReadSubExpr());
 574 }
 575
 576 void ASTStmtReader::VisitMemberExpr(MemberExpr *E) {
 577   // Don't call VisitExpr, this is fully initialized at creation.
 578   assert(E->getStmtClass() == Stmt::MemberExprClass &&
 579          "It's a subclass, we must advance Idx!");
 580 }
 581
 582 void ASTStmtReader::VisitObjCIsaExpr(ObjCIsaExpr *E) {
 583   VisitExpr(E);
 584   E->setBase(Reader.ReadSubExpr());
 585   E->setIsaMemberLoc(ReadSourceLocation(Record, Idx));
 586   E->setArrow(Record[Idx++]);
 587 }
 588
 589 void ASTStmtReader::VisitCastExpr(CastExpr *E) {
 590   VisitExpr(E);
 591   unsigned NumBaseSpecs = Record[Idx++];
 592   assert(NumBaseSpecs == E->path_size());
 593   E->setSubExpr(Reader.ReadSubExpr());
 594   E->setCastKind((CastExpr::CastKind)Record[Idx++]);
 595   CastExpr::path_iterator BaseI = E->path_begin();
 596   while (NumBaseSpecs--) {
 597     CXXBaseSpecifier *BaseSpec = new (*Reader.getContext()) CXXBaseSpecifier;
 598     *BaseSpec = Reader.ReadCXXBaseSpecifier(F, Record, Idx);
 599     *BaseI++ = BaseSpec;
 600   }
 601 }
 602
 603 void ASTStmtReader::VisitBinaryOperator(BinaryOperator *E) {
 604   VisitExpr(E);
 605   E->setLHS(Reader.ReadSubExpr());
 606   E->setRHS(Reader.ReadSubExpr());
 607   E->setOpcode((BinaryOperator::Opcode)Record[Idx++]);
 608   E->setOperatorLoc(ReadSourceLocation(Record, Idx));
 609 }
 610
 611 void ASTStmtReader::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
 612   VisitBinaryOperator(E);
 613   E->setComputationLHSType(Reader.GetType(Record[Idx++]));
 614   E->setComputationResultType(Reader.GetType(Record[Idx++]));
 615 }
 616
 617 void ASTStmtReader::VisitConditionalOperator(ConditionalOperator *E) {
 618   VisitExpr(E);
 619   E->setCond(Reader.ReadSubExpr());
 620   E->setLHS(Reader.ReadSubExpr());
 621   E->setRHS(Reader.ReadSubExpr());
 622   E->setSAVE(Reader.ReadSubExpr());
 623   E->setQuestionLoc(ReadSourceLocation(Record, Idx));
 624   E->setColonLoc(ReadSourceLocation(Record, Idx));
 625 }
 626
 627 void ASTStmtReader::VisitImplicitCastExpr(ImplicitCastExpr *E) {
 628   VisitCastExpr(E);
 629 }
 630
 631 void ASTStmtReader::VisitExplicitCastExpr(ExplicitCastExpr *E) {
 632   VisitCastExpr(E);
 633   E->setTypeInfoAsWritten(GetTypeSourceInfo(Record, Idx));
 634 }
 635
 636 void ASTStmtReader::VisitCStyleCastExpr(CStyleCastExpr *E) {
 637   VisitExplicitCastExpr(E);
 638   E->setLParenLoc(ReadSourceLocation(Record, Idx));
 639   E->setRParenLoc(ReadSourceLocation(Record, Idx));
 640 }
 641
 642 void ASTStmtReader::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
 643   VisitExpr(E);
 644   E->setLParenLoc(ReadSourceLocation(Record, Idx));
 645   E->setTypeSourceInfo(GetTypeSourceInfo(Record, Idx));
 646   E->setInitializer(Reader.ReadSubExpr());
 647   E->setFileScope(Record[Idx++]);
 648 }
 649
 650 void ASTStmtReader::VisitExtVectorElementExpr(ExtVectorElementExpr *E) {
 651   VisitExpr(E);
 652   E->setBase(Reader.ReadSubExpr());
 653   E->setAccessor(Reader.GetIdentifierInfo(Record, Idx));
 654   E->setAccessorLoc(ReadSourceLocation(Record, Idx));
 655 }
 656
 657 void ASTStmtReader::VisitInitListExpr(InitListExpr *E) {
 658   VisitExpr(E);
 659   unsigned NumInits = Record[Idx++];
 660   E->reserveInits(*Reader.getContext(), NumInits);
 661   for (unsigned I = 0; I != NumInits; ++I)
 662     E->updateInit(*Reader.getContext(), I, Reader.ReadSubExpr());
 663   E->setSyntacticForm(cast_or_null<InitListExpr>(Reader.ReadSubStmt()));
 664   E->setLBraceLoc(ReadSourceLocation(Record, Idx));
 665   E->setRBraceLoc(ReadSourceLocation(Record, Idx));
 666   E->setInitializedFieldInUnion(
 667                       cast_or_null<FieldDecl>(Reader.GetDecl(Record[Idx++])));
 668   E->sawArrayRangeDesignator(Record[Idx++]);
 669 }
 670
 671 void ASTStmtReader::VisitDesignatedInitExpr(DesignatedInitExpr *E) {
 672   typedef DesignatedInitExpr::Designator Designator;
 673
 674   VisitExpr(E);
 675   unsigned NumSubExprs = Record[Idx++];
 676   assert(NumSubExprs == E->getNumSubExprs() && "Wrong number of subexprs");
 677   for (unsigned I = 0; I != NumSubExprs; ++I)
 678     E->setSubExpr(I, Reader.ReadSubExpr());
 679   E->setEqualOrColonLoc(ReadSourceLocation(Record, Idx));
 680   E->setGNUSyntax(Record[Idx++]);
 681
 682   llvm::SmallVector<Designator, 4> Designators;
 683   while (Idx < Record.size()) {
 684     switch ((DesignatorTypes)Record[Idx++]) {
 685     case DESIG_FIELD_DECL: {
 686       FieldDecl *Field = cast<FieldDecl>(Reader.GetDecl(Record[Idx++]));
 687       SourceLocation DotLoc
 688         = ReadSourceLocation(Record, Idx);
 689       SourceLocation FieldLoc
 690         = ReadSourceLocation(Record, Idx);
 691       Designators.push_back(Designator(Field->getIdentifier(), DotLoc,
 692                                        FieldLoc));
 693       Designators.back().setField(Field);
 694       break;
 695     }
 696
 697     case DESIG_FIELD_NAME: {
 698       const IdentifierInfo *Name = Reader.GetIdentifierInfo(Record, Idx);
 699       SourceLocation DotLoc
 700         = ReadSourceLocation(Record, Idx);
 701       SourceLocation FieldLoc
 702         = ReadSourceLocation(Record, Idx);
 703       Designators.push_back(Designator(Name, DotLoc, FieldLoc));
 704       break;
 705     }
 706
 707     case DESIG_ARRAY: {
 708       unsigned Index = Record[Idx++];
 709       SourceLocation LBracketLoc
 710         = ReadSourceLocation(Record, Idx);
 711       SourceLocation RBracketLoc
 712         = ReadSourceLocation(Record, Idx);
 713       Designators.push_back(Designator(Index, LBracketLoc, RBracketLoc));
 714       break;
 715     }
 716
 717     case DESIG_ARRAY_RANGE: {
 718       unsigned Index = Record[Idx++];
 719       SourceLocation LBracketLoc
 720         = ReadSourceLocation(Record, Idx);
 721       SourceLocation EllipsisLoc
 722         = ReadSourceLocation(Record, Idx);
 723       SourceLocation RBracketLoc
 724         = ReadSourceLocation(Record, Idx);
 725       Designators.push_back(Designator(Index, LBracketLoc, EllipsisLoc,
 726                                        RBracketLoc));
 727       break;
 728     }
 729     }
 730   }
 731   E->setDesignators(*Reader.getContext(),
 732                     Designators.data(), Designators.size());
 733 }
 734
 735 void ASTStmtReader::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
 736   VisitExpr(E);
 737 }
 738
 739 void ASTStmtReader::VisitVAArgExpr(VAArgExpr *E) {
 740   VisitExpr(E);
 741   E->setSubExpr(Reader.ReadSubExpr());
 742   E->setWrittenTypeInfo(GetTypeSourceInfo(Record, Idx));
 743   E->setBuiltinLoc(ReadSourceLocation(Record, Idx));
 744   E->setRParenLoc(ReadSourceLocation(Record, Idx));
 745 }
 746
 747 void ASTStmtReader::VisitAddrLabelExpr(AddrLabelExpr *E) {
 748   VisitExpr(E);
 749   E->setAmpAmpLoc(ReadSourceLocation(Record, Idx));
 750   E->setLabelLoc(ReadSourceLocation(Record, Idx));
 751   Reader.SetLabelOf(E, Record[Idx++]);
 752 }
 753
 754 void ASTStmtReader::VisitStmtExpr(StmtExpr *E) {
 755   VisitExpr(E);
 756   E->setLParenLoc(ReadSourceLocation(Record, Idx));
 757   E->setRParenLoc(ReadSourceLocation(Record, Idx));
 758   E->setSubStmt(cast_or_null<CompoundStmt>(Reader.ReadSubStmt()));
 759 }
 760
 761 void ASTStmtReader::VisitChooseExpr(ChooseExpr *E) {
 762   VisitExpr(E);
 763   E->setCond(Reader.ReadSubExpr());
 764   E->setLHS(Reader.ReadSubExpr());
 765   E->setRHS(Reader.ReadSubExpr());
 766   E->setBuiltinLoc(ReadSourceLocation(Record, Idx));
 767   E->setRParenLoc(ReadSourceLocation(Record, Idx));
 768 }
 769
 770 void ASTStmtReader::VisitGNUNullExpr(GNUNullExpr *E) {
 771   VisitExpr(E);
 772   E->setTokenLocation(ReadSourceLocation(Record, Idx));
 773 }
 774
 775 void ASTStmtReader::VisitShuffleVectorExpr(ShuffleVectorExpr *E) {
 776   VisitExpr(E);
 777   llvm::SmallVector<Expr *, 16> Exprs;
 778   unsigned NumExprs = Record[Idx++];
 779   while (NumExprs--)
 780     Exprs.push_back(Reader.ReadSubExpr());
 781   E->setExprs(*Reader.getContext(), Exprs.data(), Exprs.size());
 782   E->setBuiltinLoc(ReadSourceLocation(Record, Idx));
 783   E->setRParenLoc(ReadSourceLocation(Record, Idx));
 784 }
 785
 786 void ASTStmtReader::VisitBlockExpr(BlockExpr *E) {
 787   VisitExpr(E);
 788   E->setBlockDecl(cast_or_null<BlockDecl>(Reader.GetDecl(Record[Idx++])));
 789   E->setHasBlockDeclRefExprs(Record[Idx++]);
 790 }
 791
 792 void ASTStmtReader::VisitBlockDeclRefExpr(BlockDeclRefExpr *E) {
 793   VisitExpr(E);
 794   E->setDecl(cast<ValueDecl>(Reader.GetDecl(Record[Idx++])));
 795   E->setLocation(ReadSourceLocation(Record, Idx));
 796   E->setByRef(Record[Idx++]);
 797   E->setConstQualAdded(Record[Idx++]);
 798   E->setCopyConstructorExpr(Reader.ReadSubExpr());
 799 }
 800
 801 //===----------------------------------------------------------------------===//
 802 // Objective-C Expressions and Statements
 803
 804 void ASTStmtReader::VisitObjCStringLiteral(ObjCStringLiteral *E) {
 805   VisitExpr(E);
 806   E->setString(cast<StringLiteral>(Reader.ReadSubStmt()));
 807   E->setAtLoc(ReadSourceLocation(Record, Idx));
 808 }
 809
 810 void ASTStmtReader::VisitObjCEncodeExpr(ObjCEncodeExpr *E) {
 811   VisitExpr(E);
 812   E->setEncodedTypeSourceInfo(GetTypeSourceInfo(Record, Idx));
 813   E->setAtLoc(ReadSourceLocation(Record, Idx));
 814   E->setRParenLoc(ReadSourceLocation(Record, Idx));
 815 }
 816
 817 void ASTStmtReader::VisitObjCSelectorExpr(ObjCSelectorExpr *E) {
 818   VisitExpr(E);
 819   E->setSelector(Reader.GetSelector(Record, Idx));
 820   E->setAtLoc(ReadSourceLocation(Record, Idx));
 821   E->setRParenLoc(ReadSourceLocation(Record, Idx));
 822 }
 823
 824 void ASTStmtReader::VisitObjCProtocolExpr(ObjCProtocolExpr *E) {
 825   VisitExpr(E);
 826   E->setProtocol(cast<ObjCProtocolDecl>(Reader.GetDecl(Record[Idx++])));
 827   E->setAtLoc(ReadSourceLocation(Record, Idx));
 828   E->setRParenLoc(ReadSourceLocation(Record, Idx));
 829 }
 830
 831 void ASTStmtReader::VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
 832   VisitExpr(E);
 833   E->setDecl(cast<ObjCIvarDecl>(Reader.GetDecl(Record[Idx++])));
 834   E->setLocation(ReadSourceLocation(Record, Idx));
 835   E->setBase(Reader.ReadSubExpr());
 836   E->setIsArrow(Record[Idx++]);
 837   E->setIsFreeIvar(Record[Idx++]);
 838 }
 839
 840 void ASTStmtReader::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
 841   VisitExpr(E);
 842   bool Implicit = Record[Idx++] != 0;
 843   if (Implicit) {
 844     ObjCMethodDecl *Getter =
 845       cast<ObjCMethodDecl>(Reader.GetDecl(Record[Idx++]));
 846     ObjCMethodDecl *Setter =
 847       cast<ObjCMethodDecl>(Reader.GetDecl(Record[Idx++]));
 848     E->setImplicitProperty(Getter, Setter);
 849   } else {
 850     E->setExplicitProperty(
 851                       cast<ObjCPropertyDecl>(Reader.GetDecl(Record[Idx++])));
 852   }
 853   E->setLocation(ReadSourceLocation(Record, Idx));
 854   E->setReceiverLocation(ReadSourceLocation(Record, Idx));
 855   switch (Record[Idx++]) {
 856   case 0:
 857     E->setBase(Reader.ReadSubExpr());
 858     break;
 859   case 1:
 860     E->setSuperReceiver(Reader.GetType(Record[Idx++]));
 861     break;
 862   case 2:
 863     E->setClassReceiver(
 864                      cast<ObjCInterfaceDecl>(Reader.GetDecl(Record[Idx++])));
 865     break;
 866   }
 867 }
 868
 869 void ASTStmtReader::VisitObjCMessageExpr(ObjCMessageExpr *E) {
 870   VisitExpr(E);
 871   assert(Record[Idx] == E->getNumArgs());
 872   ++Idx;
 873   ObjCMessageExpr::ReceiverKind Kind
 874     = static_cast<ObjCMessageExpr::ReceiverKind>(Record[Idx++]);
 875   switch (Kind) {
 876   case ObjCMessageExpr::Instance:
 877     E->setInstanceReceiver(Reader.ReadSubExpr());
 878     break;
 879
 880   case ObjCMessageExpr::Class:
 881     E->setClassReceiver(GetTypeSourceInfo(Record, Idx));
 882     break;
 883
 884   case ObjCMessageExpr::SuperClass:
 885   case ObjCMessageExpr::SuperInstance: {
 886     QualType T = Reader.GetType(Record[Idx++]);
 887     SourceLocation SuperLoc = ReadSourceLocation(Record, Idx);
 888     E->setSuper(SuperLoc, T, Kind == ObjCMessageExpr::SuperInstance);
 889     break;
 890   }
 891   }
 892
 893   assert(Kind == E->getReceiverKind());
 894
 895   if (Record[Idx++])
 896     E->setMethodDecl(cast_or_null<ObjCMethodDecl>(Reader.GetDecl(Record[Idx++])));
 897   else
 898     E->setSelector(Reader.GetSelector(Record, Idx));
 899
 900   E->LBracLoc = ReadSourceLocation(Record, Idx);
 901   E->RBracLoc = ReadSourceLocation(Record, Idx);
 902   E->SelectorLoc = ReadSourceLocation(Record, Idx);
 903
 904   for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
 905     E->setArg(I, Reader.ReadSubExpr());
 906 }
 907
 908 void ASTStmtReader::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) {
 909   VisitStmt(S);
 910   S->setElement(Reader.ReadSubStmt());
 911   S->setCollection(Reader.ReadSubExpr());
 912   S->setBody(Reader.ReadSubStmt());
 913   S->setForLoc(ReadSourceLocation(Record, Idx));
 914   S->setRParenLoc(ReadSourceLocation(Record, Idx));
 915 }
 916
 917 void ASTStmtReader::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) {
 918   VisitStmt(S);
 919   S->setCatchBody(Reader.ReadSubStmt());
 920   S->setCatchParamDecl(cast_or_null<VarDecl>(Reader.GetDecl(Record[Idx++])));
 921   S->setAtCatchLoc(ReadSourceLocation(Record, Idx));
 922   S->setRParenLoc(ReadSourceLocation(Record, Idx));
 923 }
 924
 925 void ASTStmtReader::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
 926   VisitStmt(S);
 927   S->setFinallyBody(Reader.ReadSubStmt());
 928   S->setAtFinallyLoc(ReadSourceLocation(Record, Idx));
 929 }
 930
 931 void ASTStmtReader::VisitObjCAtTryStmt(ObjCAtTryStmt *S) {
 932   VisitStmt(S);
 933   assert(Record[Idx] == S->getNumCatchStmts());
 934   ++Idx;
 935   bool HasFinally = Record[Idx++];
 936   S->setTryBody(Reader.ReadSubStmt());
 937   for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I)
 938     S->setCatchStmt(I, cast_or_null<ObjCAtCatchStmt>(Reader.ReadSubStmt()));
 939
 940   if (HasFinally)
 941     S->setFinallyStmt(Reader.ReadSubStmt());
 942   S->setAtTryLoc(ReadSourceLocation(Record, Idx));
 943 }
 944
 945 void ASTStmtReader::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S) {
 946   VisitStmt(S);
 947   S->setSynchExpr(Reader.ReadSubStmt());
 948   S->setSynchBody(Reader.ReadSubStmt());
 949   S->setAtSynchronizedLoc(ReadSourceLocation(Record, Idx));
 950 }
 951
 952 void ASTStmtReader::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) {
 953   VisitStmt(S);
 954   S->setThrowExpr(Reader.ReadSubStmt());
 955   S->setThrowLoc(ReadSourceLocation(Record, Idx));
 956 }
 957
 958 //===----------------------------------------------------------------------===//
 959 // C++ Expressions and Statements
 960 //===----------------------------------------------------------------------===//
 961
 962 void ASTStmtReader::VisitCXXCatchStmt(CXXCatchStmt *S) {
 963   VisitStmt(S);
 964   S->CatchLoc = ReadSourceLocation(Record, Idx);
 965   S->ExceptionDecl = cast_or_null<VarDecl>(Reader.GetDecl(Record[Idx++]));
 966   S->HandlerBlock = Reader.ReadSubStmt();
 967 }
 968
 969 void ASTStmtReader::VisitCXXTryStmt(CXXTryStmt *S) {
 970   VisitStmt(S);
 971   assert(Record[Idx] == S->getNumHandlers() && "NumStmtFields is wrong ?");
 972   ++Idx;
 973   S->TryLoc = ReadSourceLocation(Record, Idx);
 974   S->getStmts()[0] = Reader.ReadSubStmt();
 975   for (unsigned i = 0, e = S->getNumHandlers(); i != e; ++i)
 976     S->getStmts()[i + 1] = Reader.ReadSubStmt();
 977 }
 978
 979 void ASTStmtReader::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
 980   VisitCallExpr(E);
 981   E->setOperator((OverloadedOperatorKind)Record[Idx++]);
 982 }
 983
 984 void ASTStmtReader::VisitCXXConstructExpr(CXXConstructExpr *E) {
 985   VisitExpr(E);
 986   E->NumArgs = Record[Idx++];
 987   if (E->NumArgs)
 988     E->Args = new (*Reader.getContext()) Stmt*[E->NumArgs];
 989   for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
 990     E->setArg(I, Reader.ReadSubExpr());
 991   E->setConstructor(cast<CXXConstructorDecl>(Reader.GetDecl(Record[Idx++])));
 992   E->setLocation(ReadSourceLocation(Record, Idx));
 993   E->setElidable(Record[Idx++]);
 994   E->setRequiresZeroInitialization(Record[Idx++]);
 995   E->setConstructionKind((CXXConstructExpr::ConstructionKind)Record[Idx++]);
 996   E->ParenRange = ReadSourceRange(Record, Idx);
 997 }
 998
 999 void ASTStmtReader::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E) {
1000   VisitCXXConstructExpr(E);
1001   E->Type = GetTypeSourceInfo(Record, Idx);
1002 }
1003
1004 void ASTStmtReader::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) {
1005   VisitExplicitCastExpr(E);
1006   E->setOperatorLoc(ReadSourceLocation(Record, Idx));
1007 }
1008
1009 void ASTStmtReader::VisitCXXStaticCastExpr(CXXStaticCastExpr *E) {
1010   return VisitCXXNamedCastExpr(E);
1011 }
1012
1013 void ASTStmtReader::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *E) {
1014   return VisitCXXNamedCastExpr(E);
1015 }
1016
1017 void ASTStmtReader::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *E) {
1018   return VisitCXXNamedCastExpr(E);
1019 }
1020
1021 void ASTStmtReader::VisitCXXConstCastExpr(CXXConstCastExpr *E) {
1022   return VisitCXXNamedCastExpr(E);
1023 }
1024
1025 void ASTStmtReader::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E) {
1026   VisitExplicitCastExpr(E);
1027   E->setTypeBeginLoc(ReadSourceLocation(Record, Idx));
1028   E->setRParenLoc(ReadSourceLocation(Record, Idx));
1029 }
1030
1031 void ASTStmtReader::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
1032   VisitExpr(E);
1033   E->setValue(Record[Idx++]);
1034   E->setLocation(ReadSourceLocation(Record, Idx));
1035 }
1036
1037 void ASTStmtReader::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) {
1038   VisitExpr(E);
1039   E->setLocation(ReadSourceLocation(Record, Idx));
1040 }
1041
1042 void ASTStmtReader::VisitCXXTypeidExpr(CXXTypeidExpr *E) {
1043   VisitExpr(E);
1044   E->setSourceRange(ReadSourceRange(Record, Idx));
1045   if (E->isTypeOperand()) { // typeid(int)
1046     E->setTypeOperandSourceInfo(
1047         GetTypeSourceInfo(Record, Idx));
1048     return;
1049   }
1050
1051   // typeid(42+2)
1052   E->setExprOperand(Reader.ReadSubExpr());
1053 }
1054 void ASTStmtReader::VisitCXXUuidofExpr(CXXUuidofExpr *E) {
1055   VisitExpr(E);
1056   E->setSourceRange(ReadSourceRange(Record, Idx));
1057   if (E->isTypeOperand()) { // __uuidof(ComType)
1058     E->setTypeOperandSourceInfo(
1059         GetTypeSourceInfo(Record, Idx));
1060     return;
1061   }
1062
1063   // __uuidof(expr)
1064   E->setExprOperand(Reader.ReadSubExpr());
1065 }
1066
1067 void ASTStmtReader::VisitCXXThisExpr(CXXThisExpr *E) {
1068   VisitExpr(E);
1069   E->setLocation(ReadSourceLocation(Record, Idx));
1070   E->setImplicit(Record[Idx++]);
1071 }
1072
1073 void ASTStmtReader::VisitCXXThrowExpr(CXXThrowExpr *E) {
1074   VisitExpr(E);
1075   E->setThrowLoc(ReadSourceLocation(Record, Idx));
1076   E->setSubExpr(Reader.ReadSubExpr());
1077 }
1078
1079 void ASTStmtReader::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
1080   VisitExpr(E);
1081
1082   assert(Record[Idx] == E->Param.getInt() && "We messed up at creation ?");
1083   ++Idx; // HasOtherExprStored and SubExpr was handled during creation.
1084   E->Param.setPointer(cast<ParmVarDecl>(Reader.GetDecl(Record[Idx++])));
1085   E->Loc = ReadSourceLocation(Record, Idx);
1086 }
1087
1088 void ASTStmtReader::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
1089   VisitExpr(E);
1090   E->setTemporary(Reader.ReadCXXTemporary(Record, Idx));
1091   E->setSubExpr(Reader.ReadSubExpr());
1092 }
1093
1094 void ASTStmtReader::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
1095   VisitExpr(E);
1096   E->TypeInfo = GetTypeSourceInfo(Record, Idx);
1097   E->RParenLoc = ReadSourceLocation(Record, Idx);
1098 }
1099
1100 void ASTStmtReader::VisitCXXNewExpr(CXXNewExpr *E) {
1101   VisitExpr(E);
1102   E->setGlobalNew(Record[Idx++]);
1103   E->setHasInitializer(Record[Idx++]);
1104   bool isArray = Record[Idx++];
1105   unsigned NumPlacementArgs = Record[Idx++];
1106   unsigned NumCtorArgs = Record[Idx++];
1107   E->setOperatorNew(cast_or_null<FunctionDecl>(Reader.GetDecl(Record[Idx++])));
1108   E->setOperatorDelete(
1109                     cast_or_null<FunctionDecl>(Reader.GetDecl(Record[Idx++])));
1110   E->setConstructor(
1111                cast_or_null<CXXConstructorDecl>(Reader.GetDecl(Record[Idx++])));
1112   E->AllocatedTypeInfo = GetTypeSourceInfo(Record, Idx);
1113   SourceRange TypeIdParens;
1114   TypeIdParens.setBegin(ReadSourceLocation(Record, Idx));
1115   TypeIdParens.setEnd(ReadSourceLocation(Record, Idx));
1116   E->TypeIdParens = TypeIdParens;
1117   E->StartLoc = ReadSourceLocation(Record, Idx);
1118   E->EndLoc = ReadSourceLocation(Record, Idx);
1119   E->ConstructorLParen = ReadSourceLocation(Record, Idx);
1120   E->ConstructorRParen = ReadSourceLocation(Record, Idx);
1121
1122   E->AllocateArgsArray(*Reader.getContext(), isArray, NumPlacementArgs,
1123                        NumCtorArgs);
1124
1125   // Install all the subexpressions.
1126   for (CXXNewExpr::raw_arg_iterator I = E->raw_arg_begin(),e = E->raw_arg_end();
1127        I != e; ++I)
1128     *I = Reader.ReadSubStmt();
1129 }
1130
1131 void ASTStmtReader::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
1132   VisitExpr(E);
1133   E->GlobalDelete = Record[Idx++];
1134   E->ArrayForm = Record[Idx++];
1135   E->ArrayFormAsWritten = Record[Idx++];
1136   E->OperatorDelete = cast_or_null<FunctionDecl>(Reader.GetDecl(Record[Idx++]));
1137   E->Argument = Reader.ReadSubExpr();
1138   E->Loc = ReadSourceLocation(Record, Idx);
1139 }
1140
1141 void ASTStmtReader::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) {
1142   VisitExpr(E);
1143
1144   E->setBase(Reader.ReadSubExpr());
1145   E->setArrow(Record[Idx++]);
1146   E->setOperatorLoc(ReadSourceLocation(Record, Idx));
1147   E->setQualifier(Reader.ReadNestedNameSpecifier(Record, Idx));
1148   E->setQualifierRange(ReadSourceRange(Record, Idx));
1149   E->setScopeTypeInfo(GetTypeSourceInfo(Record, Idx));
1150   E->setColonColonLoc(ReadSourceLocation(Record, Idx));
1151   E->setTildeLoc(ReadSourceLocation(Record, Idx));
1152
1153   IdentifierInfo *II = Reader.GetIdentifierInfo(Record, Idx);
1154   if (II)
1155     E->setDestroyedType(II, ReadSourceLocation(Record, Idx));
1156   else
1157     E->setDestroyedType(GetTypeSourceInfo(Record, Idx));
1158 }
1159
1160 void ASTStmtReader::VisitExprWithCleanups(ExprWithCleanups *E) {
1161   VisitExpr(E);
1162   unsigned NumTemps = Record[Idx++];
1163   if (NumTemps) {
1164     E->setNumTemporaries(*Reader.getContext(), NumTemps);
1165     for (unsigned i = 0; i != NumTemps; ++i)
1166       E->setTemporary(i, Reader.ReadCXXTemporary(Record, Idx));
1167   }
1168   E->setSubExpr(Reader.ReadSubExpr());
1169 }
1170
1171 void
1172 ASTStmtReader::VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E){
1173   VisitExpr(E);
1174
1175   unsigned NumTemplateArgs = Record[Idx++];
1176   assert((NumTemplateArgs != 0) == E->hasExplicitTemplateArgs() &&
1177          "Read wrong record during creation ?");
1178   if (E->hasExplicitTemplateArgs())
1179     ReadExplicitTemplateArgumentList(E->getExplicitTemplateArgs(),
1180                                      NumTemplateArgs);
1181
1182   E->setBase(Reader.ReadSubExpr());
1183   E->setBaseType(Reader.GetType(Record[Idx++]));
1184   E->setArrow(Record[Idx++]);
1185   E->setOperatorLoc(ReadSourceLocation(Record, Idx));
1186   E->setQualifier(Reader.ReadNestedNameSpecifier(Record, Idx));
1187   E->setQualifierRange(ReadSourceRange(Record, Idx));
1188   E->setFirstQualifierFoundInScope(
1189                         cast_or_null<NamedDecl>(Reader.GetDecl(Record[Idx++])));
1190   ReadDeclarationNameInfo(E->MemberNameInfo, Record, Idx);
1191 }
1192
1193 void
1194 ASTStmtReader::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) {
1195   VisitExpr(E);
1196
1197   unsigned NumTemplateArgs = Record[Idx++];
1198   assert((NumTemplateArgs != 0) == E->hasExplicitTemplateArgs() &&
1199          "Read wrong record during creation ?");
1200   if (E->hasExplicitTemplateArgs())
1201     ReadExplicitTemplateArgumentList(E->getExplicitTemplateArgs(),
1202                                      NumTemplateArgs);
1203
1204   ReadDeclarationNameInfo(E->NameInfo, Record, Idx);
1205   E->setQualifierRange(ReadSourceRange(Record, Idx));
1206   E->setQualifier(Reader.ReadNestedNameSpecifier(Record, Idx));
1207 }
1208
1209 void
1210 ASTStmtReader::VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E) {
1211   VisitExpr(E);
1212   assert(Record[Idx] == E->arg_size() && "Read wrong record during creation ?");
1213   ++Idx; // NumArgs;
1214   for (unsigned I = 0, N = E->arg_size(); I != N; ++I)
1215     E->setArg(I, Reader.ReadSubExpr());
1216   E->Type = GetTypeSourceInfo(Record, Idx);
1217   E->setLParenLoc(ReadSourceLocation(Record, Idx));
1218   E->setRParenLoc(ReadSourceLocation(Record, Idx));
1219 }
1220
1221 void ASTStmtReader::VisitOverloadExpr(OverloadExpr *E) {
1222   VisitExpr(E);
1223
1224   unsigned NumTemplateArgs = Record[Idx++];
1225   assert((NumTemplateArgs != 0) == E->hasExplicitTemplateArgs() &&
1226          "Read wrong record during creation ?");
1227   if (E->hasExplicitTemplateArgs())
1228     ReadExplicitTemplateArgumentList(E->getExplicitTemplateArgs(),
1229                                      NumTemplateArgs);
1230
1231   unsigned NumDecls = Record[Idx++];
1232   UnresolvedSet<8> Decls;
1233   for (unsigned i = 0; i != NumDecls; ++i) {
1234     NamedDecl *D = cast<NamedDecl>(Reader.GetDecl(Record[Idx++]));
1235     AccessSpecifier AS = (AccessSpecifier)Record[Idx++];
1236     Decls.addDecl(D, AS);
1237   }
1238   E->initializeResults(*Reader.getContext(), Decls.begin(), Decls.end());
1239
1240   ReadDeclarationNameInfo(E->NameInfo, Record, Idx);
1241   E->setQualifier(Reader.ReadNestedNameSpecifier(Record, Idx));
1242   E->setQualifierRange(ReadSourceRange(Record, Idx));
1243 }
1244
1245 void ASTStmtReader::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) {
1246   VisitOverloadExpr(E);
1247   E->setArrow(Record[Idx++]);
1248   E->setHasUnresolvedUsing(Record[Idx++]);
1249   E->setBase(Reader.ReadSubExpr());
1250   E->setBaseType(Reader.GetType(Record[Idx++]));
1251   E->setOperatorLoc(ReadSourceLocation(Record, Idx));
1252 }
1253
1254 void ASTStmtReader::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) {
1255   VisitOverloadExpr(E);
1256   E->setRequiresADL(Record[Idx++]);
1257   E->setOverloaded(Record[Idx++]);
1258   E->setNamingClass(cast_or_null<CXXRecordDecl>(Reader.GetDecl(Record[Idx++])));
1259 }
1260
1261 void ASTStmtReader::VisitUnaryTypeTraitExpr(UnaryTypeTraitExpr *E) {
1262   VisitExpr(E);
1263   E->UTT = (UnaryTypeTrait)Record[Idx++];
1264   E->Value = (bool)Record[Idx++];
1265   SourceRange Range = ReadSourceRange(Record, Idx);
1266   E->Loc = Range.getBegin();
1267   E->RParen = Range.getEnd();
1268   E->QueriedType = GetTypeSourceInfo(Record, Idx);
1269 }
1270
1271 void ASTStmtReader::VisitBinaryTypeTraitExpr(BinaryTypeTraitExpr *E) {
1272   VisitExpr(E);
1273   E->BTT = (BinaryTypeTrait)Record[Idx++];
1274   E->Value = (bool)Record[Idx++];
1275   SourceRange Range = ReadSourceRange(Record, Idx);
1276   E->Loc = Range.getBegin();
1277   E->RParen = Range.getEnd();
1278   E->LhsType = GetTypeSourceInfo(Record, Idx);
1279   E->RhsType = GetTypeSourceInfo(Record, Idx);
1280 }
1281
1282 void ASTStmtReader::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) {
1283   VisitExpr(E);
1284   E->Value = (bool)Record[Idx++];
1285   E->Range = ReadSourceRange(Record, Idx);
1286   E->Operand = Reader.ReadSubExpr();
1287 }
1288
1289 void ASTStmtReader::VisitOpaqueValueExpr(OpaqueValueExpr *E) {
1290   VisitExpr(E);
1291 }
1292
1293 Stmt *ASTReader::ReadStmt(PerFileData &F) {
1294   switch (ReadingKind) {
1295   case Read_Decl:
1296   case Read_Type:
1297     return ReadStmtFromStream(F);
1298   case Read_Stmt:
1299     return ReadSubStmt();
1300   }
1301
1302   llvm_unreachable("ReadingKind not set ?");
1303   return 0;
1304 }
1305
1306 Expr *ASTReader::ReadExpr(PerFileData &F) {
1307   return cast_or_null<Expr>(ReadStmt(F));
1308 }
1309
1310 Expr *ASTReader::ReadSubExpr() {
1311   return cast_or_null<Expr>(ReadSubStmt());
1312 }
1313
1314 // Within the bitstream, expressions are stored in Reverse Polish
1315 // Notation, with each of the subexpressions preceding the
1316 // expression they are stored in. Subexpressions are stored from last to first.
1317 // To evaluate expressions, we continue reading expressions and placing them on
1318 // the stack, with expressions having operands removing those operands from the
1319 // stack. Evaluation terminates when we see a STMT_STOP record, and
1320 // the single remaining expression on the stack is our result.
1321 Stmt *ASTReader::ReadStmtFromStream(PerFileData &F) {
1322
1323   ReadingKindTracker ReadingKind(Read_Stmt, *this);
1324   llvm::BitstreamCursor &Cursor = F.DeclsCursor;
1325
1326 #ifndef NDEBUG
1327   unsigned PrevNumStmts = StmtStack.size();
1328 #endif
1329
1330   RecordData Record;
1331   unsigned Idx;
1332   ASTStmtReader Reader(*this, F, Cursor, Record, Idx);
1333   Stmt::EmptyShell Empty;
1334
1335   while (true) {
1336     unsigned Code = Cursor.ReadCode();
1337     if (Code == llvm::bitc::END_BLOCK) {
1338       if (Cursor.ReadBlockEnd()) {
1339         Error("error at end of block in AST file");
1340         return 0;
1341       }
1342       break;
1343     }
1344
1345     if (Code == llvm::bitc::ENTER_SUBBLOCK) {
1346       // No known subblocks, always skip them.
1347       Cursor.ReadSubBlockID();
1348       if (Cursor.SkipBlock()) {
1349         Error("malformed block record in AST file");
1350         return 0;
1351       }
1352       continue;
1353     }
1354
1355     if (Code == llvm::bitc::DEFINE_ABBREV) {
1356       Cursor.ReadAbbrevRecord();
1357       continue;
1358     }
1359
1360     Stmt *S = 0;
1361     Idx = 0;
1362     Record.clear();
1363     bool Finished = false;
1364     switch ((StmtCode)Cursor.ReadRecord(Code, Record)) {
1365     case STMT_STOP:
1366       Finished = true;
1367       break;
1368
1369     case STMT_NULL_PTR:
1370       S = 0;
1371       break;
1372
1373     case STMT_NULL:
1374       S = new (Context) NullStmt(Empty);
1375       break;
1376
1377     case STMT_COMPOUND:
1378       S = new (Context) CompoundStmt(Empty);
1379       break;
1380
1381     case STMT_CASE:
1382       S = new (Context) CaseStmt(Empty);
1383       break;
1384
1385     case STMT_DEFAULT:
1386       S = new (Context) DefaultStmt(Empty);
1387       break;
1388
1389     case STMT_LABEL:
1390       S = new (Context) LabelStmt(Empty);
1391       break;
1392
1393     case STMT_IF:
1394       S = new (Context) IfStmt(Empty);
1395       break;
1396
1397     case STMT_SWITCH:
1398       S = new (Context) SwitchStmt(Empty);
1399       break;
1400
1401     case STMT_WHILE:
1402       S = new (Context) WhileStmt(Empty);
1403       break;
1404
1405     case STMT_DO:
1406       S = new (Context) DoStmt(Empty);
1407       break;
1408
1409     case STMT_FOR:
1410       S = new (Context) ForStmt(Empty);
1411       break;
1412
1413     case STMT_GOTO:
1414       S = new (Context) GotoStmt(Empty);
1415       break;
1416
1417     case STMT_INDIRECT_GOTO:
1418       S = new (Context) IndirectGotoStmt(Empty);
1419       break;
1420
1421     case STMT_CONTINUE:
1422       S = new (Context) ContinueStmt(Empty);
1423       break;
1424
1425     case STMT_BREAK:
1426       S = new (Context) BreakStmt(Empty);
1427       break;
1428
1429     case STMT_RETURN:
1430       S = new (Context) ReturnStmt(Empty);
1431       break;
1432
1433     case STMT_DECL:
1434       S = new (Context) DeclStmt(Empty);
1435       break;
1436
1437     case STMT_ASM:
1438       S = new (Context) AsmStmt(Empty);
1439       break;
1440
1441     case EXPR_PREDEFINED:
1442       S = new (Context) PredefinedExpr(Empty);
1443       break;
1444
1445     case EXPR_DECL_REF:
1446       S = DeclRefExpr::CreateEmpty(*Context,
1447                          /*HasQualifier=*/Record[ASTStmtReader::NumExprFields],
1448                   /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields + 1]);
1449       break;
1450
1451     case EXPR_INTEGER_LITERAL:
1452       S = IntegerLiteral::Create(*Context, Empty);
1453       break;
1454
1455     case EXPR_FLOATING_LITERAL:
1456       S = FloatingLiteral::Create(*Context, Empty);
1457       break;
1458
1459     case EXPR_IMAGINARY_LITERAL:
1460       S = new (Context) ImaginaryLiteral(Empty);
1461       break;
1462
1463     case EXPR_STRING_LITERAL:
1464       S = StringLiteral::CreateEmpty(*Context,
1465                                      Record[ASTStmtReader::NumExprFields + 1]);
1466       break;
1467
1468     case EXPR_CHARACTER_LITERAL:
1469       S = new (Context) CharacterLiteral(Empty);
1470       break;
1471
1472     case EXPR_PAREN:
1473       S = new (Context) ParenExpr(Empty);
1474       break;
1475
1476     case EXPR_PAREN_LIST:
1477       S = new (Context) ParenListExpr(Empty);
1478       break;
1479
1480     case EXPR_UNARY_OPERATOR:
1481       S = new (Context) UnaryOperator(Empty);
1482       break;
1483
1484     case EXPR_OFFSETOF:
1485       S = OffsetOfExpr::CreateEmpty(*Context,
1486                                     Record[ASTStmtReader::NumExprFields],
1487                                     Record[ASTStmtReader::NumExprFields + 1]);
1488       break;
1489
1490     case EXPR_SIZEOF_ALIGN_OF:
1491       S = new (Context) SizeOfAlignOfExpr(Empty);
1492       break;
1493
1494     case EXPR_ARRAY_SUBSCRIPT:
1495       S = new (Context) ArraySubscriptExpr(Empty);
1496       break;
1497
1498     case EXPR_CALL:
1499       S = new (Context) CallExpr(*Context, Stmt::CallExprClass, Empty);
1500       break;
1501
1502     case EXPR_MEMBER: {
1503       // We load everything here and fully initialize it at creation.
1504       // That way we can use MemberExpr::Create and don't have to duplicate its
1505       // logic with a MemberExpr::CreateEmpty.
1506
1507       assert(Idx == 0);
1508       NestedNameSpecifier *NNS = 0;
1509       SourceRange QualifierRange;
1510       if (Record[Idx++]) { // HasQualifier.
1511         NNS = ReadNestedNameSpecifier(Record, Idx);
1512         QualifierRange = ReadSourceRange(F, Record, Idx);
1513       }
1514
1515       TemplateArgumentListInfo ArgInfo;
1516       unsigned NumTemplateArgs = Record[Idx++];
1517       if (NumTemplateArgs) {
1518         ArgInfo.setLAngleLoc(ReadSourceLocation(F, Record, Idx));
1519         ArgInfo.setRAngleLoc(ReadSourceLocation(F, Record, Idx));
1520         for (unsigned i = 0; i != NumTemplateArgs; ++i)
1521           ArgInfo.addArgument(ReadTemplateArgumentLoc(F, Record, Idx));
1522       }
1523
1524       NamedDecl *FoundD = cast_or_null<NamedDecl>(GetDecl(Record[Idx++]));
1525       AccessSpecifier AS = (AccessSpecifier)Record[Idx++];
1526       DeclAccessPair FoundDecl = DeclAccessPair::make(FoundD, AS);
1527
1528       QualType T = GetType(Record[Idx++]);
1529       ExprValueKind VK = static_cast<ExprValueKind>(Record[Idx++]);
1530       ExprObjectKind OK = static_cast<ExprObjectKind>(Record[Idx++]);
1531       Expr *Base = ReadSubExpr();
1532       ValueDecl *MemberD = cast<ValueDecl>(GetDecl(Record[Idx++]));
1533       SourceLocation MemberLoc = ReadSourceLocation(F, Record, Idx);
1534       DeclarationNameInfo MemberNameInfo(MemberD->getDeclName(), MemberLoc);
1535       bool IsArrow = Record[Idx++];
1536
1537       S = MemberExpr::Create(*Context, Base, IsArrow, NNS, QualifierRange,
1538                              MemberD, FoundDecl, MemberNameInfo,
1539                              NumTemplateArgs ? &ArgInfo : 0, T, VK, OK);
1540       ReadDeclarationNameLoc(F, cast<MemberExpr>(S)->MemberDNLoc,
1541                              MemberD->getDeclName(), Record, Idx);
1542       break;
1543     }
1544
1545     case EXPR_BINARY_OPERATOR:
1546       S = new (Context) BinaryOperator(Empty);
1547       break;
1548
1549     case EXPR_COMPOUND_ASSIGN_OPERATOR:
1550       S = new (Context) CompoundAssignOperator(Empty);
1551       break;
1552
1553     case EXPR_CONDITIONAL_OPERATOR:
1554       S = new (Context) ConditionalOperator(Empty);
1555       break;
1556
1557     case EXPR_IMPLICIT_CAST:
1558       S = ImplicitCastExpr::CreateEmpty(*Context,
1559                        /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
1560       break;
1561
1562     case EXPR_CSTYLE_CAST:
1563       S = CStyleCastExpr::CreateEmpty(*Context,
1564                        /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
1565       break;
1566
1567     case EXPR_COMPOUND_LITERAL:
1568       S = new (Context) CompoundLiteralExpr(Empty);
1569       break;
1570
1571     case EXPR_EXT_VECTOR_ELEMENT:
1572       S = new (Context) ExtVectorElementExpr(Empty);
1573       break;
1574
1575     case EXPR_INIT_LIST:
1576       S = new (Context) InitListExpr(*getContext(), Empty);
1577       break;
1578
1579     case EXPR_DESIGNATED_INIT:
1580       S = DesignatedInitExpr::CreateEmpty(*Context,
1581                                      Record[ASTStmtReader::NumExprFields] - 1);
1582
1583       break;
1584
1585     case EXPR_IMPLICIT_VALUE_INIT:
1586       S = new (Context) ImplicitValueInitExpr(Empty);
1587       break;
1588
1589     case EXPR_VA_ARG:
1590       S = new (Context) VAArgExpr(Empty);
1591       break;
1592
1593     case EXPR_ADDR_LABEL:
1594       S = new (Context) AddrLabelExpr(Empty);
1595       break;
1596
1597     case EXPR_STMT:
1598       S = new (Context) StmtExpr(Empty);
1599       break;
1600
1601     case EXPR_CHOOSE:
1602       S = new (Context) ChooseExpr(Empty);
1603       break;
1604
1605     case EXPR_GNU_NULL:
1606       S = new (Context) GNUNullExpr(Empty);
1607       break;
1608
1609     case EXPR_SHUFFLE_VECTOR:
1610       S = new (Context) ShuffleVectorExpr(Empty);
1611       break;
1612
1613     case EXPR_BLOCK:
1614       S = new (Context) BlockExpr(Empty);
1615       break;
1616
1617     case EXPR_BLOCK_DECL_REF:
1618       S = new (Context) BlockDeclRefExpr(Empty);
1619       break;
1620
1621     case EXPR_OBJC_STRING_LITERAL:
1622       S = new (Context) ObjCStringLiteral(Empty);
1623       break;
1624     case EXPR_OBJC_ENCODE:
1625       S = new (Context) ObjCEncodeExpr(Empty);
1626       break;
1627     case EXPR_OBJC_SELECTOR_EXPR:
1628       S = new (Context) ObjCSelectorExpr(Empty);
1629       break;
1630     case EXPR_OBJC_PROTOCOL_EXPR:
1631       S = new (Context) ObjCProtocolExpr(Empty);
1632       break;
1633     case EXPR_OBJC_IVAR_REF_EXPR:
1634       S = new (Context) ObjCIvarRefExpr(Empty);
1635       break;
1636     case EXPR_OBJC_PROPERTY_REF_EXPR:
1637       S = new (Context) ObjCPropertyRefExpr(Empty);
1638       break;
1639     case EXPR_OBJC_KVC_REF_EXPR:
1640       llvm_unreachable("mismatching AST file");
1641       break;
1642     case EXPR_OBJC_MESSAGE_EXPR:
1643       S = ObjCMessageExpr::CreateEmpty(*Context,
1644                                      Record[ASTStmtReader::NumExprFields]);
1645       break;
1646     case EXPR_OBJC_ISA:
1647       S = new (Context) ObjCIsaExpr(Empty);
1648       break;
1649     case STMT_OBJC_FOR_COLLECTION:
1650       S = new (Context) ObjCForCollectionStmt(Empty);
1651       break;
1652     case STMT_OBJC_CATCH:
1653       S = new (Context) ObjCAtCatchStmt(Empty);
1654       break;
1655     case STMT_OBJC_FINALLY:
1656       S = new (Context) ObjCAtFinallyStmt(Empty);
1657       break;
1658     case STMT_OBJC_AT_TRY:
1659       S = ObjCAtTryStmt::CreateEmpty(*Context,
1660                                      Record[ASTStmtReader::NumStmtFields],
1661                                      Record[ASTStmtReader::NumStmtFields + 1]);
1662       break;
1663     case STMT_OBJC_AT_SYNCHRONIZED:
1664       S = new (Context) ObjCAtSynchronizedStmt(Empty);
1665       break;
1666     case STMT_OBJC_AT_THROW:
1667       S = new (Context) ObjCAtThrowStmt(Empty);
1668       break;
1669
1670     case STMT_CXX_CATCH:
1671       S = new (Context) CXXCatchStmt(Empty);
1672       break;
1673
1674     case STMT_CXX_TRY:
1675       S = CXXTryStmt::Create(*Context, Empty,
1676              /*NumHandlers=*/Record[ASTStmtReader::NumStmtFields]);
1677       break;
1678
1679     case EXPR_CXX_OPERATOR_CALL:
1680       S = new (Context) CXXOperatorCallExpr(*Context, Empty);
1681       break;
1682
1683     case EXPR_CXX_MEMBER_CALL:
1684       S = new (Context) CXXMemberCallExpr(*Context, Empty);
1685       break;
1686
1687     case EXPR_CXX_CONSTRUCT:
1688       S = new (Context) CXXConstructExpr(Empty);
1689       break;
1690
1691     case EXPR_CXX_TEMPORARY_OBJECT:
1692       S = new (Context) CXXTemporaryObjectExpr(Empty);
1693       break;
1694
1695     case EXPR_CXX_STATIC_CAST:
1696       S = CXXStaticCastExpr::CreateEmpty(*Context,
1697                        /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
1698       break;
1699
1700     case EXPR_CXX_DYNAMIC_CAST:
1701       S = CXXDynamicCastExpr::CreateEmpty(*Context,
1702                        /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
1703       break;
1704
1705     case EXPR_CXX_REINTERPRET_CAST:
1706       S = CXXReinterpretCastExpr::CreateEmpty(*Context,
1707                        /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
1708       break;
1709
1710     case EXPR_CXX_CONST_CAST:
1711       S = CXXConstCastExpr::CreateEmpty(*Context);
1712       break;
1713
1714     case EXPR_CXX_FUNCTIONAL_CAST:
1715       S = CXXFunctionalCastExpr::CreateEmpty(*Context,
1716                        /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
1717       break;
1718
1719     case EXPR_CXX_BOOL_LITERAL:
1720       S = new (Context) CXXBoolLiteralExpr(Empty);
1721       break;
1722
1723     case EXPR_CXX_NULL_PTR_LITERAL:
1724       S = new (Context) CXXNullPtrLiteralExpr(Empty);
1725       break;
1726     case EXPR_CXX_TYPEID_EXPR:
1727       S = new (Context) CXXTypeidExpr(Empty, true);
1728       break;
1729     case EXPR_CXX_TYPEID_TYPE:
1730       S = new (Context) CXXTypeidExpr(Empty, false);
1731       break;
1732     case EXPR_CXX_UUIDOF_EXPR:
1733       S = new (Context) CXXUuidofExpr(Empty, true);
1734       break;
1735     case EXPR_CXX_UUIDOF_TYPE:
1736       S = new (Context) CXXUuidofExpr(Empty, false);
1737       break;
1738     case EXPR_CXX_THIS:
1739       S = new (Context) CXXThisExpr(Empty);
1740       break;
1741     case EXPR_CXX_THROW:
1742       S = new (Context) CXXThrowExpr(Empty);
1743       break;
1744     case EXPR_CXX_DEFAULT_ARG: {
1745       bool HasOtherExprStored = Record[ASTStmtReader::NumExprFields];
1746       if (HasOtherExprStored) {
1747         Expr *SubExpr = ReadSubExpr();
1748         S = CXXDefaultArgExpr::Create(*Context, SourceLocation(), 0, SubExpr);
1749       } else
1750         S = new (Context) CXXDefaultArgExpr(Empty);
1751       break;
1752     }
1753     case EXPR_CXX_BIND_TEMPORARY:
1754       S = new (Context) CXXBindTemporaryExpr(Empty);
1755       break;
1756
1757     case EXPR_CXX_SCALAR_VALUE_INIT:
1758       S = new (Context) CXXScalarValueInitExpr(Empty);
1759       break;
1760     case EXPR_CXX_NEW:
1761       S = new (Context) CXXNewExpr(Empty);
1762       break;
1763     case EXPR_CXX_DELETE:
1764       S = new (Context) CXXDeleteExpr(Empty);
1765       break;
1766     case EXPR_CXX_PSEUDO_DESTRUCTOR:
1767       S = new (Context) CXXPseudoDestructorExpr(Empty);
1768       break;
1769
1770     case EXPR_EXPR_WITH_CLEANUPS:
1771       S = new (Context) ExprWithCleanups(Empty);
1772       break;
1773
1774     case EXPR_CXX_DEPENDENT_SCOPE_MEMBER:
1775       S = CXXDependentScopeMemberExpr::CreateEmpty(*Context,
1776                       /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]);
1777       break;
1778
1779     case EXPR_CXX_DEPENDENT_SCOPE_DECL_REF:
1780       S = DependentScopeDeclRefExpr::CreateEmpty(*Context,
1781                       /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]);
1782       break;
1783
1784     case EXPR_CXX_UNRESOLVED_CONSTRUCT:
1785       S = CXXUnresolvedConstructExpr::CreateEmpty(*Context,
1786                               /*NumArgs=*/Record[ASTStmtReader::NumExprFields]);
1787       break;
1788
1789     case EXPR_CXX_UNRESOLVED_MEMBER:
1790       S = UnresolvedMemberExpr::CreateEmpty(*Context,
1791                       /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]);
1792       break;
1793
1794     case EXPR_CXX_UNRESOLVED_LOOKUP:
1795       S = UnresolvedLookupExpr::CreateEmpty(*Context,
1796                       /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]);
1797       break;
1798
1799     case EXPR_CXX_UNARY_TYPE_TRAIT:
1800       S = new (Context) UnaryTypeTraitExpr(Empty);
1801       break;
1802
1803     case EXPR_BINARY_TYPE_TRAIT:
1804       S = new (Context) BinaryTypeTraitExpr(Empty);
1805       break;
1806
1807     case EXPR_CXX_NOEXCEPT:
1808       S = new (Context) CXXNoexceptExpr(Empty);
1809       break;
1810
1811     case EXPR_OPAQUE_VALUE:
1812       S = new (Context) OpaqueValueExpr(Empty);
1813       break;
1814     }
1815
1816     // We hit a STMT_STOP, so we're done with this expression.
1817     if (Finished)
1818       break;
1819
1820     ++NumStatementsRead;
1821
1822     if (S)
1823       Reader.Visit(S);
1824
1825     assert(Idx == Record.size() && "Invalid deserialization of statement");
1826     StmtStack.push_back(S);
1827   }
1828
1829 #ifndef NDEBUG
1830   assert(StmtStack.size() > PrevNumStmts && "Read too many sub stmts!");
1831   assert(StmtStack.size() == PrevNumStmts + 1 && "Extra expressions on stack!");
1832 #endif
1833
1834   return StmtStack.pop_back_val();
1835 }