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/DeclTemplate.h"
18 #include "clang/AST/StmtVisitor.h"
19 using namespace clang;
20 using namespace clang::serialization;
24 class ASTStmtReader : public StmtVisitor<ASTStmtReader> {
26 ASTReader::PerFileData &F;
27 llvm::BitstreamCursor &DeclsCursor;
28 const ASTReader::RecordData &Record;
31 SourceLocation ReadSourceLocation(const ASTReader::RecordData &R,
33 return Reader.ReadSourceLocation(F, R, I);
35 SourceRange ReadSourceRange(const ASTReader::RecordData &R, unsigned &I) {
36 return Reader.ReadSourceRange(F, R, I);
38 TypeSourceInfo *GetTypeSourceInfo(const ASTReader::RecordData &R,
40 return Reader.GetTypeSourceInfo(F, R, I);
42 void ReadDeclarationNameLoc(DeclarationNameLoc &DNLoc, DeclarationName Name,
43 const ASTReader::RecordData &R, unsigned &I) {
44 Reader.ReadDeclarationNameLoc(F, DNLoc, Name, R, I);
46 void ReadDeclarationNameInfo(DeclarationNameInfo &NameInfo,
47 const ASTReader::RecordData &R, unsigned &I) {
48 Reader.ReadDeclarationNameInfo(F, NameInfo, R, I);
52 ASTStmtReader(ASTReader &Reader, ASTReader::PerFileData &F,
53 llvm::BitstreamCursor &Cursor,
54 const ASTReader::RecordData &Record, unsigned &Idx)
55 : Reader(Reader), F(F), DeclsCursor(Cursor), Record(Record), Idx(Idx) { }
57 /// \brief The number of record fields required for the Stmt class
59 static const unsigned NumStmtFields = 0;
61 /// \brief The number of record fields required for the Expr class
63 static const unsigned NumExprFields = NumStmtFields + 7;
65 /// \brief Read and initialize a ExplicitTemplateArgumentList structure.
66 void ReadExplicitTemplateArgumentList(ExplicitTemplateArgumentList &ArgList,
67 unsigned NumTemplateArgs);
69 void VisitStmt(Stmt *S);
70 #define STMT(Type, Base) \
71 void Visit##Type(Type *);
72 #include "clang/AST/StmtNodes.inc"
77 ReadExplicitTemplateArgumentList(ExplicitTemplateArgumentList &ArgList,
78 unsigned NumTemplateArgs) {
79 TemplateArgumentListInfo ArgInfo;
80 ArgInfo.setLAngleLoc(ReadSourceLocation(Record, Idx));
81 ArgInfo.setRAngleLoc(ReadSourceLocation(Record, Idx));
82 for (unsigned i = 0; i != NumTemplateArgs; ++i)
84 Reader.ReadTemplateArgumentLoc(F, Record, Idx));
85 ArgList.initializeFrom(ArgInfo);
88 void ASTStmtReader::VisitStmt(Stmt *S) {
89 assert(Idx == NumStmtFields && "Incorrect statement field count");
92 void ASTStmtReader::VisitNullStmt(NullStmt *S) {
94 S->setSemiLoc(ReadSourceLocation(Record, Idx));
95 S->LeadingEmptyMacro = ReadSourceLocation(Record, Idx);
98 void ASTStmtReader::VisitCompoundStmt(CompoundStmt *S) {
100 llvm::SmallVector<Stmt *, 16> Stmts;
101 unsigned NumStmts = Record[Idx++];
103 Stmts.push_back(Reader.ReadSubStmt());
104 S->setStmts(*Reader.getContext(), Stmts.data(), Stmts.size());
105 S->setLBracLoc(ReadSourceLocation(Record, Idx));
106 S->setRBracLoc(ReadSourceLocation(Record, Idx));
109 void ASTStmtReader::VisitSwitchCase(SwitchCase *S) {
111 Reader.RecordSwitchCaseID(S, Record[Idx++]);
114 void ASTStmtReader::VisitCaseStmt(CaseStmt *S) {
116 S->setLHS(Reader.ReadSubExpr());
117 S->setRHS(Reader.ReadSubExpr());
118 S->setSubStmt(Reader.ReadSubStmt());
119 S->setCaseLoc(ReadSourceLocation(Record, Idx));
120 S->setEllipsisLoc(ReadSourceLocation(Record, Idx));
121 S->setColonLoc(ReadSourceLocation(Record, Idx));
124 void ASTStmtReader::VisitDefaultStmt(DefaultStmt *S) {
126 S->setSubStmt(Reader.ReadSubStmt());
127 S->setDefaultLoc(ReadSourceLocation(Record, Idx));
128 S->setColonLoc(ReadSourceLocation(Record, Idx));
131 void ASTStmtReader::VisitLabelStmt(LabelStmt *S) {
133 LabelDecl *LD = cast<LabelDecl>(Reader.GetDecl(Record[Idx++]));
136 S->setSubStmt(Reader.ReadSubStmt());
137 S->setIdentLoc(ReadSourceLocation(Record, Idx));
140 void ASTStmtReader::VisitIfStmt(IfStmt *S) {
142 S->setConditionVariable(*Reader.getContext(),
143 cast_or_null<VarDecl>(Reader.GetDecl(Record[Idx++])));
144 S->setCond(Reader.ReadSubExpr());
145 S->setThen(Reader.ReadSubStmt());
146 S->setElse(Reader.ReadSubStmt());
147 S->setIfLoc(ReadSourceLocation(Record, Idx));
148 S->setElseLoc(ReadSourceLocation(Record, Idx));
151 void ASTStmtReader::VisitSwitchStmt(SwitchStmt *S) {
153 S->setConditionVariable(*Reader.getContext(),
154 cast_or_null<VarDecl>(Reader.GetDecl(Record[Idx++])));
155 S->setCond(Reader.ReadSubExpr());
156 S->setBody(Reader.ReadSubStmt());
157 S->setSwitchLoc(ReadSourceLocation(Record, Idx));
159 S->setAllEnumCasesCovered();
161 SwitchCase *PrevSC = 0;
162 for (unsigned N = Record.size(); Idx != N; ++Idx) {
163 SwitchCase *SC = Reader.getSwitchCaseWithID(Record[Idx]);
165 PrevSC->setNextSwitchCase(SC);
167 S->setSwitchCaseList(SC);
173 void ASTStmtReader::VisitWhileStmt(WhileStmt *S) {
175 S->setConditionVariable(*Reader.getContext(),
176 cast_or_null<VarDecl>(Reader.GetDecl(Record[Idx++])));
177 S->setCond(Reader.ReadSubExpr());
178 S->setBody(Reader.ReadSubStmt());
179 S->setWhileLoc(ReadSourceLocation(Record, Idx));
182 void ASTStmtReader::VisitDoStmt(DoStmt *S) {
184 S->setCond(Reader.ReadSubExpr());
185 S->setBody(Reader.ReadSubStmt());
186 S->setDoLoc(ReadSourceLocation(Record, Idx));
187 S->setWhileLoc(ReadSourceLocation(Record, Idx));
188 S->setRParenLoc(ReadSourceLocation(Record, Idx));
191 void ASTStmtReader::VisitForStmt(ForStmt *S) {
193 S->setInit(Reader.ReadSubStmt());
194 S->setCond(Reader.ReadSubExpr());
195 S->setConditionVariable(*Reader.getContext(),
196 cast_or_null<VarDecl>(Reader.GetDecl(Record[Idx++])));
197 S->setInc(Reader.ReadSubExpr());
198 S->setBody(Reader.ReadSubStmt());
199 S->setForLoc(ReadSourceLocation(Record, Idx));
200 S->setLParenLoc(ReadSourceLocation(Record, Idx));
201 S->setRParenLoc(ReadSourceLocation(Record, Idx));
204 void ASTStmtReader::VisitGotoStmt(GotoStmt *S) {
206 S->setLabel(cast<LabelDecl>(Reader.GetDecl(Record[Idx++])));
207 S->setGotoLoc(ReadSourceLocation(Record, Idx));
208 S->setLabelLoc(ReadSourceLocation(Record, Idx));
211 void ASTStmtReader::VisitIndirectGotoStmt(IndirectGotoStmt *S) {
213 S->setGotoLoc(ReadSourceLocation(Record, Idx));
214 S->setStarLoc(ReadSourceLocation(Record, Idx));
215 S->setTarget(Reader.ReadSubExpr());
218 void ASTStmtReader::VisitContinueStmt(ContinueStmt *S) {
220 S->setContinueLoc(ReadSourceLocation(Record, Idx));
223 void ASTStmtReader::VisitBreakStmt(BreakStmt *S) {
225 S->setBreakLoc(ReadSourceLocation(Record, Idx));
228 void ASTStmtReader::VisitReturnStmt(ReturnStmt *S) {
230 S->setRetValue(Reader.ReadSubExpr());
231 S->setReturnLoc(ReadSourceLocation(Record, Idx));
232 S->setNRVOCandidate(cast_or_null<VarDecl>(Reader.GetDecl(Record[Idx++])));
235 void ASTStmtReader::VisitDeclStmt(DeclStmt *S) {
237 S->setStartLoc(ReadSourceLocation(Record, Idx));
238 S->setEndLoc(ReadSourceLocation(Record, Idx));
240 if (Idx + 1 == Record.size()) {
241 // Single declaration
242 S->setDeclGroup(DeclGroupRef(Reader.GetDecl(Record[Idx++])));
244 llvm::SmallVector<Decl *, 16> Decls;
245 Decls.reserve(Record.size() - Idx);
246 for (unsigned N = Record.size(); Idx != N; ++Idx)
247 Decls.push_back(Reader.GetDecl(Record[Idx]));
248 S->setDeclGroup(DeclGroupRef(DeclGroup::Create(*Reader.getContext(),
254 void ASTStmtReader::VisitAsmStmt(AsmStmt *S) {
256 unsigned NumOutputs = Record[Idx++];
257 unsigned NumInputs = Record[Idx++];
258 unsigned NumClobbers = Record[Idx++];
259 S->setAsmLoc(ReadSourceLocation(Record, Idx));
260 S->setRParenLoc(ReadSourceLocation(Record, Idx));
261 S->setVolatile(Record[Idx++]);
262 S->setSimple(Record[Idx++]);
263 S->setMSAsm(Record[Idx++]);
265 S->setAsmString(cast_or_null<StringLiteral>(Reader.ReadSubStmt()));
267 // Outputs and inputs
268 llvm::SmallVector<IdentifierInfo *, 16> Names;
269 llvm::SmallVector<StringLiteral*, 16> Constraints;
270 llvm::SmallVector<Stmt*, 16> Exprs;
271 for (unsigned I = 0, N = NumOutputs + NumInputs; I != N; ++I) {
272 Names.push_back(Reader.GetIdentifierInfo(Record, Idx));
273 Constraints.push_back(cast_or_null<StringLiteral>(Reader.ReadSubStmt()));
274 Exprs.push_back(Reader.ReadSubStmt());
278 llvm::SmallVector<StringLiteral*, 16> Clobbers;
279 for (unsigned I = 0; I != NumClobbers; ++I)
280 Clobbers.push_back(cast_or_null<StringLiteral>(Reader.ReadSubStmt()));
282 S->setOutputsAndInputsAndClobbers(*Reader.getContext(),
283 Names.data(), Constraints.data(),
284 Exprs.data(), NumOutputs, NumInputs,
285 Clobbers.data(), NumClobbers);
288 void ASTStmtReader::VisitExpr(Expr *E) {
290 E->setType(Reader.GetType(Record[Idx++]));
291 E->setTypeDependent(Record[Idx++]);
292 E->setValueDependent(Record[Idx++]);
293 E->setInstantiationDependent(Record[Idx++]);
294 E->ExprBits.ContainsUnexpandedParameterPack = Record[Idx++];
295 E->setValueKind(static_cast<ExprValueKind>(Record[Idx++]));
296 E->setObjectKind(static_cast<ExprObjectKind>(Record[Idx++]));
297 assert(Idx == NumExprFields && "Incorrect expression field count");
300 void ASTStmtReader::VisitPredefinedExpr(PredefinedExpr *E) {
302 E->setLocation(ReadSourceLocation(Record, Idx));
303 E->setIdentType((PredefinedExpr::IdentType)Record[Idx++]);
306 void ASTStmtReader::VisitDeclRefExpr(DeclRefExpr *E) {
309 E->DeclRefExprBits.HasQualifier = Record[Idx++];
310 E->DeclRefExprBits.HasFoundDecl = Record[Idx++];
311 E->DeclRefExprBits.HasExplicitTemplateArgs = Record[Idx++];
312 unsigned NumTemplateArgs = 0;
313 if (E->hasExplicitTemplateArgs())
314 NumTemplateArgs = Record[Idx++];
316 if (E->hasQualifier())
317 E->getInternalQualifierLoc()
318 = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
320 if (E->hasFoundDecl())
321 E->getInternalFoundDecl() = cast<NamedDecl>(Reader.GetDecl(Record[Idx++]));
323 if (E->hasExplicitTemplateArgs())
324 ReadExplicitTemplateArgumentList(E->getExplicitTemplateArgs(),
327 E->setDecl(cast<ValueDecl>(Reader.GetDecl(Record[Idx++])));
328 E->setLocation(ReadSourceLocation(Record, Idx));
329 ReadDeclarationNameLoc(E->DNLoc, E->getDecl()->getDeclName(), Record, Idx);
332 void ASTStmtReader::VisitIntegerLiteral(IntegerLiteral *E) {
334 E->setLocation(ReadSourceLocation(Record, Idx));
335 E->setValue(*Reader.getContext(), Reader.ReadAPInt(Record, Idx));
338 void ASTStmtReader::VisitFloatingLiteral(FloatingLiteral *E) {
340 E->setValue(*Reader.getContext(), Reader.ReadAPFloat(Record, Idx));
341 E->setExact(Record[Idx++]);
342 E->setLocation(ReadSourceLocation(Record, Idx));
345 void ASTStmtReader::VisitImaginaryLiteral(ImaginaryLiteral *E) {
347 E->setSubExpr(Reader.ReadSubExpr());
350 void ASTStmtReader::VisitStringLiteral(StringLiteral *E) {
352 unsigned Len = Record[Idx++];
353 assert(Record[Idx] == E->getNumConcatenated() &&
354 "Wrong number of concatenated tokens!");
356 E->IsWide = Record[Idx++];
357 E->IsPascal = Record[Idx++];
360 llvm::SmallString<16> Str(&Record[Idx], &Record[Idx] + Len);
361 E->setString(*Reader.getContext(), Str.str());
364 // Read source locations
365 for (unsigned I = 0, N = E->getNumConcatenated(); I != N; ++I)
366 E->setStrTokenLoc(I, ReadSourceLocation(Record, Idx));
369 void ASTStmtReader::VisitCharacterLiteral(CharacterLiteral *E) {
371 E->setValue(Record[Idx++]);
372 E->setLocation(ReadSourceLocation(Record, Idx));
373 E->setWide(Record[Idx++]);
376 void ASTStmtReader::VisitParenExpr(ParenExpr *E) {
378 E->setLParen(ReadSourceLocation(Record, Idx));
379 E->setRParen(ReadSourceLocation(Record, Idx));
380 E->setSubExpr(Reader.ReadSubExpr());
383 void ASTStmtReader::VisitParenListExpr(ParenListExpr *E) {
385 unsigned NumExprs = Record[Idx++];
386 E->Exprs = new (*Reader.getContext()) Stmt*[NumExprs];
387 for (unsigned i = 0; i != NumExprs; ++i)
388 E->Exprs[i] = Reader.ReadSubStmt();
389 E->NumExprs = NumExprs;
390 E->LParenLoc = ReadSourceLocation(Record, Idx);
391 E->RParenLoc = ReadSourceLocation(Record, Idx);
394 void ASTStmtReader::VisitUnaryOperator(UnaryOperator *E) {
396 E->setSubExpr(Reader.ReadSubExpr());
397 E->setOpcode((UnaryOperator::Opcode)Record[Idx++]);
398 E->setOperatorLoc(ReadSourceLocation(Record, Idx));
401 void ASTStmtReader::VisitOffsetOfExpr(OffsetOfExpr *E) {
402 typedef OffsetOfExpr::OffsetOfNode Node;
404 assert(E->getNumComponents() == Record[Idx]);
406 assert(E->getNumExpressions() == Record[Idx]);
408 E->setOperatorLoc(ReadSourceLocation(Record, Idx));
409 E->setRParenLoc(ReadSourceLocation(Record, Idx));
410 E->setTypeSourceInfo(GetTypeSourceInfo(Record, Idx));
411 for (unsigned I = 0, N = E->getNumComponents(); I != N; ++I) {
412 Node::Kind Kind = static_cast<Node::Kind>(Record[Idx++]);
413 SourceLocation Start = ReadSourceLocation(Record, Idx);
414 SourceLocation End = ReadSourceLocation(Record, Idx);
417 E->setComponent(I, Node(Start, Record[Idx++], End));
423 dyn_cast_or_null<FieldDecl>(Reader.GetDecl(Record[Idx++])),
427 case Node::Identifier:
428 E->setComponent(I, Node(Start, Reader.GetIdentifier(Record[Idx++]), End));
432 CXXBaseSpecifier *Base = new (*Reader.getContext()) CXXBaseSpecifier();
433 *Base = Reader.ReadCXXBaseSpecifier(F, Record, Idx);
434 E->setComponent(I, Node(Base));
440 for (unsigned I = 0, N = E->getNumExpressions(); I != N; ++I)
441 E->setIndexExpr(I, Reader.ReadSubExpr());
444 void ASTStmtReader::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E) {
446 E->setKind(static_cast<UnaryExprOrTypeTrait>(Record[Idx++]));
447 if (Record[Idx] == 0) {
448 E->setArgument(Reader.ReadSubExpr());
451 E->setArgument(GetTypeSourceInfo(Record, Idx));
453 E->setOperatorLoc(ReadSourceLocation(Record, Idx));
454 E->setRParenLoc(ReadSourceLocation(Record, Idx));
457 void ASTStmtReader::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
459 E->setLHS(Reader.ReadSubExpr());
460 E->setRHS(Reader.ReadSubExpr());
461 E->setRBracketLoc(ReadSourceLocation(Record, Idx));
464 void ASTStmtReader::VisitCallExpr(CallExpr *E) {
466 E->setNumArgs(*Reader.getContext(), Record[Idx++]);
467 E->setRParenLoc(ReadSourceLocation(Record, Idx));
468 E->setCallee(Reader.ReadSubExpr());
469 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
470 E->setArg(I, Reader.ReadSubExpr());
473 void ASTStmtReader::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
477 void ASTStmtReader::VisitMemberExpr(MemberExpr *E) {
478 // Don't call VisitExpr, this is fully initialized at creation.
479 assert(E->getStmtClass() == Stmt::MemberExprClass &&
480 "It's a subclass, we must advance Idx!");
483 void ASTStmtReader::VisitObjCIsaExpr(ObjCIsaExpr *E) {
485 E->setBase(Reader.ReadSubExpr());
486 E->setIsaMemberLoc(ReadSourceLocation(Record, Idx));
487 E->setArrow(Record[Idx++]);
491 VisitObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *E) {
493 E->Operand = Reader.ReadSubExpr();
494 E->setShouldCopy(Record[Idx++]);
497 void ASTStmtReader::VisitObjCBridgedCastExpr(ObjCBridgedCastExpr *E) {
498 VisitExplicitCastExpr(E);
499 E->LParenLoc = ReadSourceLocation(Record, Idx);
500 E->BridgeKeywordLoc = ReadSourceLocation(Record, Idx);
501 E->Kind = Record[Idx++];
504 void ASTStmtReader::VisitCastExpr(CastExpr *E) {
506 unsigned NumBaseSpecs = Record[Idx++];
507 assert(NumBaseSpecs == E->path_size());
508 E->setSubExpr(Reader.ReadSubExpr());
509 E->setCastKind((CastExpr::CastKind)Record[Idx++]);
510 CastExpr::path_iterator BaseI = E->path_begin();
511 while (NumBaseSpecs--) {
512 CXXBaseSpecifier *BaseSpec = new (*Reader.getContext()) CXXBaseSpecifier;
513 *BaseSpec = Reader.ReadCXXBaseSpecifier(F, Record, Idx);
518 void ASTStmtReader::VisitBinaryOperator(BinaryOperator *E) {
520 E->setLHS(Reader.ReadSubExpr());
521 E->setRHS(Reader.ReadSubExpr());
522 E->setOpcode((BinaryOperator::Opcode)Record[Idx++]);
523 E->setOperatorLoc(ReadSourceLocation(Record, Idx));
526 void ASTStmtReader::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
527 VisitBinaryOperator(E);
528 E->setComputationLHSType(Reader.GetType(Record[Idx++]));
529 E->setComputationResultType(Reader.GetType(Record[Idx++]));
532 void ASTStmtReader::VisitConditionalOperator(ConditionalOperator *E) {
534 E->SubExprs[ConditionalOperator::COND] = Reader.ReadSubExpr();
535 E->SubExprs[ConditionalOperator::LHS] = Reader.ReadSubExpr();
536 E->SubExprs[ConditionalOperator::RHS] = Reader.ReadSubExpr();
537 E->QuestionLoc = ReadSourceLocation(Record, Idx);
538 E->ColonLoc = ReadSourceLocation(Record, Idx);
542 ASTStmtReader::VisitBinaryConditionalOperator(BinaryConditionalOperator *E) {
544 E->OpaqueValue = cast<OpaqueValueExpr>(Reader.ReadSubExpr());
545 E->SubExprs[BinaryConditionalOperator::COMMON] = Reader.ReadSubExpr();
546 E->SubExprs[BinaryConditionalOperator::COND] = Reader.ReadSubExpr();
547 E->SubExprs[BinaryConditionalOperator::LHS] = Reader.ReadSubExpr();
548 E->SubExprs[BinaryConditionalOperator::RHS] = Reader.ReadSubExpr();
549 E->QuestionLoc = ReadSourceLocation(Record, Idx);
550 E->ColonLoc = ReadSourceLocation(Record, Idx);
552 E->getOpaqueValue()->setSourceExpr(E->getCommon());
555 void ASTStmtReader::VisitImplicitCastExpr(ImplicitCastExpr *E) {
559 void ASTStmtReader::VisitExplicitCastExpr(ExplicitCastExpr *E) {
561 E->setTypeInfoAsWritten(GetTypeSourceInfo(Record, Idx));
564 void ASTStmtReader::VisitCStyleCastExpr(CStyleCastExpr *E) {
565 VisitExplicitCastExpr(E);
566 E->setLParenLoc(ReadSourceLocation(Record, Idx));
567 E->setRParenLoc(ReadSourceLocation(Record, Idx));
570 void ASTStmtReader::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
572 E->setLParenLoc(ReadSourceLocation(Record, Idx));
573 E->setTypeSourceInfo(GetTypeSourceInfo(Record, Idx));
574 E->setInitializer(Reader.ReadSubExpr());
575 E->setFileScope(Record[Idx++]);
578 void ASTStmtReader::VisitExtVectorElementExpr(ExtVectorElementExpr *E) {
580 E->setBase(Reader.ReadSubExpr());
581 E->setAccessor(Reader.GetIdentifierInfo(Record, Idx));
582 E->setAccessorLoc(ReadSourceLocation(Record, Idx));
585 void ASTStmtReader::VisitInitListExpr(InitListExpr *E) {
587 E->setSyntacticForm(cast_or_null<InitListExpr>(Reader.ReadSubStmt()));
588 E->setLBraceLoc(ReadSourceLocation(Record, Idx));
589 E->setRBraceLoc(ReadSourceLocation(Record, Idx));
590 bool isArrayFiller = Record[Idx++];
593 filler = Reader.ReadSubExpr();
594 E->ArrayFillerOrUnionFieldInit = filler;
596 E->ArrayFillerOrUnionFieldInit
597 = cast_or_null<FieldDecl>(Reader.GetDecl(Record[Idx++]));
598 E->sawArrayRangeDesignator(Record[Idx++]);
599 unsigned NumInits = Record[Idx++];
600 E->reserveInits(*Reader.getContext(), NumInits);
602 for (unsigned I = 0; I != NumInits; ++I) {
603 Expr *init = Reader.ReadSubExpr();
604 E->updateInit(*Reader.getContext(), I, init ? init : filler);
607 for (unsigned I = 0; I != NumInits; ++I)
608 E->updateInit(*Reader.getContext(), I, Reader.ReadSubExpr());
612 void ASTStmtReader::VisitDesignatedInitExpr(DesignatedInitExpr *E) {
613 typedef DesignatedInitExpr::Designator Designator;
616 unsigned NumSubExprs = Record[Idx++];
617 assert(NumSubExprs == E->getNumSubExprs() && "Wrong number of subexprs");
618 for (unsigned I = 0; I != NumSubExprs; ++I)
619 E->setSubExpr(I, Reader.ReadSubExpr());
620 E->setEqualOrColonLoc(ReadSourceLocation(Record, Idx));
621 E->setGNUSyntax(Record[Idx++]);
623 llvm::SmallVector<Designator, 4> Designators;
624 while (Idx < Record.size()) {
625 switch ((DesignatorTypes)Record[Idx++]) {
626 case DESIG_FIELD_DECL: {
627 FieldDecl *Field = cast<FieldDecl>(Reader.GetDecl(Record[Idx++]));
628 SourceLocation DotLoc
629 = ReadSourceLocation(Record, Idx);
630 SourceLocation FieldLoc
631 = ReadSourceLocation(Record, Idx);
632 Designators.push_back(Designator(Field->getIdentifier(), DotLoc,
634 Designators.back().setField(Field);
638 case DESIG_FIELD_NAME: {
639 const IdentifierInfo *Name = Reader.GetIdentifierInfo(Record, Idx);
640 SourceLocation DotLoc
641 = ReadSourceLocation(Record, Idx);
642 SourceLocation FieldLoc
643 = ReadSourceLocation(Record, Idx);
644 Designators.push_back(Designator(Name, DotLoc, FieldLoc));
649 unsigned Index = Record[Idx++];
650 SourceLocation LBracketLoc
651 = ReadSourceLocation(Record, Idx);
652 SourceLocation RBracketLoc
653 = ReadSourceLocation(Record, Idx);
654 Designators.push_back(Designator(Index, LBracketLoc, RBracketLoc));
658 case DESIG_ARRAY_RANGE: {
659 unsigned Index = Record[Idx++];
660 SourceLocation LBracketLoc
661 = ReadSourceLocation(Record, Idx);
662 SourceLocation EllipsisLoc
663 = ReadSourceLocation(Record, Idx);
664 SourceLocation RBracketLoc
665 = ReadSourceLocation(Record, Idx);
666 Designators.push_back(Designator(Index, LBracketLoc, EllipsisLoc,
672 E->setDesignators(*Reader.getContext(),
673 Designators.data(), Designators.size());
676 void ASTStmtReader::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
680 void ASTStmtReader::VisitVAArgExpr(VAArgExpr *E) {
682 E->setSubExpr(Reader.ReadSubExpr());
683 E->setWrittenTypeInfo(GetTypeSourceInfo(Record, Idx));
684 E->setBuiltinLoc(ReadSourceLocation(Record, Idx));
685 E->setRParenLoc(ReadSourceLocation(Record, Idx));
688 void ASTStmtReader::VisitAddrLabelExpr(AddrLabelExpr *E) {
690 E->setAmpAmpLoc(ReadSourceLocation(Record, Idx));
691 E->setLabelLoc(ReadSourceLocation(Record, Idx));
692 E->setLabel(cast<LabelDecl>(Reader.GetDecl(Record[Idx++])));
695 void ASTStmtReader::VisitStmtExpr(StmtExpr *E) {
697 E->setLParenLoc(ReadSourceLocation(Record, Idx));
698 E->setRParenLoc(ReadSourceLocation(Record, Idx));
699 E->setSubStmt(cast_or_null<CompoundStmt>(Reader.ReadSubStmt()));
702 void ASTStmtReader::VisitChooseExpr(ChooseExpr *E) {
704 E->setCond(Reader.ReadSubExpr());
705 E->setLHS(Reader.ReadSubExpr());
706 E->setRHS(Reader.ReadSubExpr());
707 E->setBuiltinLoc(ReadSourceLocation(Record, Idx));
708 E->setRParenLoc(ReadSourceLocation(Record, Idx));
711 void ASTStmtReader::VisitGNUNullExpr(GNUNullExpr *E) {
713 E->setTokenLocation(ReadSourceLocation(Record, Idx));
716 void ASTStmtReader::VisitShuffleVectorExpr(ShuffleVectorExpr *E) {
718 llvm::SmallVector<Expr *, 16> Exprs;
719 unsigned NumExprs = Record[Idx++];
721 Exprs.push_back(Reader.ReadSubExpr());
722 E->setExprs(*Reader.getContext(), Exprs.data(), Exprs.size());
723 E->setBuiltinLoc(ReadSourceLocation(Record, Idx));
724 E->setRParenLoc(ReadSourceLocation(Record, Idx));
727 void ASTStmtReader::VisitBlockExpr(BlockExpr *E) {
729 E->setBlockDecl(cast_or_null<BlockDecl>(Reader.GetDecl(Record[Idx++])));
732 void ASTStmtReader::VisitBlockDeclRefExpr(BlockDeclRefExpr *E) {
734 E->setDecl(cast<VarDecl>(Reader.GetDecl(Record[Idx++])));
735 E->setLocation(ReadSourceLocation(Record, Idx));
736 E->setByRef(Record[Idx++]);
737 E->setConstQualAdded(Record[Idx++]);
740 void ASTStmtReader::VisitGenericSelectionExpr(GenericSelectionExpr *E) {
742 E->NumAssocs = Record[Idx++];
743 E->AssocTypes = new (*Reader.getContext()) TypeSourceInfo*[E->NumAssocs];
745 new(*Reader.getContext()) Stmt*[GenericSelectionExpr::END_EXPR+E->NumAssocs];
747 E->SubExprs[GenericSelectionExpr::CONTROLLING] = Reader.ReadSubExpr();
748 for (unsigned I = 0, N = E->getNumAssocs(); I != N; ++I) {
749 E->AssocTypes[I] = GetTypeSourceInfo(Record, Idx);
750 E->SubExprs[GenericSelectionExpr::END_EXPR+I] = Reader.ReadSubExpr();
752 E->ResultIndex = Record[Idx++];
754 E->GenericLoc = ReadSourceLocation(Record, Idx);
755 E->DefaultLoc = ReadSourceLocation(Record, Idx);
756 E->RParenLoc = ReadSourceLocation(Record, Idx);
759 //===----------------------------------------------------------------------===//
760 // Objective-C Expressions and Statements
762 void ASTStmtReader::VisitObjCStringLiteral(ObjCStringLiteral *E) {
764 E->setString(cast<StringLiteral>(Reader.ReadSubStmt()));
765 E->setAtLoc(ReadSourceLocation(Record, Idx));
768 void ASTStmtReader::VisitObjCEncodeExpr(ObjCEncodeExpr *E) {
770 E->setEncodedTypeSourceInfo(GetTypeSourceInfo(Record, Idx));
771 E->setAtLoc(ReadSourceLocation(Record, Idx));
772 E->setRParenLoc(ReadSourceLocation(Record, Idx));
775 void ASTStmtReader::VisitObjCSelectorExpr(ObjCSelectorExpr *E) {
777 E->setSelector(Reader.GetSelector(Record, Idx));
778 E->setAtLoc(ReadSourceLocation(Record, Idx));
779 E->setRParenLoc(ReadSourceLocation(Record, Idx));
782 void ASTStmtReader::VisitObjCProtocolExpr(ObjCProtocolExpr *E) {
784 E->setProtocol(cast<ObjCProtocolDecl>(Reader.GetDecl(Record[Idx++])));
785 E->setAtLoc(ReadSourceLocation(Record, Idx));
786 E->setRParenLoc(ReadSourceLocation(Record, Idx));
789 void ASTStmtReader::VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
791 E->setDecl(cast<ObjCIvarDecl>(Reader.GetDecl(Record[Idx++])));
792 E->setLocation(ReadSourceLocation(Record, Idx));
793 E->setBase(Reader.ReadSubExpr());
794 E->setIsArrow(Record[Idx++]);
795 E->setIsFreeIvar(Record[Idx++]);
798 void ASTStmtReader::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
800 bool Implicit = Record[Idx++] != 0;
802 ObjCMethodDecl *Getter =
803 cast<ObjCMethodDecl>(Reader.GetDecl(Record[Idx++]));
804 ObjCMethodDecl *Setter =
805 cast<ObjCMethodDecl>(Reader.GetDecl(Record[Idx++]));
806 E->setImplicitProperty(Getter, Setter);
808 E->setExplicitProperty(
809 cast<ObjCPropertyDecl>(Reader.GetDecl(Record[Idx++])));
811 E->setLocation(ReadSourceLocation(Record, Idx));
812 E->setReceiverLocation(ReadSourceLocation(Record, Idx));
813 switch (Record[Idx++]) {
815 E->setBase(Reader.ReadSubExpr());
818 E->setSuperReceiver(Reader.GetType(Record[Idx++]));
822 cast<ObjCInterfaceDecl>(Reader.GetDecl(Record[Idx++])));
827 void ASTStmtReader::VisitObjCMessageExpr(ObjCMessageExpr *E) {
829 assert(Record[Idx] == E->getNumArgs());
831 E->setDelegateInitCall(Record[Idx++]);
832 ObjCMessageExpr::ReceiverKind Kind
833 = static_cast<ObjCMessageExpr::ReceiverKind>(Record[Idx++]);
835 case ObjCMessageExpr::Instance:
836 E->setInstanceReceiver(Reader.ReadSubExpr());
839 case ObjCMessageExpr::Class:
840 E->setClassReceiver(GetTypeSourceInfo(Record, Idx));
843 case ObjCMessageExpr::SuperClass:
844 case ObjCMessageExpr::SuperInstance: {
845 QualType T = Reader.GetType(Record[Idx++]);
846 SourceLocation SuperLoc = ReadSourceLocation(Record, Idx);
847 E->setSuper(SuperLoc, T, Kind == ObjCMessageExpr::SuperInstance);
852 assert(Kind == E->getReceiverKind());
855 E->setMethodDecl(cast_or_null<ObjCMethodDecl>(Reader.GetDecl(Record[Idx++])));
857 E->setSelector(Reader.GetSelector(Record, Idx));
859 E->LBracLoc = ReadSourceLocation(Record, Idx);
860 E->RBracLoc = ReadSourceLocation(Record, Idx);
861 E->SelectorLoc = ReadSourceLocation(Record, Idx);
863 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
864 E->setArg(I, Reader.ReadSubExpr());
867 void ASTStmtReader::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) {
869 S->setElement(Reader.ReadSubStmt());
870 S->setCollection(Reader.ReadSubExpr());
871 S->setBody(Reader.ReadSubStmt());
872 S->setForLoc(ReadSourceLocation(Record, Idx));
873 S->setRParenLoc(ReadSourceLocation(Record, Idx));
876 void ASTStmtReader::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) {
878 S->setCatchBody(Reader.ReadSubStmt());
879 S->setCatchParamDecl(cast_or_null<VarDecl>(Reader.GetDecl(Record[Idx++])));
880 S->setAtCatchLoc(ReadSourceLocation(Record, Idx));
881 S->setRParenLoc(ReadSourceLocation(Record, Idx));
884 void ASTStmtReader::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
886 S->setFinallyBody(Reader.ReadSubStmt());
887 S->setAtFinallyLoc(ReadSourceLocation(Record, Idx));
890 void ASTStmtReader::VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S) {
892 S->setSubStmt(Reader.ReadSubStmt());
893 S->setAtLoc(ReadSourceLocation(Record, Idx));
896 void ASTStmtReader::VisitObjCAtTryStmt(ObjCAtTryStmt *S) {
898 assert(Record[Idx] == S->getNumCatchStmts());
900 bool HasFinally = Record[Idx++];
901 S->setTryBody(Reader.ReadSubStmt());
902 for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I)
903 S->setCatchStmt(I, cast_or_null<ObjCAtCatchStmt>(Reader.ReadSubStmt()));
906 S->setFinallyStmt(Reader.ReadSubStmt());
907 S->setAtTryLoc(ReadSourceLocation(Record, Idx));
910 void ASTStmtReader::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S) {
912 S->setSynchExpr(Reader.ReadSubStmt());
913 S->setSynchBody(Reader.ReadSubStmt());
914 S->setAtSynchronizedLoc(ReadSourceLocation(Record, Idx));
917 void ASTStmtReader::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) {
919 S->setThrowExpr(Reader.ReadSubStmt());
920 S->setThrowLoc(ReadSourceLocation(Record, Idx));
923 //===----------------------------------------------------------------------===//
924 // C++ Expressions and Statements
925 //===----------------------------------------------------------------------===//
927 void ASTStmtReader::VisitCXXCatchStmt(CXXCatchStmt *S) {
929 S->CatchLoc = ReadSourceLocation(Record, Idx);
930 S->ExceptionDecl = cast_or_null<VarDecl>(Reader.GetDecl(Record[Idx++]));
931 S->HandlerBlock = Reader.ReadSubStmt();
934 void ASTStmtReader::VisitCXXTryStmt(CXXTryStmt *S) {
936 assert(Record[Idx] == S->getNumHandlers() && "NumStmtFields is wrong ?");
938 S->TryLoc = ReadSourceLocation(Record, Idx);
939 S->getStmts()[0] = Reader.ReadSubStmt();
940 for (unsigned i = 0, e = S->getNumHandlers(); i != e; ++i)
941 S->getStmts()[i + 1] = Reader.ReadSubStmt();
944 void ASTStmtReader::VisitCXXForRangeStmt(CXXForRangeStmt *S) {
946 S->setForLoc(ReadSourceLocation(Record, Idx));
947 S->setColonLoc(ReadSourceLocation(Record, Idx));
948 S->setRParenLoc(ReadSourceLocation(Record, Idx));
949 S->setRangeStmt(Reader.ReadSubStmt());
950 S->setBeginEndStmt(Reader.ReadSubStmt());
951 S->setCond(Reader.ReadSubExpr());
952 S->setInc(Reader.ReadSubExpr());
953 S->setLoopVarStmt(Reader.ReadSubStmt());
954 S->setBody(Reader.ReadSubStmt());
957 void ASTStmtReader::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
959 E->setOperator((OverloadedOperatorKind)Record[Idx++]);
962 void ASTStmtReader::VisitCXXConstructExpr(CXXConstructExpr *E) {
964 E->NumArgs = Record[Idx++];
966 E->Args = new (*Reader.getContext()) Stmt*[E->NumArgs];
967 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
968 E->setArg(I, Reader.ReadSubExpr());
969 E->setConstructor(cast<CXXConstructorDecl>(Reader.GetDecl(Record[Idx++])));
970 E->setLocation(ReadSourceLocation(Record, Idx));
971 E->setElidable(Record[Idx++]);
972 E->setRequiresZeroInitialization(Record[Idx++]);
973 E->setConstructionKind((CXXConstructExpr::ConstructionKind)Record[Idx++]);
974 E->ParenRange = ReadSourceRange(Record, Idx);
977 void ASTStmtReader::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E) {
978 VisitCXXConstructExpr(E);
979 E->Type = GetTypeSourceInfo(Record, Idx);
982 void ASTStmtReader::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) {
983 VisitExplicitCastExpr(E);
984 SourceRange R = ReadSourceRange(Record, Idx);
985 E->Loc = R.getBegin();
986 E->RParenLoc = R.getEnd();
989 void ASTStmtReader::VisitCXXStaticCastExpr(CXXStaticCastExpr *E) {
990 return VisitCXXNamedCastExpr(E);
993 void ASTStmtReader::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *E) {
994 return VisitCXXNamedCastExpr(E);
997 void ASTStmtReader::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *E) {
998 return VisitCXXNamedCastExpr(E);
1001 void ASTStmtReader::VisitCXXConstCastExpr(CXXConstCastExpr *E) {
1002 return VisitCXXNamedCastExpr(E);
1005 void ASTStmtReader::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E) {
1006 VisitExplicitCastExpr(E);
1007 E->setTypeBeginLoc(ReadSourceLocation(Record, Idx));
1008 E->setRParenLoc(ReadSourceLocation(Record, Idx));
1011 void ASTStmtReader::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
1013 E->setValue(Record[Idx++]);
1014 E->setLocation(ReadSourceLocation(Record, Idx));
1017 void ASTStmtReader::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) {
1019 E->setLocation(ReadSourceLocation(Record, Idx));
1022 void ASTStmtReader::VisitCXXTypeidExpr(CXXTypeidExpr *E) {
1024 E->setSourceRange(ReadSourceRange(Record, Idx));
1025 if (E->isTypeOperand()) { // typeid(int)
1026 E->setTypeOperandSourceInfo(
1027 GetTypeSourceInfo(Record, Idx));
1032 E->setExprOperand(Reader.ReadSubExpr());
1035 void ASTStmtReader::VisitCXXThisExpr(CXXThisExpr *E) {
1037 E->setLocation(ReadSourceLocation(Record, Idx));
1038 E->setImplicit(Record[Idx++]);
1041 void ASTStmtReader::VisitCXXThrowExpr(CXXThrowExpr *E) {
1043 E->ThrowLoc = ReadSourceLocation(Record, Idx);
1044 E->Op = Reader.ReadSubExpr();
1045 E->IsThrownVariableInScope = Record[Idx++];
1048 void ASTStmtReader::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
1051 assert(Record[Idx] == E->Param.getInt() && "We messed up at creation ?");
1052 ++Idx; // HasOtherExprStored and SubExpr was handled during creation.
1053 E->Param.setPointer(cast<ParmVarDecl>(Reader.GetDecl(Record[Idx++])));
1054 E->Loc = ReadSourceLocation(Record, Idx);
1057 void ASTStmtReader::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
1059 E->setTemporary(Reader.ReadCXXTemporary(Record, Idx));
1060 E->setSubExpr(Reader.ReadSubExpr());
1063 void ASTStmtReader::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
1065 E->TypeInfo = GetTypeSourceInfo(Record, Idx);
1066 E->RParenLoc = ReadSourceLocation(Record, Idx);
1069 void ASTStmtReader::VisitCXXNewExpr(CXXNewExpr *E) {
1071 E->GlobalNew = Record[Idx++];
1072 E->Initializer = Record[Idx++];
1073 E->UsualArrayDeleteWantsSize = Record[Idx++];
1074 bool isArray = Record[Idx++];
1075 unsigned NumPlacementArgs = Record[Idx++];
1076 unsigned NumCtorArgs = Record[Idx++];
1077 E->setOperatorNew(cast_or_null<FunctionDecl>(Reader.GetDecl(Record[Idx++])));
1078 E->setOperatorDelete(
1079 cast_or_null<FunctionDecl>(Reader.GetDecl(Record[Idx++])));
1081 cast_or_null<CXXConstructorDecl>(Reader.GetDecl(Record[Idx++])));
1082 E->AllocatedTypeInfo = GetTypeSourceInfo(Record, Idx);
1083 SourceRange TypeIdParens;
1084 TypeIdParens.setBegin(ReadSourceLocation(Record, Idx));
1085 TypeIdParens.setEnd(ReadSourceLocation(Record, Idx));
1086 E->TypeIdParens = TypeIdParens;
1087 E->StartLoc = ReadSourceLocation(Record, Idx);
1088 E->EndLoc = ReadSourceLocation(Record, Idx);
1089 E->ConstructorLParen = ReadSourceLocation(Record, Idx);
1090 E->ConstructorRParen = ReadSourceLocation(Record, Idx);
1092 E->AllocateArgsArray(*Reader.getContext(), isArray, NumPlacementArgs,
1095 // Install all the subexpressions.
1096 for (CXXNewExpr::raw_arg_iterator I = E->raw_arg_begin(),e = E->raw_arg_end();
1098 *I = Reader.ReadSubStmt();
1101 void ASTStmtReader::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
1103 E->GlobalDelete = Record[Idx++];
1104 E->ArrayForm = Record[Idx++];
1105 E->ArrayFormAsWritten = Record[Idx++];
1106 E->UsualArrayDeleteWantsSize = Record[Idx++];
1107 E->OperatorDelete = cast_or_null<FunctionDecl>(Reader.GetDecl(Record[Idx++]));
1108 E->Argument = Reader.ReadSubExpr();
1109 E->Loc = ReadSourceLocation(Record, Idx);
1112 void ASTStmtReader::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) {
1115 E->Base = Reader.ReadSubExpr();
1116 E->IsArrow = Record[Idx++];
1117 E->OperatorLoc = ReadSourceLocation(Record, Idx);
1118 E->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1119 E->ScopeType = GetTypeSourceInfo(Record, Idx);
1120 E->ColonColonLoc = ReadSourceLocation(Record, Idx);
1121 E->TildeLoc = ReadSourceLocation(Record, Idx);
1123 IdentifierInfo *II = Reader.GetIdentifierInfo(Record, Idx);
1125 E->setDestroyedType(II, ReadSourceLocation(Record, Idx));
1127 E->setDestroyedType(GetTypeSourceInfo(Record, Idx));
1130 void ASTStmtReader::VisitExprWithCleanups(ExprWithCleanups *E) {
1132 unsigned NumTemps = Record[Idx++];
1134 E->setNumTemporaries(*Reader.getContext(), NumTemps);
1135 for (unsigned i = 0; i != NumTemps; ++i)
1136 E->setTemporary(i, Reader.ReadCXXTemporary(Record, Idx));
1138 E->setSubExpr(Reader.ReadSubExpr());
1142 ASTStmtReader::VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E){
1146 ReadExplicitTemplateArgumentList(E->getExplicitTemplateArgs(),
1149 E->Base = Reader.ReadSubExpr();
1150 E->BaseType = Reader.GetType(Record[Idx++]);
1151 E->IsArrow = Record[Idx++];
1152 E->OperatorLoc = ReadSourceLocation(Record, Idx);
1153 E->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1154 E->FirstQualifierFoundInScope
1155 = cast_or_null<NamedDecl>(Reader.GetDecl(Record[Idx++]));
1156 ReadDeclarationNameInfo(E->MemberNameInfo, Record, Idx);
1160 ASTStmtReader::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) {
1164 ReadExplicitTemplateArgumentList(E->getExplicitTemplateArgs(),
1167 E->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1168 ReadDeclarationNameInfo(E->NameInfo, Record, Idx);
1172 ASTStmtReader::VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E) {
1174 assert(Record[Idx] == E->arg_size() && "Read wrong record during creation ?");
1176 for (unsigned I = 0, N = E->arg_size(); I != N; ++I)
1177 E->setArg(I, Reader.ReadSubExpr());
1178 E->Type = GetTypeSourceInfo(Record, Idx);
1179 E->setLParenLoc(ReadSourceLocation(Record, Idx));
1180 E->setRParenLoc(ReadSourceLocation(Record, Idx));
1183 void ASTStmtReader::VisitOverloadExpr(OverloadExpr *E) {
1186 // Read the explicit template argument list, if available.
1188 ReadExplicitTemplateArgumentList(E->getExplicitTemplateArgs(),
1191 unsigned NumDecls = Record[Idx++];
1192 UnresolvedSet<8> Decls;
1193 for (unsigned i = 0; i != NumDecls; ++i) {
1194 NamedDecl *D = cast<NamedDecl>(Reader.GetDecl(Record[Idx++]));
1195 AccessSpecifier AS = (AccessSpecifier)Record[Idx++];
1196 Decls.addDecl(D, AS);
1198 E->initializeResults(*Reader.getContext(), Decls.begin(), Decls.end());
1200 ReadDeclarationNameInfo(E->NameInfo, Record, Idx);
1201 E->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1204 void ASTStmtReader::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) {
1205 VisitOverloadExpr(E);
1206 E->IsArrow = Record[Idx++];
1207 E->HasUnresolvedUsing = Record[Idx++];
1208 E->Base = Reader.ReadSubExpr();
1209 E->BaseType = Reader.GetType(Record[Idx++]);
1210 E->OperatorLoc = ReadSourceLocation(Record, Idx);
1213 void ASTStmtReader::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) {
1214 VisitOverloadExpr(E);
1215 E->RequiresADL = Record[Idx++];
1217 E->StdIsAssociatedNamespace = Record[Idx++];
1218 E->Overloaded = Record[Idx++];
1219 E->NamingClass = cast_or_null<CXXRecordDecl>(Reader.GetDecl(Record[Idx++]));
1222 void ASTStmtReader::VisitUnaryTypeTraitExpr(UnaryTypeTraitExpr *E) {
1224 E->UTT = (UnaryTypeTrait)Record[Idx++];
1225 E->Value = (bool)Record[Idx++];
1226 SourceRange Range = ReadSourceRange(Record, Idx);
1227 E->Loc = Range.getBegin();
1228 E->RParen = Range.getEnd();
1229 E->QueriedType = GetTypeSourceInfo(Record, Idx);
1232 void ASTStmtReader::VisitBinaryTypeTraitExpr(BinaryTypeTraitExpr *E) {
1234 E->BTT = (BinaryTypeTrait)Record[Idx++];
1235 E->Value = (bool)Record[Idx++];
1236 SourceRange Range = ReadSourceRange(Record, Idx);
1237 E->Loc = Range.getBegin();
1238 E->RParen = Range.getEnd();
1239 E->LhsType = GetTypeSourceInfo(Record, Idx);
1240 E->RhsType = GetTypeSourceInfo(Record, Idx);
1243 void ASTStmtReader::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
1245 E->ATT = (ArrayTypeTrait)Record[Idx++];
1246 E->Value = (unsigned int)Record[Idx++];
1247 SourceRange Range = ReadSourceRange(Record, Idx);
1248 E->Loc = Range.getBegin();
1249 E->RParen = Range.getEnd();
1250 E->QueriedType = GetTypeSourceInfo(Record, Idx);
1253 void ASTStmtReader::VisitExpressionTraitExpr(ExpressionTraitExpr *E) {
1255 E->ET = (ExpressionTrait)Record[Idx++];
1256 E->Value = (bool)Record[Idx++];
1257 SourceRange Range = ReadSourceRange(Record, Idx);
1258 E->QueriedExpression = Reader.ReadSubExpr();
1259 E->Loc = Range.getBegin();
1260 E->RParen = Range.getEnd();
1263 void ASTStmtReader::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) {
1265 E->Value = (bool)Record[Idx++];
1266 E->Range = ReadSourceRange(Record, Idx);
1267 E->Operand = Reader.ReadSubExpr();
1270 void ASTStmtReader::VisitPackExpansionExpr(PackExpansionExpr *E) {
1272 E->EllipsisLoc = ReadSourceLocation(Record, Idx);
1273 E->NumExpansions = Record[Idx++];
1274 E->Pattern = Reader.ReadSubExpr();
1277 void ASTStmtReader::VisitSizeOfPackExpr(SizeOfPackExpr *E) {
1279 E->OperatorLoc = ReadSourceLocation(Record, Idx);
1280 E->PackLoc = ReadSourceLocation(Record, Idx);
1281 E->RParenLoc = ReadSourceLocation(Record, Idx);
1282 E->Length = Record[Idx++];
1283 E->Pack = cast_or_null<NamedDecl>(Reader.GetDecl(Record[Idx++]));
1286 void ASTStmtReader::VisitSubstNonTypeTemplateParmExpr(
1287 SubstNonTypeTemplateParmExpr *E) {
1290 = cast_or_null<NonTypeTemplateParmDecl>(Reader.GetDecl(Record[Idx++]));
1291 E->NameLoc = ReadSourceLocation(Record, Idx);
1292 E->Replacement = Reader.ReadSubExpr();
1295 void ASTStmtReader::VisitSubstNonTypeTemplateParmPackExpr(
1296 SubstNonTypeTemplateParmPackExpr *E) {
1299 = cast_or_null<NonTypeTemplateParmDecl>(Reader.GetDecl(Record[Idx++]));
1300 TemplateArgument ArgPack = Reader.ReadTemplateArgument(F, Record, Idx);
1301 if (ArgPack.getKind() != TemplateArgument::Pack)
1304 E->Arguments = ArgPack.pack_begin();
1305 E->NumArguments = ArgPack.pack_size();
1306 E->NameLoc = ReadSourceLocation(Record, Idx);
1309 void ASTStmtReader::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) {
1311 E->Temporary = Reader.ReadSubExpr();
1314 void ASTStmtReader::VisitOpaqueValueExpr(OpaqueValueExpr *E) {
1317 E->Loc = ReadSourceLocation(Record, Idx);
1320 //===----------------------------------------------------------------------===//
1321 // Microsoft Expressions and Statements
1322 //===----------------------------------------------------------------------===//
1323 void ASTStmtReader::VisitCXXUuidofExpr(CXXUuidofExpr *E) {
1325 E->setSourceRange(ReadSourceRange(Record, Idx));
1326 if (E->isTypeOperand()) { // __uuidof(ComType)
1327 E->setTypeOperandSourceInfo(
1328 GetTypeSourceInfo(Record, Idx));
1333 E->setExprOperand(Reader.ReadSubExpr());
1336 void ASTStmtReader::VisitSEHExceptStmt(SEHExceptStmt *S) {
1338 S->Loc = ReadSourceLocation(Record, Idx);
1339 S->Children[SEHExceptStmt::FILTER_EXPR] = Reader.ReadSubStmt();
1340 S->Children[SEHExceptStmt::BLOCK] = Reader.ReadSubStmt();
1343 void ASTStmtReader::VisitSEHFinallyStmt(SEHFinallyStmt *S) {
1345 S->Loc = ReadSourceLocation(Record, Idx);
1346 S->Block = Reader.ReadSubStmt();
1349 void ASTStmtReader::VisitSEHTryStmt(SEHTryStmt *S) {
1351 S->IsCXXTry = Record[Idx++];
1352 S->TryLoc = ReadSourceLocation(Record, Idx);
1353 S->Children[SEHTryStmt::TRY] = Reader.ReadSubStmt();
1354 S->Children[SEHTryStmt::HANDLER] = Reader.ReadSubStmt();
1357 //===----------------------------------------------------------------------===//
1358 // CUDA Expressions and Statements
1359 //===----------------------------------------------------------------------===//
1361 void ASTStmtReader::VisitCUDAKernelCallExpr(CUDAKernelCallExpr *E) {
1363 E->setConfig(cast<CallExpr>(Reader.ReadSubExpr()));
1366 //===----------------------------------------------------------------------===//
1367 // OpenCL Expressions and Statements.
1368 //===----------------------------------------------------------------------===//
1369 void ASTStmtReader::VisitAsTypeExpr(AsTypeExpr *E) {
1371 E->BuiltinLoc = ReadSourceLocation(Record, Idx);
1372 E->RParenLoc = ReadSourceLocation(Record, Idx);
1373 E->SrcExpr = Reader.ReadSubExpr();
1376 //===----------------------------------------------------------------------===//
1377 // ASTReader Implementation
1378 //===----------------------------------------------------------------------===//
1380 Stmt *ASTReader::ReadStmt(PerFileData &F) {
1381 switch (ReadingKind) {
1384 return ReadStmtFromStream(F);
1386 return ReadSubStmt();
1389 llvm_unreachable("ReadingKind not set ?");
1393 Expr *ASTReader::ReadExpr(PerFileData &F) {
1394 return cast_or_null<Expr>(ReadStmt(F));
1397 Expr *ASTReader::ReadSubExpr() {
1398 return cast_or_null<Expr>(ReadSubStmt());
1401 // Within the bitstream, expressions are stored in Reverse Polish
1402 // Notation, with each of the subexpressions preceding the
1403 // expression they are stored in. Subexpressions are stored from last to first.
1404 // To evaluate expressions, we continue reading expressions and placing them on
1405 // the stack, with expressions having operands removing those operands from the
1406 // stack. Evaluation terminates when we see a STMT_STOP record, and
1407 // the single remaining expression on the stack is our result.
1408 Stmt *ASTReader::ReadStmtFromStream(PerFileData &F) {
1410 ReadingKindTracker ReadingKind(Read_Stmt, *this);
1411 llvm::BitstreamCursor &Cursor = F.DeclsCursor;
1414 unsigned PrevNumStmts = StmtStack.size();
1419 ASTStmtReader Reader(*this, F, Cursor, Record, Idx);
1420 Stmt::EmptyShell Empty;
1423 unsigned Code = Cursor.ReadCode();
1424 if (Code == llvm::bitc::END_BLOCK) {
1425 if (Cursor.ReadBlockEnd()) {
1426 Error("error at end of block in AST file");
1432 if (Code == llvm::bitc::ENTER_SUBBLOCK) {
1433 // No known subblocks, always skip them.
1434 Cursor.ReadSubBlockID();
1435 if (Cursor.SkipBlock()) {
1436 Error("malformed block record in AST file");
1442 if (Code == llvm::bitc::DEFINE_ABBREV) {
1443 Cursor.ReadAbbrevRecord();
1450 bool Finished = false;
1451 switch ((StmtCode)Cursor.ReadRecord(Code, Record)) {
1461 S = new (Context) NullStmt(Empty);
1465 S = new (Context) CompoundStmt(Empty);
1469 S = new (Context) CaseStmt(Empty);
1473 S = new (Context) DefaultStmt(Empty);
1477 S = new (Context) LabelStmt(Empty);
1481 S = new (Context) IfStmt(Empty);
1485 S = new (Context) SwitchStmt(Empty);
1489 S = new (Context) WhileStmt(Empty);
1493 S = new (Context) DoStmt(Empty);
1497 S = new (Context) ForStmt(Empty);
1501 S = new (Context) GotoStmt(Empty);
1504 case STMT_INDIRECT_GOTO:
1505 S = new (Context) IndirectGotoStmt(Empty);
1509 S = new (Context) ContinueStmt(Empty);
1513 S = new (Context) BreakStmt(Empty);
1517 S = new (Context) ReturnStmt(Empty);
1521 S = new (Context) DeclStmt(Empty);
1525 S = new (Context) AsmStmt(Empty);
1528 case EXPR_PREDEFINED:
1529 S = new (Context) PredefinedExpr(Empty);
1533 S = DeclRefExpr::CreateEmpty(
1535 /*HasQualifier=*/Record[ASTStmtReader::NumExprFields],
1536 /*HasFoundDecl=*/Record[ASTStmtReader::NumExprFields + 1],
1537 /*HasExplicitTemplateArgs=*/Record[ASTStmtReader::NumExprFields + 2],
1538 /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields + 2] ?
1539 Record[ASTStmtReader::NumExprFields + 3] : 0);
1542 case EXPR_INTEGER_LITERAL:
1543 S = IntegerLiteral::Create(*Context, Empty);
1546 case EXPR_FLOATING_LITERAL:
1547 S = FloatingLiteral::Create(*Context, Empty);
1550 case EXPR_IMAGINARY_LITERAL:
1551 S = new (Context) ImaginaryLiteral(Empty);
1554 case EXPR_STRING_LITERAL:
1555 S = StringLiteral::CreateEmpty(*Context,
1556 Record[ASTStmtReader::NumExprFields + 1]);
1559 case EXPR_CHARACTER_LITERAL:
1560 S = new (Context) CharacterLiteral(Empty);
1564 S = new (Context) ParenExpr(Empty);
1567 case EXPR_PAREN_LIST:
1568 S = new (Context) ParenListExpr(Empty);
1571 case EXPR_UNARY_OPERATOR:
1572 S = new (Context) UnaryOperator(Empty);
1576 S = OffsetOfExpr::CreateEmpty(*Context,
1577 Record[ASTStmtReader::NumExprFields],
1578 Record[ASTStmtReader::NumExprFields + 1]);
1581 case EXPR_SIZEOF_ALIGN_OF:
1582 S = new (Context) UnaryExprOrTypeTraitExpr(Empty);
1585 case EXPR_ARRAY_SUBSCRIPT:
1586 S = new (Context) ArraySubscriptExpr(Empty);
1590 S = new (Context) CallExpr(*Context, Stmt::CallExprClass, Empty);
1594 // We load everything here and fully initialize it at creation.
1595 // That way we can use MemberExpr::Create and don't have to duplicate its
1596 // logic with a MemberExpr::CreateEmpty.
1599 NestedNameSpecifierLoc QualifierLoc;
1600 if (Record[Idx++]) { // HasQualifier.
1601 QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, Idx);
1604 TemplateArgumentListInfo ArgInfo;
1605 bool HasExplicitTemplateArgs = Record[Idx++];
1606 if (HasExplicitTemplateArgs) {
1607 unsigned NumTemplateArgs = Record[Idx++];
1608 ArgInfo.setLAngleLoc(ReadSourceLocation(F, Record, Idx));
1609 ArgInfo.setRAngleLoc(ReadSourceLocation(F, Record, Idx));
1610 for (unsigned i = 0; i != NumTemplateArgs; ++i)
1611 ArgInfo.addArgument(ReadTemplateArgumentLoc(F, Record, Idx));
1614 NamedDecl *FoundD = cast_or_null<NamedDecl>(GetDecl(Record[Idx++]));
1615 AccessSpecifier AS = (AccessSpecifier)Record[Idx++];
1616 DeclAccessPair FoundDecl = DeclAccessPair::make(FoundD, AS);
1618 QualType T = GetType(Record[Idx++]);
1619 ExprValueKind VK = static_cast<ExprValueKind>(Record[Idx++]);
1620 ExprObjectKind OK = static_cast<ExprObjectKind>(Record[Idx++]);
1621 Expr *Base = ReadSubExpr();
1622 ValueDecl *MemberD = cast<ValueDecl>(GetDecl(Record[Idx++]));
1623 SourceLocation MemberLoc = ReadSourceLocation(F, Record, Idx);
1624 DeclarationNameInfo MemberNameInfo(MemberD->getDeclName(), MemberLoc);
1625 bool IsArrow = Record[Idx++];
1627 S = MemberExpr::Create(*Context, Base, IsArrow, QualifierLoc,
1628 MemberD, FoundDecl, MemberNameInfo,
1629 HasExplicitTemplateArgs ? &ArgInfo : 0, T, VK, OK);
1630 ReadDeclarationNameLoc(F, cast<MemberExpr>(S)->MemberDNLoc,
1631 MemberD->getDeclName(), Record, Idx);
1635 case EXPR_BINARY_OPERATOR:
1636 S = new (Context) BinaryOperator(Empty);
1639 case EXPR_COMPOUND_ASSIGN_OPERATOR:
1640 S = new (Context) CompoundAssignOperator(Empty);
1643 case EXPR_CONDITIONAL_OPERATOR:
1644 S = new (Context) ConditionalOperator(Empty);
1647 case EXPR_BINARY_CONDITIONAL_OPERATOR:
1648 S = new (Context) BinaryConditionalOperator(Empty);
1651 case EXPR_IMPLICIT_CAST:
1652 S = ImplicitCastExpr::CreateEmpty(*Context,
1653 /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
1656 case EXPR_CSTYLE_CAST:
1657 S = CStyleCastExpr::CreateEmpty(*Context,
1658 /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
1661 case EXPR_COMPOUND_LITERAL:
1662 S = new (Context) CompoundLiteralExpr(Empty);
1665 case EXPR_EXT_VECTOR_ELEMENT:
1666 S = new (Context) ExtVectorElementExpr(Empty);
1669 case EXPR_INIT_LIST:
1670 S = new (Context) InitListExpr(*getContext(), Empty);
1673 case EXPR_DESIGNATED_INIT:
1674 S = DesignatedInitExpr::CreateEmpty(*Context,
1675 Record[ASTStmtReader::NumExprFields] - 1);
1679 case EXPR_IMPLICIT_VALUE_INIT:
1680 S = new (Context) ImplicitValueInitExpr(Empty);
1684 S = new (Context) VAArgExpr(Empty);
1687 case EXPR_ADDR_LABEL:
1688 S = new (Context) AddrLabelExpr(Empty);
1692 S = new (Context) StmtExpr(Empty);
1696 S = new (Context) ChooseExpr(Empty);
1700 S = new (Context) GNUNullExpr(Empty);
1703 case EXPR_SHUFFLE_VECTOR:
1704 S = new (Context) ShuffleVectorExpr(Empty);
1708 S = new (Context) BlockExpr(Empty);
1711 case EXPR_BLOCK_DECL_REF:
1712 S = new (Context) BlockDeclRefExpr(Empty);
1715 case EXPR_GENERIC_SELECTION:
1716 S = new (Context) GenericSelectionExpr(Empty);
1719 case EXPR_OBJC_STRING_LITERAL:
1720 S = new (Context) ObjCStringLiteral(Empty);
1722 case EXPR_OBJC_ENCODE:
1723 S = new (Context) ObjCEncodeExpr(Empty);
1725 case EXPR_OBJC_SELECTOR_EXPR:
1726 S = new (Context) ObjCSelectorExpr(Empty);
1728 case EXPR_OBJC_PROTOCOL_EXPR:
1729 S = new (Context) ObjCProtocolExpr(Empty);
1731 case EXPR_OBJC_IVAR_REF_EXPR:
1732 S = new (Context) ObjCIvarRefExpr(Empty);
1734 case EXPR_OBJC_PROPERTY_REF_EXPR:
1735 S = new (Context) ObjCPropertyRefExpr(Empty);
1737 case EXPR_OBJC_KVC_REF_EXPR:
1738 llvm_unreachable("mismatching AST file");
1740 case EXPR_OBJC_MESSAGE_EXPR:
1741 S = ObjCMessageExpr::CreateEmpty(*Context,
1742 Record[ASTStmtReader::NumExprFields]);
1745 S = new (Context) ObjCIsaExpr(Empty);
1747 case EXPR_OBJC_INDIRECT_COPY_RESTORE:
1748 S = new (Context) ObjCIndirectCopyRestoreExpr(Empty);
1750 case EXPR_OBJC_BRIDGED_CAST:
1751 S = new (Context) ObjCBridgedCastExpr(Empty);
1753 case STMT_OBJC_FOR_COLLECTION:
1754 S = new (Context) ObjCForCollectionStmt(Empty);
1756 case STMT_OBJC_CATCH:
1757 S = new (Context) ObjCAtCatchStmt(Empty);
1759 case STMT_OBJC_FINALLY:
1760 S = new (Context) ObjCAtFinallyStmt(Empty);
1762 case STMT_OBJC_AT_TRY:
1763 S = ObjCAtTryStmt::CreateEmpty(*Context,
1764 Record[ASTStmtReader::NumStmtFields],
1765 Record[ASTStmtReader::NumStmtFields + 1]);
1767 case STMT_OBJC_AT_SYNCHRONIZED:
1768 S = new (Context) ObjCAtSynchronizedStmt(Empty);
1770 case STMT_OBJC_AT_THROW:
1771 S = new (Context) ObjCAtThrowStmt(Empty);
1773 case STMT_OBJC_AUTORELEASE_POOL:
1774 S = new (Context) ObjCAutoreleasePoolStmt(Empty);
1776 case STMT_SEH_EXCEPT:
1777 S = new (Context) SEHExceptStmt(Empty);
1779 case STMT_SEH_FINALLY:
1780 S = new (Context) SEHFinallyStmt(Empty);
1783 S = new (Context) SEHTryStmt(Empty);
1785 case STMT_CXX_CATCH:
1786 S = new (Context) CXXCatchStmt(Empty);
1790 S = CXXTryStmt::Create(*Context, Empty,
1791 /*NumHandlers=*/Record[ASTStmtReader::NumStmtFields]);
1794 case STMT_CXX_FOR_RANGE:
1795 S = new (Context) CXXForRangeStmt(Empty);
1798 case EXPR_CXX_OPERATOR_CALL:
1799 S = new (Context) CXXOperatorCallExpr(*Context, Empty);
1802 case EXPR_CXX_MEMBER_CALL:
1803 S = new (Context) CXXMemberCallExpr(*Context, Empty);
1806 case EXPR_CXX_CONSTRUCT:
1807 S = new (Context) CXXConstructExpr(Empty);
1810 case EXPR_CXX_TEMPORARY_OBJECT:
1811 S = new (Context) CXXTemporaryObjectExpr(Empty);
1814 case EXPR_CXX_STATIC_CAST:
1815 S = CXXStaticCastExpr::CreateEmpty(*Context,
1816 /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
1819 case EXPR_CXX_DYNAMIC_CAST:
1820 S = CXXDynamicCastExpr::CreateEmpty(*Context,
1821 /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
1824 case EXPR_CXX_REINTERPRET_CAST:
1825 S = CXXReinterpretCastExpr::CreateEmpty(*Context,
1826 /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
1829 case EXPR_CXX_CONST_CAST:
1830 S = CXXConstCastExpr::CreateEmpty(*Context);
1833 case EXPR_CXX_FUNCTIONAL_CAST:
1834 S = CXXFunctionalCastExpr::CreateEmpty(*Context,
1835 /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
1838 case EXPR_CXX_BOOL_LITERAL:
1839 S = new (Context) CXXBoolLiteralExpr(Empty);
1842 case EXPR_CXX_NULL_PTR_LITERAL:
1843 S = new (Context) CXXNullPtrLiteralExpr(Empty);
1845 case EXPR_CXX_TYPEID_EXPR:
1846 S = new (Context) CXXTypeidExpr(Empty, true);
1848 case EXPR_CXX_TYPEID_TYPE:
1849 S = new (Context) CXXTypeidExpr(Empty, false);
1851 case EXPR_CXX_UUIDOF_EXPR:
1852 S = new (Context) CXXUuidofExpr(Empty, true);
1854 case EXPR_CXX_UUIDOF_TYPE:
1855 S = new (Context) CXXUuidofExpr(Empty, false);
1858 S = new (Context) CXXThisExpr(Empty);
1860 case EXPR_CXX_THROW:
1861 S = new (Context) CXXThrowExpr(Empty);
1863 case EXPR_CXX_DEFAULT_ARG: {
1864 bool HasOtherExprStored = Record[ASTStmtReader::NumExprFields];
1865 if (HasOtherExprStored) {
1866 Expr *SubExpr = ReadSubExpr();
1867 S = CXXDefaultArgExpr::Create(*Context, SourceLocation(), 0, SubExpr);
1869 S = new (Context) CXXDefaultArgExpr(Empty);
1872 case EXPR_CXX_BIND_TEMPORARY:
1873 S = new (Context) CXXBindTemporaryExpr(Empty);
1876 case EXPR_CXX_SCALAR_VALUE_INIT:
1877 S = new (Context) CXXScalarValueInitExpr(Empty);
1880 S = new (Context) CXXNewExpr(Empty);
1882 case EXPR_CXX_DELETE:
1883 S = new (Context) CXXDeleteExpr(Empty);
1885 case EXPR_CXX_PSEUDO_DESTRUCTOR:
1886 S = new (Context) CXXPseudoDestructorExpr(Empty);
1889 case EXPR_EXPR_WITH_CLEANUPS:
1890 S = new (Context) ExprWithCleanups(Empty);
1893 case EXPR_CXX_DEPENDENT_SCOPE_MEMBER:
1894 S = CXXDependentScopeMemberExpr::CreateEmpty(*Context,
1895 /*HasExplicitTemplateArgs=*/Record[ASTStmtReader::NumExprFields],
1896 /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]
1897 ? Record[ASTStmtReader::NumExprFields + 1]
1901 case EXPR_CXX_DEPENDENT_SCOPE_DECL_REF:
1902 S = DependentScopeDeclRefExpr::CreateEmpty(*Context,
1903 /*HasExplicitTemplateArgs=*/Record[ASTStmtReader::NumExprFields],
1904 /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]
1905 ? Record[ASTStmtReader::NumExprFields + 1]
1909 case EXPR_CXX_UNRESOLVED_CONSTRUCT:
1910 S = CXXUnresolvedConstructExpr::CreateEmpty(*Context,
1911 /*NumArgs=*/Record[ASTStmtReader::NumExprFields]);
1914 case EXPR_CXX_UNRESOLVED_MEMBER:
1915 S = UnresolvedMemberExpr::CreateEmpty(*Context,
1916 /*HasExplicitTemplateArgs=*/Record[ASTStmtReader::NumExprFields],
1917 /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]
1918 ? Record[ASTStmtReader::NumExprFields + 1]
1922 case EXPR_CXX_UNRESOLVED_LOOKUP:
1923 S = UnresolvedLookupExpr::CreateEmpty(*Context,
1924 /*HasExplicitTemplateArgs=*/Record[ASTStmtReader::NumExprFields],
1925 /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]
1926 ? Record[ASTStmtReader::NumExprFields + 1]
1930 case EXPR_CXX_UNARY_TYPE_TRAIT:
1931 S = new (Context) UnaryTypeTraitExpr(Empty);
1934 case EXPR_BINARY_TYPE_TRAIT:
1935 S = new (Context) BinaryTypeTraitExpr(Empty);
1938 case EXPR_ARRAY_TYPE_TRAIT:
1939 S = new (Context) ArrayTypeTraitExpr(Empty);
1942 case EXPR_CXX_EXPRESSION_TRAIT:
1943 S = new (Context) ExpressionTraitExpr(Empty);
1946 case EXPR_CXX_NOEXCEPT:
1947 S = new (Context) CXXNoexceptExpr(Empty);
1950 case EXPR_PACK_EXPANSION:
1951 S = new (Context) PackExpansionExpr(Empty);
1954 case EXPR_SIZEOF_PACK:
1955 S = new (Context) SizeOfPackExpr(Empty);
1958 case EXPR_SUBST_NON_TYPE_TEMPLATE_PARM:
1959 S = new (Context) SubstNonTypeTemplateParmExpr(Empty);
1962 case EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK:
1963 S = new (Context) SubstNonTypeTemplateParmPackExpr(Empty);
1966 case EXPR_MATERIALIZE_TEMPORARY:
1967 S = new (Context) MaterializeTemporaryExpr(Empty);
1970 case EXPR_OPAQUE_VALUE: {
1971 unsigned key = Record[ASTStmtReader::NumExprFields];
1972 OpaqueValueExpr *&expr = OpaqueValueExprs[key];
1974 // If we already have an entry for this opaque value expression,
1975 // don't bother reading it again.
1977 StmtStack.push_back(expr);
1981 S = expr = new (Context) OpaqueValueExpr(Empty);
1985 case EXPR_CUDA_KERNEL_CALL:
1986 S = new (Context) CUDAKernelCallExpr(*Context, Empty);
1990 S = new (Context) AsTypeExpr(Empty);
1994 // We hit a STMT_STOP, so we're done with this expression.
1998 ++NumStatementsRead;
2003 assert(Idx == Record.size() && "Invalid deserialization of statement");
2004 StmtStack.push_back(S);
2008 assert(StmtStack.size() > PrevNumStmts && "Read too many sub stmts!");
2009 assert(StmtStack.size() == PrevNumStmts + 1 && "Extra expressions on stack!");
2012 return StmtStack.pop_back_val();