1 //===--- ASTReaderStmt.cpp - Stmt/Expr Deserialization ----------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // Statement/expression deserialization. This implements the
11 // ASTReader::ReadStmt method.
13 //===----------------------------------------------------------------------===//
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;
23 class ASTStmtReader : public StmtVisitor<ASTStmtReader> {
25 llvm::BitstreamCursor &DeclsCursor;
26 const ASTReader::RecordData &Record;
30 ASTStmtReader(ASTReader &Reader, llvm::BitstreamCursor &Cursor,
31 const ASTReader::RecordData &Record, unsigned &Idx)
32 : Reader(Reader), DeclsCursor(Cursor), Record(Record), Idx(Idx) { }
34 /// \brief The number of record fields required for the Stmt class
36 static const unsigned NumStmtFields = 0;
38 /// \brief The number of record fields required for the Expr class
40 static const unsigned NumExprFields = NumStmtFields + 3;
42 /// \brief Read and initialize a ExplicitTemplateArgumentList structure.
43 void ReadExplicitTemplateArgumentList(ExplicitTemplateArgumentList &ArgList,
44 unsigned NumTemplateArgs);
46 void VisitStmt(Stmt *S);
47 void VisitNullStmt(NullStmt *S);
48 void VisitCompoundStmt(CompoundStmt *S);
49 void VisitSwitchCase(SwitchCase *S);
50 void VisitCaseStmt(CaseStmt *S);
51 void VisitDefaultStmt(DefaultStmt *S);
52 void VisitLabelStmt(LabelStmt *S);
53 void VisitIfStmt(IfStmt *S);
54 void VisitSwitchStmt(SwitchStmt *S);
55 void VisitWhileStmt(WhileStmt *S);
56 void VisitDoStmt(DoStmt *S);
57 void VisitForStmt(ForStmt *S);
58 void VisitGotoStmt(GotoStmt *S);
59 void VisitIndirectGotoStmt(IndirectGotoStmt *S);
60 void VisitContinueStmt(ContinueStmt *S);
61 void VisitBreakStmt(BreakStmt *S);
62 void VisitReturnStmt(ReturnStmt *S);
63 void VisitDeclStmt(DeclStmt *S);
64 void VisitAsmStmt(AsmStmt *S);
65 void VisitExpr(Expr *E);
66 void VisitPredefinedExpr(PredefinedExpr *E);
67 void VisitDeclRefExpr(DeclRefExpr *E);
68 void VisitIntegerLiteral(IntegerLiteral *E);
69 void VisitFloatingLiteral(FloatingLiteral *E);
70 void VisitImaginaryLiteral(ImaginaryLiteral *E);
71 void VisitStringLiteral(StringLiteral *E);
72 void VisitCharacterLiteral(CharacterLiteral *E);
73 void VisitParenExpr(ParenExpr *E);
74 void VisitParenListExpr(ParenListExpr *E);
75 void VisitUnaryOperator(UnaryOperator *E);
76 void VisitOffsetOfExpr(OffsetOfExpr *E);
77 void VisitSizeOfAlignOfExpr(SizeOfAlignOfExpr *E);
78 void VisitArraySubscriptExpr(ArraySubscriptExpr *E);
79 void VisitCallExpr(CallExpr *E);
80 void VisitMemberExpr(MemberExpr *E);
81 void VisitCastExpr(CastExpr *E);
82 void VisitBinaryOperator(BinaryOperator *E);
83 void VisitCompoundAssignOperator(CompoundAssignOperator *E);
84 void VisitConditionalOperator(ConditionalOperator *E);
85 void VisitImplicitCastExpr(ImplicitCastExpr *E);
86 void VisitExplicitCastExpr(ExplicitCastExpr *E);
87 void VisitCStyleCastExpr(CStyleCastExpr *E);
88 void VisitCompoundLiteralExpr(CompoundLiteralExpr *E);
89 void VisitExtVectorElementExpr(ExtVectorElementExpr *E);
90 void VisitInitListExpr(InitListExpr *E);
91 void VisitDesignatedInitExpr(DesignatedInitExpr *E);
92 void VisitImplicitValueInitExpr(ImplicitValueInitExpr *E);
93 void VisitVAArgExpr(VAArgExpr *E);
94 void VisitAddrLabelExpr(AddrLabelExpr *E);
95 void VisitStmtExpr(StmtExpr *E);
96 void VisitTypesCompatibleExpr(TypesCompatibleExpr *E);
97 void VisitChooseExpr(ChooseExpr *E);
98 void VisitGNUNullExpr(GNUNullExpr *E);
99 void VisitShuffleVectorExpr(ShuffleVectorExpr *E);
100 void VisitBlockExpr(BlockExpr *E);
101 void VisitBlockDeclRefExpr(BlockDeclRefExpr *E);
102 void VisitObjCStringLiteral(ObjCStringLiteral *E);
103 void VisitObjCEncodeExpr(ObjCEncodeExpr *E);
104 void VisitObjCSelectorExpr(ObjCSelectorExpr *E);
105 void VisitObjCProtocolExpr(ObjCProtocolExpr *E);
106 void VisitObjCIvarRefExpr(ObjCIvarRefExpr *E);
107 void VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E);
108 void VisitObjCImplicitSetterGetterRefExpr(
109 ObjCImplicitSetterGetterRefExpr *E);
110 void VisitObjCMessageExpr(ObjCMessageExpr *E);
111 void VisitObjCSuperExpr(ObjCSuperExpr *E);
112 void VisitObjCIsaExpr(ObjCIsaExpr *E);
114 void VisitObjCForCollectionStmt(ObjCForCollectionStmt *);
115 void VisitObjCAtCatchStmt(ObjCAtCatchStmt *);
116 void VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *);
117 void VisitObjCAtTryStmt(ObjCAtTryStmt *);
118 void VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *);
119 void VisitObjCAtThrowStmt(ObjCAtThrowStmt *);
122 void VisitCXXCatchStmt(CXXCatchStmt *S);
123 void VisitCXXTryStmt(CXXTryStmt *S);
125 void VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E);
126 void VisitCXXConstructExpr(CXXConstructExpr *E);
127 void VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E);
128 void VisitCXXNamedCastExpr(CXXNamedCastExpr *E);
129 void VisitCXXStaticCastExpr(CXXStaticCastExpr *E);
130 void VisitCXXDynamicCastExpr(CXXDynamicCastExpr *E);
131 void VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *E);
132 void VisitCXXConstCastExpr(CXXConstCastExpr *E);
133 void VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E);
134 void VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E);
135 void VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E);
136 void VisitCXXTypeidExpr(CXXTypeidExpr *E);
137 void VisitCXXThisExpr(CXXThisExpr *E);
138 void VisitCXXThrowExpr(CXXThrowExpr *E);
139 void VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E);
140 void VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E);
142 void VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E);
143 void VisitCXXNewExpr(CXXNewExpr *E);
144 void VisitCXXDeleteExpr(CXXDeleteExpr *E);
145 void VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E);
147 void VisitCXXExprWithTemporaries(CXXExprWithTemporaries *E);
149 void VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E);
150 void VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E);
151 void VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E);
153 void VisitOverloadExpr(OverloadExpr *E);
154 void VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E);
155 void VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E);
157 void VisitUnaryTypeTraitExpr(UnaryTypeTraitExpr *E);
162 ReadExplicitTemplateArgumentList(ExplicitTemplateArgumentList &ArgList,
163 unsigned NumTemplateArgs) {
164 TemplateArgumentListInfo ArgInfo;
165 ArgInfo.setLAngleLoc(Reader.ReadSourceLocation(Record, Idx));
166 ArgInfo.setRAngleLoc(Reader.ReadSourceLocation(Record, Idx));
167 for (unsigned i = 0; i != NumTemplateArgs; ++i)
169 Reader.ReadTemplateArgumentLoc(DeclsCursor, Record, Idx));
170 ArgList.initializeFrom(ArgInfo);
173 void ASTStmtReader::VisitStmt(Stmt *S) {
174 assert(Idx == NumStmtFields && "Incorrect statement field count");
177 void ASTStmtReader::VisitNullStmt(NullStmt *S) {
179 S->setSemiLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
182 void ASTStmtReader::VisitCompoundStmt(CompoundStmt *S) {
184 llvm::SmallVector<Stmt *, 16> Stmts;
185 unsigned NumStmts = Record[Idx++];
187 Stmts.push_back(Reader.ReadSubStmt());
188 S->setStmts(*Reader.getContext(), Stmts.data(), Stmts.size());
189 S->setLBracLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
190 S->setRBracLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
193 void ASTStmtReader::VisitSwitchCase(SwitchCase *S) {
195 Reader.RecordSwitchCaseID(S, Record[Idx++]);
198 void ASTStmtReader::VisitCaseStmt(CaseStmt *S) {
200 S->setLHS(Reader.ReadSubExpr());
201 S->setRHS(Reader.ReadSubExpr());
202 S->setSubStmt(Reader.ReadSubStmt());
203 S->setCaseLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
204 S->setEllipsisLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
205 S->setColonLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
208 void ASTStmtReader::VisitDefaultStmt(DefaultStmt *S) {
210 S->setSubStmt(Reader.ReadSubStmt());
211 S->setDefaultLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
212 S->setColonLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
215 void ASTStmtReader::VisitLabelStmt(LabelStmt *S) {
217 S->setID(Reader.GetIdentifierInfo(Record, Idx));
218 S->setSubStmt(Reader.ReadSubStmt());
219 S->setIdentLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
220 Reader.RecordLabelStmt(S, Record[Idx++]);
223 void ASTStmtReader::VisitIfStmt(IfStmt *S) {
225 S->setConditionVariable(*Reader.getContext(),
226 cast_or_null<VarDecl>(Reader.GetDecl(Record[Idx++])));
227 S->setCond(Reader.ReadSubExpr());
228 S->setThen(Reader.ReadSubStmt());
229 S->setElse(Reader.ReadSubStmt());
230 S->setIfLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
231 S->setElseLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
234 void ASTStmtReader::VisitSwitchStmt(SwitchStmt *S) {
236 S->setConditionVariable(*Reader.getContext(),
237 cast_or_null<VarDecl>(Reader.GetDecl(Record[Idx++])));
238 S->setCond(Reader.ReadSubExpr());
239 S->setBody(Reader.ReadSubStmt());
240 S->setSwitchLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
241 SwitchCase *PrevSC = 0;
242 for (unsigned N = Record.size(); Idx != N; ++Idx) {
243 SwitchCase *SC = Reader.getSwitchCaseWithID(Record[Idx]);
245 PrevSC->setNextSwitchCase(SC);
247 S->setSwitchCaseList(SC);
249 // Retain this SwitchCase, since SwitchStmt::addSwitchCase() would
250 // normally retain it (but we aren't calling addSwitchCase).
256 void ASTStmtReader::VisitWhileStmt(WhileStmt *S) {
258 S->setConditionVariable(*Reader.getContext(),
259 cast_or_null<VarDecl>(Reader.GetDecl(Record[Idx++])));
260 S->setCond(Reader.ReadSubExpr());
261 S->setBody(Reader.ReadSubStmt());
262 S->setWhileLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
265 void ASTStmtReader::VisitDoStmt(DoStmt *S) {
267 S->setCond(Reader.ReadSubExpr());
268 S->setBody(Reader.ReadSubStmt());
269 S->setDoLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
270 S->setWhileLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
271 S->setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
274 void ASTStmtReader::VisitForStmt(ForStmt *S) {
276 S->setInit(Reader.ReadSubStmt());
277 S->setCond(Reader.ReadSubExpr());
278 S->setConditionVariable(*Reader.getContext(),
279 cast_or_null<VarDecl>(Reader.GetDecl(Record[Idx++])));
280 S->setInc(Reader.ReadSubExpr());
281 S->setBody(Reader.ReadSubStmt());
282 S->setForLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
283 S->setLParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
284 S->setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
287 void ASTStmtReader::VisitGotoStmt(GotoStmt *S) {
289 Reader.SetLabelOf(S, Record[Idx++]);
290 S->setGotoLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
291 S->setLabelLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
294 void ASTStmtReader::VisitIndirectGotoStmt(IndirectGotoStmt *S) {
296 S->setGotoLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
297 S->setStarLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
298 S->setTarget(Reader.ReadSubExpr());
301 void ASTStmtReader::VisitContinueStmt(ContinueStmt *S) {
303 S->setContinueLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
306 void ASTStmtReader::VisitBreakStmt(BreakStmt *S) {
308 S->setBreakLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
311 void ASTStmtReader::VisitReturnStmt(ReturnStmt *S) {
313 S->setRetValue(Reader.ReadSubExpr());
314 S->setReturnLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
315 S->setNRVOCandidate(cast_or_null<VarDecl>(Reader.GetDecl(Record[Idx++])));
318 void ASTStmtReader::VisitDeclStmt(DeclStmt *S) {
320 S->setStartLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
321 S->setEndLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
323 if (Idx + 1 == Record.size()) {
324 // Single declaration
325 S->setDeclGroup(DeclGroupRef(Reader.GetDecl(Record[Idx++])));
327 llvm::SmallVector<Decl *, 16> Decls;
328 Decls.reserve(Record.size() - Idx);
329 for (unsigned N = Record.size(); Idx != N; ++Idx)
330 Decls.push_back(Reader.GetDecl(Record[Idx]));
331 S->setDeclGroup(DeclGroupRef(DeclGroup::Create(*Reader.getContext(),
337 void ASTStmtReader::VisitAsmStmt(AsmStmt *S) {
339 unsigned NumOutputs = Record[Idx++];
340 unsigned NumInputs = Record[Idx++];
341 unsigned NumClobbers = Record[Idx++];
342 S->setAsmLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
343 S->setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
344 S->setVolatile(Record[Idx++]);
345 S->setSimple(Record[Idx++]);
346 S->setMSAsm(Record[Idx++]);
348 S->setAsmString(cast_or_null<StringLiteral>(Reader.ReadSubStmt()));
350 // Outputs and inputs
351 llvm::SmallVector<IdentifierInfo *, 16> Names;
352 llvm::SmallVector<StringLiteral*, 16> Constraints;
353 llvm::SmallVector<Stmt*, 16> Exprs;
354 for (unsigned I = 0, N = NumOutputs + NumInputs; I != N; ++I) {
355 Names.push_back(Reader.GetIdentifierInfo(Record, Idx));
356 Constraints.push_back(cast_or_null<StringLiteral>(Reader.ReadSubStmt()));
357 Exprs.push_back(Reader.ReadSubStmt());
361 llvm::SmallVector<StringLiteral*, 16> Clobbers;
362 for (unsigned I = 0; I != NumClobbers; ++I)
363 Clobbers.push_back(cast_or_null<StringLiteral>(Reader.ReadSubStmt()));
365 S->setOutputsAndInputsAndClobbers(*Reader.getContext(),
366 Names.data(), Constraints.data(),
367 Exprs.data(), NumOutputs, NumInputs,
368 Clobbers.data(), NumClobbers);
371 void ASTStmtReader::VisitExpr(Expr *E) {
373 E->setType(Reader.GetType(Record[Idx++]));
374 E->setTypeDependent(Record[Idx++]);
375 E->setValueDependent(Record[Idx++]);
376 assert(Idx == NumExprFields && "Incorrect expression field count");
379 void ASTStmtReader::VisitPredefinedExpr(PredefinedExpr *E) {
381 E->setLocation(SourceLocation::getFromRawEncoding(Record[Idx++]));
382 E->setIdentType((PredefinedExpr::IdentType)Record[Idx++]);
385 void ASTStmtReader::VisitDeclRefExpr(DeclRefExpr *E) {
388 bool HasQualifier = Record[Idx++];
389 unsigned NumTemplateArgs = Record[Idx++];
391 E->DecoratedD.setInt((HasQualifier? DeclRefExpr::HasQualifierFlag : 0) |
392 (NumTemplateArgs ? DeclRefExpr::HasExplicitTemplateArgumentListFlag : 0));
395 E->getNameQualifier()->NNS = Reader.ReadNestedNameSpecifier(Record, Idx);
396 E->getNameQualifier()->Range = Reader.ReadSourceRange(Record, Idx);
400 ReadExplicitTemplateArgumentList(E->getExplicitTemplateArgs(),
403 E->setDecl(cast<ValueDecl>(Reader.GetDecl(Record[Idx++])));
404 // FIXME: read DeclarationNameLoc.
405 E->setLocation(Reader.ReadSourceLocation(Record, Idx));
408 void ASTStmtReader::VisitIntegerLiteral(IntegerLiteral *E) {
410 E->setLocation(SourceLocation::getFromRawEncoding(Record[Idx++]));
411 E->setValue(*Reader.getContext(), Reader.ReadAPInt(Record, Idx));
414 void ASTStmtReader::VisitFloatingLiteral(FloatingLiteral *E) {
416 E->setValue(*Reader.getContext(), Reader.ReadAPFloat(Record, Idx));
417 E->setExact(Record[Idx++]);
418 E->setLocation(SourceLocation::getFromRawEncoding(Record[Idx++]));
421 void ASTStmtReader::VisitImaginaryLiteral(ImaginaryLiteral *E) {
423 E->setSubExpr(Reader.ReadSubExpr());
426 void ASTStmtReader::VisitStringLiteral(StringLiteral *E) {
428 unsigned Len = Record[Idx++];
429 assert(Record[Idx] == E->getNumConcatenated() &&
430 "Wrong number of concatenated tokens!");
432 E->setWide(Record[Idx++]);
435 llvm::SmallString<16> Str(&Record[Idx], &Record[Idx] + Len);
436 E->setString(*Reader.getContext(), Str.str());
439 // Read source locations
440 for (unsigned I = 0, N = E->getNumConcatenated(); I != N; ++I)
441 E->setStrTokenLoc(I, SourceLocation::getFromRawEncoding(Record[Idx++]));
444 void ASTStmtReader::VisitCharacterLiteral(CharacterLiteral *E) {
446 E->setValue(Record[Idx++]);
447 E->setLocation(SourceLocation::getFromRawEncoding(Record[Idx++]));
448 E->setWide(Record[Idx++]);
451 void ASTStmtReader::VisitParenExpr(ParenExpr *E) {
453 E->setLParen(SourceLocation::getFromRawEncoding(Record[Idx++]));
454 E->setRParen(SourceLocation::getFromRawEncoding(Record[Idx++]));
455 E->setSubExpr(Reader.ReadSubExpr());
458 void ASTStmtReader::VisitParenListExpr(ParenListExpr *E) {
460 unsigned NumExprs = Record[Idx++];
461 E->Exprs = new (*Reader.getContext()) Stmt*[NumExprs];
462 for (unsigned i = 0; i != NumExprs; ++i)
463 E->Exprs[i] = Reader.ReadSubStmt();
464 E->NumExprs = NumExprs;
465 E->LParenLoc = Reader.ReadSourceLocation(Record, Idx);
466 E->RParenLoc = Reader.ReadSourceLocation(Record, Idx);
469 void ASTStmtReader::VisitUnaryOperator(UnaryOperator *E) {
471 E->setSubExpr(Reader.ReadSubExpr());
472 E->setOpcode((UnaryOperator::Opcode)Record[Idx++]);
473 E->setOperatorLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
476 void ASTStmtReader::VisitOffsetOfExpr(OffsetOfExpr *E) {
477 typedef OffsetOfExpr::OffsetOfNode Node;
479 assert(E->getNumComponents() == Record[Idx]);
481 assert(E->getNumExpressions() == Record[Idx]);
483 E->setOperatorLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
484 E->setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
485 E->setTypeSourceInfo(Reader.GetTypeSourceInfo(DeclsCursor, Record, Idx));
486 for (unsigned I = 0, N = E->getNumComponents(); I != N; ++I) {
487 Node::Kind Kind = static_cast<Node::Kind>(Record[Idx++]);
488 SourceLocation Start = SourceLocation::getFromRawEncoding(Record[Idx++]);
489 SourceLocation End = SourceLocation::getFromRawEncoding(Record[Idx++]);
492 E->setComponent(I, Node(Start, Record[Idx++], End));
498 dyn_cast_or_null<FieldDecl>(Reader.GetDecl(Record[Idx++])),
502 case Node::Identifier:
503 E->setComponent(I, Node(Start, Reader.GetIdentifier(Record[Idx++]), End));
507 CXXBaseSpecifier *Base = new (*Reader.getContext()) CXXBaseSpecifier();
508 *Base = Reader.ReadCXXBaseSpecifier(DeclsCursor, Record, Idx);
509 E->setComponent(I, Node(Base));
515 for (unsigned I = 0, N = E->getNumExpressions(); I != N; ++I)
516 E->setIndexExpr(I, Reader.ReadSubExpr());
519 void ASTStmtReader::VisitSizeOfAlignOfExpr(SizeOfAlignOfExpr *E) {
521 E->setSizeof(Record[Idx++]);
522 if (Record[Idx] == 0) {
523 E->setArgument(Reader.ReadSubExpr());
526 E->setArgument(Reader.GetTypeSourceInfo(DeclsCursor, Record, Idx));
528 E->setOperatorLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
529 E->setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
532 void ASTStmtReader::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
534 E->setLHS(Reader.ReadSubExpr());
535 E->setRHS(Reader.ReadSubExpr());
536 E->setRBracketLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
539 void ASTStmtReader::VisitCallExpr(CallExpr *E) {
541 E->setNumArgs(*Reader.getContext(), Record[Idx++]);
542 E->setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
543 E->setCallee(Reader.ReadSubExpr());
544 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
545 E->setArg(I, Reader.ReadSubExpr());
548 void ASTStmtReader::VisitMemberExpr(MemberExpr *E) {
549 // Don't call VisitExpr, this is fully initialized at creation.
550 assert(E->getStmtClass() == Stmt::MemberExprClass &&
551 "It's a subclass, we must advance Idx!");
554 void ASTStmtReader::VisitObjCIsaExpr(ObjCIsaExpr *E) {
556 E->setBase(Reader.ReadSubExpr());
557 E->setIsaMemberLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
558 E->setArrow(Record[Idx++]);
561 void ASTStmtReader::VisitCastExpr(CastExpr *E) {
563 unsigned NumBaseSpecs = Record[Idx++];
564 assert(NumBaseSpecs == E->path_size());
565 E->setSubExpr(Reader.ReadSubExpr());
566 E->setCastKind((CastExpr::CastKind)Record[Idx++]);
567 CastExpr::path_iterator BaseI = E->path_begin();
568 while (NumBaseSpecs--) {
569 CXXBaseSpecifier *BaseSpec = new (*Reader.getContext()) CXXBaseSpecifier;
570 *BaseSpec = Reader.ReadCXXBaseSpecifier(DeclsCursor, Record, Idx);
575 void ASTStmtReader::VisitBinaryOperator(BinaryOperator *E) {
577 E->setLHS(Reader.ReadSubExpr());
578 E->setRHS(Reader.ReadSubExpr());
579 E->setOpcode((BinaryOperator::Opcode)Record[Idx++]);
580 E->setOperatorLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
583 void ASTStmtReader::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
584 VisitBinaryOperator(E);
585 E->setComputationLHSType(Reader.GetType(Record[Idx++]));
586 E->setComputationResultType(Reader.GetType(Record[Idx++]));
589 void ASTStmtReader::VisitConditionalOperator(ConditionalOperator *E) {
591 E->setCond(Reader.ReadSubExpr());
592 E->setLHS(Reader.ReadSubExpr());
593 E->setRHS(Reader.ReadSubExpr());
594 E->setSAVE(Reader.ReadSubExpr());
595 E->setQuestionLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
596 E->setColonLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
599 void ASTStmtReader::VisitImplicitCastExpr(ImplicitCastExpr *E) {
601 E->setValueKind(static_cast<ExprValueKind>(Record[Idx++]));
604 void ASTStmtReader::VisitExplicitCastExpr(ExplicitCastExpr *E) {
606 E->setTypeInfoAsWritten(Reader.GetTypeSourceInfo(DeclsCursor, Record, Idx));
609 void ASTStmtReader::VisitCStyleCastExpr(CStyleCastExpr *E) {
610 VisitExplicitCastExpr(E);
611 E->setLParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
612 E->setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
615 void ASTStmtReader::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
617 E->setLParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
618 E->setTypeSourceInfo(Reader.GetTypeSourceInfo(DeclsCursor, Record, Idx));
619 E->setInitializer(Reader.ReadSubExpr());
620 E->setFileScope(Record[Idx++]);
623 void ASTStmtReader::VisitExtVectorElementExpr(ExtVectorElementExpr *E) {
625 E->setBase(Reader.ReadSubExpr());
626 E->setAccessor(Reader.GetIdentifierInfo(Record, Idx));
627 E->setAccessorLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
630 void ASTStmtReader::VisitInitListExpr(InitListExpr *E) {
632 unsigned NumInits = Record[Idx++];
633 E->reserveInits(*Reader.getContext(), NumInits);
634 for (unsigned I = 0; I != NumInits; ++I)
635 E->updateInit(*Reader.getContext(), I, Reader.ReadSubExpr());
636 E->setSyntacticForm(cast_or_null<InitListExpr>(Reader.ReadSubStmt()));
637 E->setLBraceLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
638 E->setRBraceLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
639 E->setInitializedFieldInUnion(
640 cast_or_null<FieldDecl>(Reader.GetDecl(Record[Idx++])));
641 E->sawArrayRangeDesignator(Record[Idx++]);
644 void ASTStmtReader::VisitDesignatedInitExpr(DesignatedInitExpr *E) {
645 typedef DesignatedInitExpr::Designator Designator;
648 unsigned NumSubExprs = Record[Idx++];
649 assert(NumSubExprs == E->getNumSubExprs() && "Wrong number of subexprs");
650 for (unsigned I = 0; I != NumSubExprs; ++I)
651 E->setSubExpr(I, Reader.ReadSubExpr());
652 E->setEqualOrColonLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
653 E->setGNUSyntax(Record[Idx++]);
655 llvm::SmallVector<Designator, 4> Designators;
656 while (Idx < Record.size()) {
657 switch ((DesignatorTypes)Record[Idx++]) {
658 case DESIG_FIELD_DECL: {
659 FieldDecl *Field = cast<FieldDecl>(Reader.GetDecl(Record[Idx++]));
660 SourceLocation DotLoc
661 = SourceLocation::getFromRawEncoding(Record[Idx++]);
662 SourceLocation FieldLoc
663 = SourceLocation::getFromRawEncoding(Record[Idx++]);
664 Designators.push_back(Designator(Field->getIdentifier(), DotLoc,
666 Designators.back().setField(Field);
670 case DESIG_FIELD_NAME: {
671 const IdentifierInfo *Name = Reader.GetIdentifierInfo(Record, Idx);
672 SourceLocation DotLoc
673 = SourceLocation::getFromRawEncoding(Record[Idx++]);
674 SourceLocation FieldLoc
675 = SourceLocation::getFromRawEncoding(Record[Idx++]);
676 Designators.push_back(Designator(Name, DotLoc, FieldLoc));
681 unsigned Index = Record[Idx++];
682 SourceLocation LBracketLoc
683 = SourceLocation::getFromRawEncoding(Record[Idx++]);
684 SourceLocation RBracketLoc
685 = SourceLocation::getFromRawEncoding(Record[Idx++]);
686 Designators.push_back(Designator(Index, LBracketLoc, RBracketLoc));
690 case DESIG_ARRAY_RANGE: {
691 unsigned Index = Record[Idx++];
692 SourceLocation LBracketLoc
693 = SourceLocation::getFromRawEncoding(Record[Idx++]);
694 SourceLocation EllipsisLoc
695 = SourceLocation::getFromRawEncoding(Record[Idx++]);
696 SourceLocation RBracketLoc
697 = SourceLocation::getFromRawEncoding(Record[Idx++]);
698 Designators.push_back(Designator(Index, LBracketLoc, EllipsisLoc,
704 E->setDesignators(*Reader.getContext(),
705 Designators.data(), Designators.size());
708 void ASTStmtReader::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
712 void ASTStmtReader::VisitVAArgExpr(VAArgExpr *E) {
714 E->setSubExpr(Reader.ReadSubExpr());
715 E->setWrittenTypeInfo(Reader.GetTypeSourceInfo(DeclsCursor, Record, Idx));
716 E->setBuiltinLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
717 E->setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
720 void ASTStmtReader::VisitAddrLabelExpr(AddrLabelExpr *E) {
722 E->setAmpAmpLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
723 E->setLabelLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
724 Reader.SetLabelOf(E, Record[Idx++]);
727 void ASTStmtReader::VisitStmtExpr(StmtExpr *E) {
729 E->setLParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
730 E->setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
731 E->setSubStmt(cast_or_null<CompoundStmt>(Reader.ReadSubStmt()));
734 void ASTStmtReader::VisitTypesCompatibleExpr(TypesCompatibleExpr *E) {
736 E->setArgTInfo1(Reader.GetTypeSourceInfo(DeclsCursor, Record, Idx));
737 E->setArgTInfo2(Reader.GetTypeSourceInfo(DeclsCursor, Record, Idx));
738 E->setBuiltinLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
739 E->setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
742 void ASTStmtReader::VisitChooseExpr(ChooseExpr *E) {
744 E->setCond(Reader.ReadSubExpr());
745 E->setLHS(Reader.ReadSubExpr());
746 E->setRHS(Reader.ReadSubExpr());
747 E->setBuiltinLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
748 E->setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
751 void ASTStmtReader::VisitGNUNullExpr(GNUNullExpr *E) {
753 E->setTokenLocation(SourceLocation::getFromRawEncoding(Record[Idx++]));
756 void ASTStmtReader::VisitShuffleVectorExpr(ShuffleVectorExpr *E) {
758 llvm::SmallVector<Expr *, 16> Exprs;
759 unsigned NumExprs = Record[Idx++];
761 Exprs.push_back(Reader.ReadSubExpr());
762 E->setExprs(*Reader.getContext(), Exprs.data(), Exprs.size());
763 E->setBuiltinLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
764 E->setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
767 void ASTStmtReader::VisitBlockExpr(BlockExpr *E) {
769 E->setBlockDecl(cast_or_null<BlockDecl>(Reader.GetDecl(Record[Idx++])));
770 E->setHasBlockDeclRefExprs(Record[Idx++]);
773 void ASTStmtReader::VisitBlockDeclRefExpr(BlockDeclRefExpr *E) {
775 E->setDecl(cast<ValueDecl>(Reader.GetDecl(Record[Idx++])));
776 E->setLocation(SourceLocation::getFromRawEncoding(Record[Idx++]));
777 E->setByRef(Record[Idx++]);
778 E->setConstQualAdded(Record[Idx++]);
779 E->setCopyConstructorExpr(Reader.ReadSubExpr());
782 //===----------------------------------------------------------------------===//
783 // Objective-C Expressions and Statements
785 void ASTStmtReader::VisitObjCStringLiteral(ObjCStringLiteral *E) {
787 E->setString(cast<StringLiteral>(Reader.ReadSubStmt()));
788 E->setAtLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
791 void ASTStmtReader::VisitObjCEncodeExpr(ObjCEncodeExpr *E) {
793 E->setEncodedTypeSourceInfo(Reader.GetTypeSourceInfo(DeclsCursor,Record,Idx));
794 E->setAtLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
795 E->setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
798 void ASTStmtReader::VisitObjCSelectorExpr(ObjCSelectorExpr *E) {
800 E->setSelector(Reader.GetSelector(Record, Idx));
801 E->setAtLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
802 E->setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
805 void ASTStmtReader::VisitObjCProtocolExpr(ObjCProtocolExpr *E) {
807 E->setProtocol(cast<ObjCProtocolDecl>(Reader.GetDecl(Record[Idx++])));
808 E->setAtLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
809 E->setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
812 void ASTStmtReader::VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
814 E->setDecl(cast<ObjCIvarDecl>(Reader.GetDecl(Record[Idx++])));
815 E->setLocation(SourceLocation::getFromRawEncoding(Record[Idx++]));
816 E->setBase(Reader.ReadSubExpr());
817 E->setIsArrow(Record[Idx++]);
818 E->setIsFreeIvar(Record[Idx++]);
821 void ASTStmtReader::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
823 E->setProperty(cast<ObjCPropertyDecl>(Reader.GetDecl(Record[Idx++])));
824 E->setLocation(SourceLocation::getFromRawEncoding(Record[Idx++]));
825 E->setBase(Reader.ReadSubExpr());
828 void ASTStmtReader::VisitObjCImplicitSetterGetterRefExpr(
829 ObjCImplicitSetterGetterRefExpr *E) {
832 cast_or_null<ObjCMethodDecl>(Reader.GetDecl(Record[Idx++])));
834 cast_or_null<ObjCMethodDecl>(Reader.GetDecl(Record[Idx++])));
836 cast_or_null<ObjCInterfaceDecl>(Reader.GetDecl(Record[Idx++])));
837 E->setBase(Reader.ReadSubExpr());
838 E->setLocation(SourceLocation::getFromRawEncoding(Record[Idx++]));
839 E->setClassLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
842 void ASTStmtReader::VisitObjCMessageExpr(ObjCMessageExpr *E) {
844 assert(Record[Idx] == E->getNumArgs());
846 ObjCMessageExpr::ReceiverKind Kind
847 = static_cast<ObjCMessageExpr::ReceiverKind>(Record[Idx++]);
849 case ObjCMessageExpr::Instance:
850 E->setInstanceReceiver(Reader.ReadSubExpr());
853 case ObjCMessageExpr::Class:
854 E->setClassReceiver(Reader.GetTypeSourceInfo(DeclsCursor, Record, Idx));
857 case ObjCMessageExpr::SuperClass:
858 case ObjCMessageExpr::SuperInstance: {
859 QualType T = Reader.GetType(Record[Idx++]);
860 SourceLocation SuperLoc = SourceLocation::getFromRawEncoding(Record[Idx++]);
861 E->setSuper(SuperLoc, T, Kind == ObjCMessageExpr::SuperInstance);
866 assert(Kind == E->getReceiverKind());
869 E->setMethodDecl(cast_or_null<ObjCMethodDecl>(Reader.GetDecl(Record[Idx++])));
871 E->setSelector(Reader.GetSelector(Record, Idx));
873 E->setLeftLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
874 E->setRightLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
876 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
877 E->setArg(I, Reader.ReadSubExpr());
880 void ASTStmtReader::VisitObjCSuperExpr(ObjCSuperExpr *E) {
882 E->setLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
885 void ASTStmtReader::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) {
887 S->setElement(Reader.ReadSubStmt());
888 S->setCollection(Reader.ReadSubExpr());
889 S->setBody(Reader.ReadSubStmt());
890 S->setForLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
891 S->setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
894 void ASTStmtReader::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) {
896 S->setCatchBody(Reader.ReadSubStmt());
897 S->setCatchParamDecl(cast_or_null<VarDecl>(Reader.GetDecl(Record[Idx++])));
898 S->setAtCatchLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
899 S->setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
902 void ASTStmtReader::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
904 S->setFinallyBody(Reader.ReadSubStmt());
905 S->setAtFinallyLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
908 void ASTStmtReader::VisitObjCAtTryStmt(ObjCAtTryStmt *S) {
910 assert(Record[Idx] == S->getNumCatchStmts());
912 bool HasFinally = Record[Idx++];
913 S->setTryBody(Reader.ReadSubStmt());
914 for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I)
915 S->setCatchStmt(I, cast_or_null<ObjCAtCatchStmt>(Reader.ReadSubStmt()));
918 S->setFinallyStmt(Reader.ReadSubStmt());
919 S->setAtTryLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
922 void ASTStmtReader::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S) {
924 S->setSynchExpr(Reader.ReadSubStmt());
925 S->setSynchBody(Reader.ReadSubStmt());
926 S->setAtSynchronizedLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
929 void ASTStmtReader::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) {
931 S->setThrowExpr(Reader.ReadSubStmt());
932 S->setThrowLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
935 //===----------------------------------------------------------------------===//
936 // C++ Expressions and Statements
937 //===----------------------------------------------------------------------===//
939 void ASTStmtReader::VisitCXXCatchStmt(CXXCatchStmt *S) {
941 S->CatchLoc = Reader.ReadSourceLocation(Record, Idx);
942 S->ExceptionDecl = cast_or_null<VarDecl>(Reader.GetDecl(Record[Idx++]));
943 S->HandlerBlock = Reader.ReadSubStmt();
946 void ASTStmtReader::VisitCXXTryStmt(CXXTryStmt *S) {
948 assert(Record[Idx] == S->getNumHandlers() && "NumStmtFields is wrong ?");
950 S->TryLoc = Reader.ReadSourceLocation(Record, Idx);
951 S->getStmts()[0] = Reader.ReadSubStmt();
952 for (unsigned i = 0, e = S->getNumHandlers(); i != e; ++i)
953 S->getStmts()[i + 1] = Reader.ReadSubStmt();
956 void ASTStmtReader::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
958 E->setOperator((OverloadedOperatorKind)Record[Idx++]);
961 void ASTStmtReader::VisitCXXConstructExpr(CXXConstructExpr *E) {
963 E->NumArgs = Record[Idx++];
965 E->Args = new (*Reader.getContext()) Stmt*[E->NumArgs];
966 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
967 E->setArg(I, Reader.ReadSubExpr());
968 E->setConstructor(cast<CXXConstructorDecl>(Reader.GetDecl(Record[Idx++])));
969 E->setLocation(SourceLocation::getFromRawEncoding(Record[Idx++]));
970 E->setElidable(Record[Idx++]);
971 E->setRequiresZeroInitialization(Record[Idx++]);
972 E->setConstructionKind((CXXConstructExpr::ConstructionKind)Record[Idx++]);
975 void ASTStmtReader::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E) {
976 VisitCXXConstructExpr(E);
977 E->TyBeginLoc = Reader.ReadSourceLocation(Record, Idx);
978 E->RParenLoc = Reader.ReadSourceLocation(Record, Idx);
981 void ASTStmtReader::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) {
982 VisitExplicitCastExpr(E);
983 E->setOperatorLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
986 void ASTStmtReader::VisitCXXStaticCastExpr(CXXStaticCastExpr *E) {
987 return VisitCXXNamedCastExpr(E);
990 void ASTStmtReader::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *E) {
991 return VisitCXXNamedCastExpr(E);
994 void ASTStmtReader::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *E) {
995 return VisitCXXNamedCastExpr(E);
998 void ASTStmtReader::VisitCXXConstCastExpr(CXXConstCastExpr *E) {
999 return VisitCXXNamedCastExpr(E);
1002 void ASTStmtReader::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E) {
1003 VisitExplicitCastExpr(E);
1004 E->setTypeBeginLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
1005 E->setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
1008 void ASTStmtReader::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
1010 E->setValue(Record[Idx++]);
1011 E->setLocation(SourceLocation::getFromRawEncoding(Record[Idx++]));
1014 void ASTStmtReader::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) {
1016 E->setLocation(SourceLocation::getFromRawEncoding(Record[Idx++]));
1019 void ASTStmtReader::VisitCXXTypeidExpr(CXXTypeidExpr *E) {
1021 E->setSourceRange(Reader.ReadSourceRange(Record, Idx));
1022 if (E->isTypeOperand()) { // typeid(int)
1023 E->setTypeOperandSourceInfo(
1024 Reader.GetTypeSourceInfo(DeclsCursor, Record, Idx));
1029 E->setExprOperand(Reader.ReadSubExpr());
1032 void ASTStmtReader::VisitCXXThisExpr(CXXThisExpr *E) {
1034 E->setLocation(SourceLocation::getFromRawEncoding(Record[Idx++]));
1035 E->setImplicit(Record[Idx++]);
1038 void ASTStmtReader::VisitCXXThrowExpr(CXXThrowExpr *E) {
1040 E->setThrowLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
1041 E->setSubExpr(Reader.ReadSubExpr());
1044 void ASTStmtReader::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
1047 assert(Record[Idx] == E->Param.getInt() && "We messed up at creation ?");
1048 ++Idx; // HasOtherExprStored and SubExpr was handled during creation.
1049 E->Param.setPointer(cast<ParmVarDecl>(Reader.GetDecl(Record[Idx++])));
1050 E->Loc = Reader.ReadSourceLocation(Record, Idx);
1053 void ASTStmtReader::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
1055 E->setTemporary(Reader.ReadCXXTemporary(Record, Idx));
1056 E->setSubExpr(Reader.ReadSubExpr());
1059 void ASTStmtReader::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
1061 E->setTypeBeginLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
1062 E->setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
1065 void ASTStmtReader::VisitCXXNewExpr(CXXNewExpr *E) {
1067 E->setGlobalNew(Record[Idx++]);
1068 E->setHasInitializer(Record[Idx++]);
1069 bool isArray = Record[Idx++];
1070 unsigned NumPlacementArgs = Record[Idx++];
1071 unsigned NumCtorArgs = Record[Idx++];
1072 E->setOperatorNew(cast_or_null<FunctionDecl>(Reader.GetDecl(Record[Idx++])));
1073 E->setOperatorDelete(
1074 cast_or_null<FunctionDecl>(Reader.GetDecl(Record[Idx++])));
1076 cast_or_null<CXXConstructorDecl>(Reader.GetDecl(Record[Idx++])));
1077 SourceRange TypeIdParens;
1078 TypeIdParens.setBegin(SourceLocation::getFromRawEncoding(Record[Idx++]));
1079 TypeIdParens.setEnd(SourceLocation::getFromRawEncoding(Record[Idx++]));
1080 E->TypeIdParens = TypeIdParens;
1081 E->setStartLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
1082 E->setEndLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
1084 E->AllocateArgsArray(*Reader.getContext(), isArray, NumPlacementArgs,
1087 // Install all the subexpressions.
1088 for (CXXNewExpr::raw_arg_iterator I = E->raw_arg_begin(),e = E->raw_arg_end();
1090 *I = Reader.ReadSubStmt();
1093 void ASTStmtReader::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
1095 E->setGlobalDelete(Record[Idx++]);
1096 E->setArrayForm(Record[Idx++]);
1097 E->setOperatorDelete(
1098 cast_or_null<FunctionDecl>(Reader.GetDecl(Record[Idx++])));
1099 E->setArgument(Reader.ReadSubExpr());
1100 E->setStartLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
1103 void ASTStmtReader::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) {
1106 E->setBase(Reader.ReadSubExpr());
1107 E->setArrow(Record[Idx++]);
1108 E->setOperatorLoc(Reader.ReadSourceLocation(Record, Idx));
1109 E->setQualifier(Reader.ReadNestedNameSpecifier(Record, Idx));
1110 E->setQualifierRange(Reader.ReadSourceRange(Record, Idx));
1111 E->setScopeTypeInfo(Reader.GetTypeSourceInfo(DeclsCursor, Record, Idx));
1112 E->setColonColonLoc(Reader.ReadSourceLocation(Record, Idx));
1113 E->setTildeLoc(Reader.ReadSourceLocation(Record, Idx));
1115 IdentifierInfo *II = Reader.GetIdentifierInfo(Record, Idx);
1117 E->setDestroyedType(II, Reader.ReadSourceLocation(Record, Idx));
1119 E->setDestroyedType(Reader.GetTypeSourceInfo(DeclsCursor, Record, Idx));
1122 void ASTStmtReader::VisitCXXExprWithTemporaries(CXXExprWithTemporaries *E) {
1124 unsigned NumTemps = Record[Idx++];
1126 E->setNumTemporaries(*Reader.getContext(), NumTemps);
1127 for (unsigned i = 0; i != NumTemps; ++i)
1128 E->setTemporary(i, Reader.ReadCXXTemporary(Record, Idx));
1130 E->setSubExpr(Reader.ReadSubExpr());
1134 ASTStmtReader::VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E){
1137 unsigned NumTemplateArgs = Record[Idx++];
1138 assert((NumTemplateArgs != 0) == E->hasExplicitTemplateArgs() &&
1139 "Read wrong record during creation ?");
1140 if (E->hasExplicitTemplateArgs())
1141 ReadExplicitTemplateArgumentList(E->getExplicitTemplateArgs(),
1144 E->setBase(Reader.ReadSubExpr());
1145 E->setBaseType(Reader.GetType(Record[Idx++]));
1146 E->setArrow(Record[Idx++]);
1147 E->setOperatorLoc(Reader.ReadSourceLocation(Record, Idx));
1148 E->setQualifier(Reader.ReadNestedNameSpecifier(Record, Idx));
1149 E->setQualifierRange(Reader.ReadSourceRange(Record, Idx));
1150 E->setFirstQualifierFoundInScope(
1151 cast_or_null<NamedDecl>(Reader.GetDecl(Record[Idx++])));
1152 // FIXME: read whole DeclarationNameInfo.
1153 E->setMember(Reader.ReadDeclarationName(Record, Idx));
1154 E->setMemberLoc(Reader.ReadSourceLocation(Record, Idx));
1158 ASTStmtReader::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) {
1161 unsigned NumTemplateArgs = Record[Idx++];
1162 assert((NumTemplateArgs != 0) == E->hasExplicitTemplateArgs() &&
1163 "Read wrong record during creation ?");
1164 if (E->hasExplicitTemplateArgs())
1165 ReadExplicitTemplateArgumentList(E->getExplicitTemplateArgs(),
1168 // FIXME: read whole DeclarationNameInfo.
1169 E->setDeclName(Reader.ReadDeclarationName(Record, Idx));
1170 E->setLocation(Reader.ReadSourceLocation(Record, Idx));
1171 E->setQualifierRange(Reader.ReadSourceRange(Record, Idx));
1172 E->setQualifier(Reader.ReadNestedNameSpecifier(Record, Idx));
1176 ASTStmtReader::VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E) {
1178 assert(Record[Idx] == E->arg_size() && "Read wrong record during creation ?");
1180 for (unsigned I = 0, N = E->arg_size(); I != N; ++I)
1181 E->setArg(I, Reader.ReadSubExpr());
1182 E->setTypeBeginLoc(Reader.ReadSourceLocation(Record, Idx));
1183 E->setTypeAsWritten(Reader.GetType(Record[Idx++]));
1184 E->setLParenLoc(Reader.ReadSourceLocation(Record, Idx));
1185 E->setRParenLoc(Reader.ReadSourceLocation(Record, Idx));
1188 void ASTStmtReader::VisitOverloadExpr(OverloadExpr *E) {
1191 unsigned NumTemplateArgs = Record[Idx++];
1192 assert((NumTemplateArgs != 0) == E->hasExplicitTemplateArgs() &&
1193 "Read wrong record during creation ?");
1194 if (E->hasExplicitTemplateArgs())
1195 ReadExplicitTemplateArgumentList(E->getExplicitTemplateArgs(),
1198 unsigned NumDecls = Record[Idx++];
1199 UnresolvedSet<8> Decls;
1200 for (unsigned i = 0; i != NumDecls; ++i) {
1201 NamedDecl *D = cast<NamedDecl>(Reader.GetDecl(Record[Idx++]));
1202 AccessSpecifier AS = (AccessSpecifier)Record[Idx++];
1203 Decls.addDecl(D, AS);
1205 E->initializeResults(*Reader.getContext(), Decls.begin(), Decls.end());
1207 // FIXME: read whole DeclarationNameInfo.
1208 E->setName(Reader.ReadDeclarationName(Record, Idx));
1209 E->setQualifier(Reader.ReadNestedNameSpecifier(Record, Idx));
1210 E->setQualifierRange(Reader.ReadSourceRange(Record, Idx));
1211 E->setNameLoc(Reader.ReadSourceLocation(Record, Idx));
1214 void ASTStmtReader::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) {
1215 VisitOverloadExpr(E);
1216 E->setArrow(Record[Idx++]);
1217 E->setHasUnresolvedUsing(Record[Idx++]);
1218 E->setBase(Reader.ReadSubExpr());
1219 E->setBaseType(Reader.GetType(Record[Idx++]));
1220 E->setOperatorLoc(Reader.ReadSourceLocation(Record, Idx));
1223 void ASTStmtReader::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) {
1224 VisitOverloadExpr(E);
1225 E->setRequiresADL(Record[Idx++]);
1226 E->setOverloaded(Record[Idx++]);
1227 E->setNamingClass(cast_or_null<CXXRecordDecl>(Reader.GetDecl(Record[Idx++])));
1230 void ASTStmtReader::VisitUnaryTypeTraitExpr(UnaryTypeTraitExpr *E) {
1232 E->UTT = (UnaryTypeTrait)Record[Idx++];
1233 SourceRange Range = Reader.ReadSourceRange(Record, Idx);
1234 E->Loc = Range.getBegin();
1235 E->RParen = Range.getEnd();
1236 E->QueriedType = Reader.GetType(Record[Idx++]);
1239 Stmt *ASTReader::ReadStmt(llvm::BitstreamCursor &Cursor) {
1240 switch (ReadingKind) {
1243 return ReadStmtFromStream(Cursor);
1245 return ReadSubStmt();
1248 llvm_unreachable("ReadingKind not set ?");
1252 Expr *ASTReader::ReadExpr(llvm::BitstreamCursor &Cursor) {
1253 return cast_or_null<Expr>(ReadStmt(Cursor));
1256 Expr *ASTReader::ReadSubExpr() {
1257 return cast_or_null<Expr>(ReadSubStmt());
1260 // Within the bitstream, expressions are stored in Reverse Polish
1261 // Notation, with each of the subexpressions preceding the
1262 // expression they are stored in. Subexpressions are stored from last to first.
1263 // To evaluate expressions, we continue reading expressions and placing them on
1264 // the stack, with expressions having operands removing those operands from the
1265 // stack. Evaluation terminates when we see a STMT_STOP record, and
1266 // the single remaining expression on the stack is our result.
1267 Stmt *ASTReader::ReadStmtFromStream(llvm::BitstreamCursor &Cursor) {
1269 ReadingKindTracker ReadingKind(Read_Stmt, *this);
1272 unsigned PrevNumStmts = StmtStack.size();
1277 ASTStmtReader Reader(*this, Cursor, Record, Idx);
1278 Stmt::EmptyShell Empty;
1281 unsigned Code = Cursor.ReadCode();
1282 if (Code == llvm::bitc::END_BLOCK) {
1283 if (Cursor.ReadBlockEnd()) {
1284 Error("error at end of block in AST file");
1290 if (Code == llvm::bitc::ENTER_SUBBLOCK) {
1291 // No known subblocks, always skip them.
1292 Cursor.ReadSubBlockID();
1293 if (Cursor.SkipBlock()) {
1294 Error("malformed block record in AST file");
1300 if (Code == llvm::bitc::DEFINE_ABBREV) {
1301 Cursor.ReadAbbrevRecord();
1308 bool Finished = false;
1309 switch ((StmtCode)Cursor.ReadRecord(Code, Record)) {
1319 S = new (Context) NullStmt(Empty);
1323 S = new (Context) CompoundStmt(Empty);
1327 S = new (Context) CaseStmt(Empty);
1331 S = new (Context) DefaultStmt(Empty);
1335 S = new (Context) LabelStmt(Empty);
1339 S = new (Context) IfStmt(Empty);
1343 S = new (Context) SwitchStmt(Empty);
1347 S = new (Context) WhileStmt(Empty);
1351 S = new (Context) DoStmt(Empty);
1355 S = new (Context) ForStmt(Empty);
1359 S = new (Context) GotoStmt(Empty);
1362 case STMT_INDIRECT_GOTO:
1363 S = new (Context) IndirectGotoStmt(Empty);
1367 S = new (Context) ContinueStmt(Empty);
1371 S = new (Context) BreakStmt(Empty);
1375 S = new (Context) ReturnStmt(Empty);
1379 S = new (Context) DeclStmt(Empty);
1383 S = new (Context) AsmStmt(Empty);
1386 case EXPR_PREDEFINED:
1387 S = new (Context) PredefinedExpr(Empty);
1391 S = DeclRefExpr::CreateEmpty(*Context,
1392 /*HasQualifier=*/Record[ASTStmtReader::NumExprFields],
1393 /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields + 1]);
1396 case EXPR_INTEGER_LITERAL:
1397 S = IntegerLiteral::Create(*Context, Empty);
1400 case EXPR_FLOATING_LITERAL:
1401 S = FloatingLiteral::Create(*Context, Empty);
1404 case EXPR_IMAGINARY_LITERAL:
1405 S = new (Context) ImaginaryLiteral(Empty);
1408 case EXPR_STRING_LITERAL:
1409 S = StringLiteral::CreateEmpty(*Context,
1410 Record[ASTStmtReader::NumExprFields + 1]);
1413 case EXPR_CHARACTER_LITERAL:
1414 S = new (Context) CharacterLiteral(Empty);
1418 S = new (Context) ParenExpr(Empty);
1421 case EXPR_PAREN_LIST:
1422 S = new (Context) ParenListExpr(Empty);
1425 case EXPR_UNARY_OPERATOR:
1426 S = new (Context) UnaryOperator(Empty);
1430 S = OffsetOfExpr::CreateEmpty(*Context,
1431 Record[ASTStmtReader::NumExprFields],
1432 Record[ASTStmtReader::NumExprFields + 1]);
1435 case EXPR_SIZEOF_ALIGN_OF:
1436 S = new (Context) SizeOfAlignOfExpr(Empty);
1439 case EXPR_ARRAY_SUBSCRIPT:
1440 S = new (Context) ArraySubscriptExpr(Empty);
1444 S = new (Context) CallExpr(*Context, Stmt::CallExprClass, Empty);
1448 // We load everything here and fully initialize it at creation.
1449 // That way we can use MemberExpr::Create and don't have to duplicate its
1450 // logic with a MemberExpr::CreateEmpty.
1453 NestedNameSpecifier *NNS = 0;
1454 SourceRange QualifierRange;
1455 if (Record[Idx++]) { // HasQualifier.
1456 NNS = ReadNestedNameSpecifier(Record, Idx);
1457 QualifierRange = ReadSourceRange(Record, Idx);
1460 TemplateArgumentListInfo ArgInfo;
1461 unsigned NumTemplateArgs = Record[Idx++];
1462 if (NumTemplateArgs) {
1463 ArgInfo.setLAngleLoc(ReadSourceLocation(Record, Idx));
1464 ArgInfo.setRAngleLoc(ReadSourceLocation(Record, Idx));
1465 for (unsigned i = 0; i != NumTemplateArgs; ++i)
1466 ArgInfo.addArgument(ReadTemplateArgumentLoc(Cursor, Record, Idx));
1469 NamedDecl *FoundD = cast_or_null<NamedDecl>(GetDecl(Record[Idx++]));
1470 AccessSpecifier AS = (AccessSpecifier)Record[Idx++];
1471 DeclAccessPair FoundDecl = DeclAccessPair::make(FoundD, AS);
1473 QualType T = GetType(Record[Idx++]);
1474 Expr *Base = ReadSubExpr();
1475 ValueDecl *MemberD = cast<ValueDecl>(GetDecl(Record[Idx++]));
1476 // FIXME: read DeclarationNameLoc.
1477 SourceLocation MemberLoc = ReadSourceLocation(Record, Idx);
1478 DeclarationNameInfo MemberNameInfo(MemberD->getDeclName(), MemberLoc);
1479 bool IsArrow = Record[Idx++];
1481 S = MemberExpr::Create(*Context, Base, IsArrow, NNS, QualifierRange,
1482 MemberD, FoundDecl, MemberNameInfo,
1483 NumTemplateArgs ? &ArgInfo : 0, T);
1487 case EXPR_BINARY_OPERATOR:
1488 S = new (Context) BinaryOperator(Empty);
1491 case EXPR_COMPOUND_ASSIGN_OPERATOR:
1492 S = new (Context) CompoundAssignOperator(Empty);
1495 case EXPR_CONDITIONAL_OPERATOR:
1496 S = new (Context) ConditionalOperator(Empty);
1499 case EXPR_IMPLICIT_CAST:
1500 S = ImplicitCastExpr::CreateEmpty(*Context,
1501 /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
1504 case EXPR_CSTYLE_CAST:
1505 S = CStyleCastExpr::CreateEmpty(*Context,
1506 /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
1509 case EXPR_COMPOUND_LITERAL:
1510 S = new (Context) CompoundLiteralExpr(Empty);
1513 case EXPR_EXT_VECTOR_ELEMENT:
1514 S = new (Context) ExtVectorElementExpr(Empty);
1517 case EXPR_INIT_LIST:
1518 S = new (Context) InitListExpr(*getContext(), Empty);
1521 case EXPR_DESIGNATED_INIT:
1522 S = DesignatedInitExpr::CreateEmpty(*Context,
1523 Record[ASTStmtReader::NumExprFields] - 1);
1527 case EXPR_IMPLICIT_VALUE_INIT:
1528 S = new (Context) ImplicitValueInitExpr(Empty);
1532 S = new (Context) VAArgExpr(Empty);
1535 case EXPR_ADDR_LABEL:
1536 S = new (Context) AddrLabelExpr(Empty);
1540 S = new (Context) StmtExpr(Empty);
1543 case EXPR_TYPES_COMPATIBLE:
1544 S = new (Context) TypesCompatibleExpr(Empty);
1548 S = new (Context) ChooseExpr(Empty);
1552 S = new (Context) GNUNullExpr(Empty);
1555 case EXPR_SHUFFLE_VECTOR:
1556 S = new (Context) ShuffleVectorExpr(Empty);
1560 S = new (Context) BlockExpr(Empty);
1563 case EXPR_BLOCK_DECL_REF:
1564 S = new (Context) BlockDeclRefExpr(Empty);
1567 case EXPR_OBJC_STRING_LITERAL:
1568 S = new (Context) ObjCStringLiteral(Empty);
1570 case EXPR_OBJC_ENCODE:
1571 S = new (Context) ObjCEncodeExpr(Empty);
1573 case EXPR_OBJC_SELECTOR_EXPR:
1574 S = new (Context) ObjCSelectorExpr(Empty);
1576 case EXPR_OBJC_PROTOCOL_EXPR:
1577 S = new (Context) ObjCProtocolExpr(Empty);
1579 case EXPR_OBJC_IVAR_REF_EXPR:
1580 S = new (Context) ObjCIvarRefExpr(Empty);
1582 case EXPR_OBJC_PROPERTY_REF_EXPR:
1583 S = new (Context) ObjCPropertyRefExpr(Empty);
1585 case EXPR_OBJC_KVC_REF_EXPR:
1586 S = new (Context) ObjCImplicitSetterGetterRefExpr(Empty);
1588 case EXPR_OBJC_MESSAGE_EXPR:
1589 S = ObjCMessageExpr::CreateEmpty(*Context,
1590 Record[ASTStmtReader::NumExprFields]);
1592 case EXPR_OBJC_SUPER_EXPR:
1593 S = new (Context) ObjCSuperExpr(Empty);
1596 S = new (Context) ObjCIsaExpr(Empty);
1598 case STMT_OBJC_FOR_COLLECTION:
1599 S = new (Context) ObjCForCollectionStmt(Empty);
1601 case STMT_OBJC_CATCH:
1602 S = new (Context) ObjCAtCatchStmt(Empty);
1604 case STMT_OBJC_FINALLY:
1605 S = new (Context) ObjCAtFinallyStmt(Empty);
1607 case STMT_OBJC_AT_TRY:
1608 S = ObjCAtTryStmt::CreateEmpty(*Context,
1609 Record[ASTStmtReader::NumStmtFields],
1610 Record[ASTStmtReader::NumStmtFields + 1]);
1612 case STMT_OBJC_AT_SYNCHRONIZED:
1613 S = new (Context) ObjCAtSynchronizedStmt(Empty);
1615 case STMT_OBJC_AT_THROW:
1616 S = new (Context) ObjCAtThrowStmt(Empty);
1619 case STMT_CXX_CATCH:
1620 S = new (Context) CXXCatchStmt(Empty);
1624 S = CXXTryStmt::Create(*Context, Empty,
1625 /*NumHandlers=*/Record[ASTStmtReader::NumStmtFields]);
1628 case EXPR_CXX_OPERATOR_CALL:
1629 S = new (Context) CXXOperatorCallExpr(*Context, Empty);
1632 case EXPR_CXX_MEMBER_CALL:
1633 S = new (Context) CXXMemberCallExpr(*Context, Empty);
1636 case EXPR_CXX_CONSTRUCT:
1637 S = new (Context) CXXConstructExpr(Empty);
1640 case EXPR_CXX_TEMPORARY_OBJECT:
1641 S = new (Context) CXXTemporaryObjectExpr(Empty);
1644 case EXPR_CXX_STATIC_CAST:
1645 S = CXXStaticCastExpr::CreateEmpty(*Context,
1646 /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
1649 case EXPR_CXX_DYNAMIC_CAST:
1650 S = CXXDynamicCastExpr::CreateEmpty(*Context,
1651 /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
1654 case EXPR_CXX_REINTERPRET_CAST:
1655 S = CXXReinterpretCastExpr::CreateEmpty(*Context,
1656 /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
1659 case EXPR_CXX_CONST_CAST:
1660 S = CXXConstCastExpr::CreateEmpty(*Context);
1663 case EXPR_CXX_FUNCTIONAL_CAST:
1664 S = CXXFunctionalCastExpr::CreateEmpty(*Context,
1665 /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
1668 case EXPR_CXX_BOOL_LITERAL:
1669 S = new (Context) CXXBoolLiteralExpr(Empty);
1672 case EXPR_CXX_NULL_PTR_LITERAL:
1673 S = new (Context) CXXNullPtrLiteralExpr(Empty);
1675 case EXPR_CXX_TYPEID_EXPR:
1676 S = new (Context) CXXTypeidExpr(Empty, true);
1678 case EXPR_CXX_TYPEID_TYPE:
1679 S = new (Context) CXXTypeidExpr(Empty, false);
1682 S = new (Context) CXXThisExpr(Empty);
1684 case EXPR_CXX_THROW:
1685 S = new (Context) CXXThrowExpr(Empty);
1687 case EXPR_CXX_DEFAULT_ARG: {
1688 bool HasOtherExprStored = Record[ASTStmtReader::NumExprFields];
1689 if (HasOtherExprStored) {
1690 Expr *SubExpr = ReadSubExpr();
1691 S = CXXDefaultArgExpr::Create(*Context, SourceLocation(), 0, SubExpr);
1693 S = new (Context) CXXDefaultArgExpr(Empty);
1696 case EXPR_CXX_BIND_TEMPORARY:
1697 S = new (Context) CXXBindTemporaryExpr(Empty);
1700 case EXPR_CXX_SCALAR_VALUE_INIT:
1701 S = new (Context) CXXScalarValueInitExpr(Empty);
1704 S = new (Context) CXXNewExpr(Empty);
1706 case EXPR_CXX_DELETE:
1707 S = new (Context) CXXDeleteExpr(Empty);
1709 case EXPR_CXX_PSEUDO_DESTRUCTOR:
1710 S = new (Context) CXXPseudoDestructorExpr(Empty);
1713 case EXPR_CXX_EXPR_WITH_TEMPORARIES:
1714 S = new (Context) CXXExprWithTemporaries(Empty);
1717 case EXPR_CXX_DEPENDENT_SCOPE_MEMBER:
1718 S = CXXDependentScopeMemberExpr::CreateEmpty(*Context,
1719 /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]);
1722 case EXPR_CXX_DEPENDENT_SCOPE_DECL_REF:
1723 S = DependentScopeDeclRefExpr::CreateEmpty(*Context,
1724 /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]);
1727 case EXPR_CXX_UNRESOLVED_CONSTRUCT:
1728 S = CXXUnresolvedConstructExpr::CreateEmpty(*Context,
1729 /*NumArgs=*/Record[ASTStmtReader::NumExprFields]);
1732 case EXPR_CXX_UNRESOLVED_MEMBER:
1733 S = UnresolvedMemberExpr::CreateEmpty(*Context,
1734 /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]);
1737 case EXPR_CXX_UNRESOLVED_LOOKUP:
1738 S = UnresolvedLookupExpr::CreateEmpty(*Context,
1739 /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]);
1742 case EXPR_CXX_UNARY_TYPE_TRAIT:
1743 S = new (Context) UnaryTypeTraitExpr(Empty);
1747 // We hit a STMT_STOP, so we're done with this expression.
1751 ++NumStatementsRead;
1756 assert(Idx == Record.size() && "Invalid deserialization of statement");
1757 StmtStack.push_back(S);
1761 assert(StmtStack.size() > PrevNumStmts && "Read too many sub stmts!");
1762 assert(StmtStack.size() == PrevNumStmts + 1 && "Extra expressions on stack!");
1765 return StmtStack.pop_back_val();