1 //===--- ExprCXX.cpp - (C++) Expression AST Node Implementation -----------===//
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 // This file implements the subclesses of Expr class declared in ExprCXX.h
12 //===----------------------------------------------------------------------===//
14 #include "clang/Basic/IdentifierTable.h"
15 #include "clang/AST/DeclCXX.h"
16 #include "clang/AST/DeclTemplate.h"
17 #include "clang/AST/ExprCXX.h"
18 #include "clang/AST/TypeLoc.h"
19 using namespace clang;
22 //===----------------------------------------------------------------------===//
23 // Child Iterators for iterating over subexpressions/substatements
24 //===----------------------------------------------------------------------===//
26 QualType CXXTypeidExpr::getTypeOperand() const {
27 assert(isTypeOperand() && "Cannot call getTypeOperand for typeid(expr)");
28 return Operand.get<TypeSourceInfo *>()->getType().getNonReferenceType()
29 .getUnqualifiedType();
32 QualType CXXUuidofExpr::getTypeOperand() const {
33 assert(isTypeOperand() && "Cannot call getTypeOperand for __uuidof(expr)");
34 return Operand.get<TypeSourceInfo *>()->getType().getNonReferenceType()
35 .getUnqualifiedType();
38 // CXXScalarValueInitExpr
39 SourceRange CXXScalarValueInitExpr::getSourceRange() const {
40 SourceLocation Start = RParenLoc;
42 Start = TypeInfo->getTypeLoc().getBeginLoc();
43 return SourceRange(Start, RParenLoc);
47 CXXNewExpr::CXXNewExpr(ASTContext &C, bool globalNew, FunctionDecl *operatorNew,
48 Expr **placementArgs, unsigned numPlaceArgs,
49 SourceRange TypeIdParens, Expr *arraySize,
50 CXXConstructorDecl *constructor, bool initializer,
51 Expr **constructorArgs, unsigned numConsArgs,
52 bool HadMultipleCandidates,
53 FunctionDecl *operatorDelete,
54 bool usualArrayDeleteWantsSize, QualType ty,
55 TypeSourceInfo *AllocatedTypeInfo,
56 SourceLocation startLoc, SourceLocation endLoc,
57 SourceLocation constructorLParen,
58 SourceLocation constructorRParen)
59 : Expr(CXXNewExprClass, ty, VK_RValue, OK_Ordinary,
60 ty->isDependentType(), ty->isDependentType(),
61 ty->isInstantiationDependentType(),
62 ty->containsUnexpandedParameterPack()),
63 GlobalNew(globalNew), Initializer(initializer),
64 UsualArrayDeleteWantsSize(usualArrayDeleteWantsSize),
65 HadMultipleCandidates(HadMultipleCandidates),
66 SubExprs(0), OperatorNew(operatorNew),
67 OperatorDelete(operatorDelete), Constructor(constructor),
68 AllocatedTypeInfo(AllocatedTypeInfo), TypeIdParens(TypeIdParens),
69 StartLoc(startLoc), EndLoc(endLoc), ConstructorLParen(constructorLParen),
70 ConstructorRParen(constructorRParen) {
71 AllocateArgsArray(C, arraySize != 0, numPlaceArgs, numConsArgs);
74 if (arraySize->isInstantiationDependent())
75 ExprBits.InstantiationDependent = true;
77 if (arraySize->containsUnexpandedParameterPack())
78 ExprBits.ContainsUnexpandedParameterPack = true;
80 SubExprs[i++] = arraySize;
83 for (unsigned j = 0; j < NumPlacementArgs; ++j) {
84 if (placementArgs[j]->isInstantiationDependent())
85 ExprBits.InstantiationDependent = true;
86 if (placementArgs[j]->containsUnexpandedParameterPack())
87 ExprBits.ContainsUnexpandedParameterPack = true;
89 SubExprs[i++] = placementArgs[j];
92 for (unsigned j = 0; j < NumConstructorArgs; ++j) {
93 if (constructorArgs[j]->isInstantiationDependent())
94 ExprBits.InstantiationDependent = true;
95 if (constructorArgs[j]->containsUnexpandedParameterPack())
96 ExprBits.ContainsUnexpandedParameterPack = true;
98 SubExprs[i++] = constructorArgs[j];
102 void CXXNewExpr::AllocateArgsArray(ASTContext &C, bool isArray,
103 unsigned numPlaceArgs, unsigned numConsArgs){
104 assert(SubExprs == 0 && "SubExprs already allocated");
106 NumPlacementArgs = numPlaceArgs;
107 NumConstructorArgs = numConsArgs;
109 unsigned TotalSize = Array + NumPlacementArgs + NumConstructorArgs;
110 SubExprs = new (C) Stmt*[TotalSize];
113 bool CXXNewExpr::shouldNullCheckAllocation(ASTContext &Ctx) const {
114 return getOperatorNew()->getType()->
115 castAs<FunctionProtoType>()->isNothrow(Ctx);
119 QualType CXXDeleteExpr::getDestroyedType() const {
120 const Expr *Arg = getArgument();
121 while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Arg)) {
122 if (ICE->getCastKind() != CK_UserDefinedConversion &&
123 ICE->getType()->isVoidPointerType())
124 Arg = ICE->getSubExpr();
128 // The type-to-delete may not be a pointer if it's a dependent type.
129 const QualType ArgType = Arg->getType();
131 if (ArgType->isDependentType() && !ArgType->isPointerType())
134 return ArgType->getAs<PointerType>()->getPointeeType();
137 // CXXPseudoDestructorExpr
138 PseudoDestructorTypeStorage::PseudoDestructorTypeStorage(TypeSourceInfo *Info)
141 Location = Info->getTypeLoc().getLocalSourceRange().getBegin();
144 CXXPseudoDestructorExpr::CXXPseudoDestructorExpr(ASTContext &Context,
145 Expr *Base, bool isArrow, SourceLocation OperatorLoc,
146 NestedNameSpecifierLoc QualifierLoc, TypeSourceInfo *ScopeType,
147 SourceLocation ColonColonLoc, SourceLocation TildeLoc,
148 PseudoDestructorTypeStorage DestroyedType)
149 : Expr(CXXPseudoDestructorExprClass,
150 Context.getPointerType(Context.getFunctionType(Context.VoidTy, 0, 0,
151 FunctionProtoType::ExtProtoInfo())),
152 VK_RValue, OK_Ordinary,
153 /*isTypeDependent=*/(Base->isTypeDependent() ||
154 (DestroyedType.getTypeSourceInfo() &&
155 DestroyedType.getTypeSourceInfo()->getType()->isDependentType())),
156 /*isValueDependent=*/Base->isValueDependent(),
157 (Base->isInstantiationDependent() ||
159 QualifierLoc.getNestedNameSpecifier()->isInstantiationDependent()) ||
161 ScopeType->getType()->isInstantiationDependentType()) ||
162 (DestroyedType.getTypeSourceInfo() &&
163 DestroyedType.getTypeSourceInfo()->getType()
164 ->isInstantiationDependentType())),
165 // ContainsUnexpandedParameterPack
166 (Base->containsUnexpandedParameterPack() ||
168 QualifierLoc.getNestedNameSpecifier()
169 ->containsUnexpandedParameterPack()) ||
171 ScopeType->getType()->containsUnexpandedParameterPack()) ||
172 (DestroyedType.getTypeSourceInfo() &&
173 DestroyedType.getTypeSourceInfo()->getType()
174 ->containsUnexpandedParameterPack()))),
175 Base(static_cast<Stmt *>(Base)), IsArrow(isArrow),
176 OperatorLoc(OperatorLoc), QualifierLoc(QualifierLoc),
177 ScopeType(ScopeType), ColonColonLoc(ColonColonLoc), TildeLoc(TildeLoc),
178 DestroyedType(DestroyedType) { }
180 QualType CXXPseudoDestructorExpr::getDestroyedType() const {
181 if (TypeSourceInfo *TInfo = DestroyedType.getTypeSourceInfo())
182 return TInfo->getType();
187 SourceRange CXXPseudoDestructorExpr::getSourceRange() const {
188 SourceLocation End = DestroyedType.getLocation();
189 if (TypeSourceInfo *TInfo = DestroyedType.getTypeSourceInfo())
190 End = TInfo->getTypeLoc().getLocalSourceRange().getEnd();
191 return SourceRange(Base->getLocStart(), End);
195 // UnresolvedLookupExpr
196 UnresolvedLookupExpr *
197 UnresolvedLookupExpr::Create(ASTContext &C,
198 CXXRecordDecl *NamingClass,
199 NestedNameSpecifierLoc QualifierLoc,
200 const DeclarationNameInfo &NameInfo,
202 const TemplateArgumentListInfo &Args,
203 UnresolvedSetIterator Begin,
204 UnresolvedSetIterator End)
206 void *Mem = C.Allocate(sizeof(UnresolvedLookupExpr) +
207 ASTTemplateArgumentListInfo::sizeFor(Args));
208 return new (Mem) UnresolvedLookupExpr(C, NamingClass, QualifierLoc, NameInfo,
209 ADL, /*Overload*/ true, &Args,
210 Begin, End, /*StdIsAssociated=*/false);
213 UnresolvedLookupExpr *
214 UnresolvedLookupExpr::CreateEmpty(ASTContext &C, bool HasExplicitTemplateArgs,
215 unsigned NumTemplateArgs) {
216 std::size_t size = sizeof(UnresolvedLookupExpr);
217 if (HasExplicitTemplateArgs)
218 size += ASTTemplateArgumentListInfo::sizeFor(NumTemplateArgs);
220 void *Mem = C.Allocate(size, llvm::alignOf<UnresolvedLookupExpr>());
221 UnresolvedLookupExpr *E = new (Mem) UnresolvedLookupExpr(EmptyShell());
222 E->HasExplicitTemplateArgs = HasExplicitTemplateArgs;
226 OverloadExpr::OverloadExpr(StmtClass K, ASTContext &C,
227 NestedNameSpecifierLoc QualifierLoc,
228 const DeclarationNameInfo &NameInfo,
229 const TemplateArgumentListInfo *TemplateArgs,
230 UnresolvedSetIterator Begin,
231 UnresolvedSetIterator End,
233 bool KnownInstantiationDependent,
234 bool KnownContainsUnexpandedParameterPack)
235 : Expr(K, C.OverloadTy, VK_LValue, OK_Ordinary, KnownDependent,
237 (KnownInstantiationDependent ||
238 NameInfo.isInstantiationDependent() ||
240 QualifierLoc.getNestedNameSpecifier()->isInstantiationDependent())),
241 (KnownContainsUnexpandedParameterPack ||
242 NameInfo.containsUnexpandedParameterPack() ||
244 QualifierLoc.getNestedNameSpecifier()
245 ->containsUnexpandedParameterPack()))),
246 Results(0), NumResults(End - Begin), NameInfo(NameInfo),
247 QualifierLoc(QualifierLoc), HasExplicitTemplateArgs(TemplateArgs != 0)
249 NumResults = End - Begin;
251 // Determine whether this expression is type-dependent.
252 for (UnresolvedSetImpl::const_iterator I = Begin; I != End; ++I) {
253 if ((*I)->getDeclContext()->isDependentContext() ||
254 isa<UnresolvedUsingValueDecl>(*I)) {
255 ExprBits.TypeDependent = true;
256 ExprBits.ValueDependent = true;
260 Results = static_cast<DeclAccessPair *>(
261 C.Allocate(sizeof(DeclAccessPair) * NumResults,
262 llvm::alignOf<DeclAccessPair>()));
263 memcpy(Results, &*Begin.getIterator(),
264 NumResults * sizeof(DeclAccessPair));
267 // If we have explicit template arguments, check for dependent
268 // template arguments and whether they contain any unexpanded pack
271 bool Dependent = false;
272 bool InstantiationDependent = false;
273 bool ContainsUnexpandedParameterPack = false;
274 getExplicitTemplateArgs().initializeFrom(*TemplateArgs, Dependent,
275 InstantiationDependent,
276 ContainsUnexpandedParameterPack);
279 ExprBits.TypeDependent = true;
280 ExprBits.ValueDependent = true;
282 if (InstantiationDependent)
283 ExprBits.InstantiationDependent = true;
284 if (ContainsUnexpandedParameterPack)
285 ExprBits.ContainsUnexpandedParameterPack = true;
288 if (isTypeDependent())
289 setType(C.DependentTy);
292 void OverloadExpr::initializeResults(ASTContext &C,
293 UnresolvedSetIterator Begin,
294 UnresolvedSetIterator End) {
295 assert(Results == 0 && "Results already initialized!");
296 NumResults = End - Begin;
298 Results = static_cast<DeclAccessPair *>(
299 C.Allocate(sizeof(DeclAccessPair) * NumResults,
301 llvm::alignOf<DeclAccessPair>()));
302 memcpy(Results, &*Begin.getIterator(),
303 NumResults * sizeof(DeclAccessPair));
307 CXXRecordDecl *OverloadExpr::getNamingClass() const {
308 if (isa<UnresolvedLookupExpr>(this))
309 return cast<UnresolvedLookupExpr>(this)->getNamingClass();
311 return cast<UnresolvedMemberExpr>(this)->getNamingClass();
314 // DependentScopeDeclRefExpr
315 DependentScopeDeclRefExpr::DependentScopeDeclRefExpr(QualType T,
316 NestedNameSpecifierLoc QualifierLoc,
317 const DeclarationNameInfo &NameInfo,
318 const TemplateArgumentListInfo *Args)
319 : Expr(DependentScopeDeclRefExprClass, T, VK_LValue, OK_Ordinary,
321 (NameInfo.isInstantiationDependent() ||
323 QualifierLoc.getNestedNameSpecifier()->isInstantiationDependent())),
324 (NameInfo.containsUnexpandedParameterPack() ||
326 QualifierLoc.getNestedNameSpecifier()
327 ->containsUnexpandedParameterPack()))),
328 QualifierLoc(QualifierLoc), NameInfo(NameInfo),
329 HasExplicitTemplateArgs(Args != 0)
332 bool Dependent = true;
333 bool InstantiationDependent = true;
334 bool ContainsUnexpandedParameterPack
335 = ExprBits.ContainsUnexpandedParameterPack;
337 reinterpret_cast<ASTTemplateArgumentListInfo*>(this+1)
338 ->initializeFrom(*Args, Dependent, InstantiationDependent,
339 ContainsUnexpandedParameterPack);
341 ExprBits.ContainsUnexpandedParameterPack = ContainsUnexpandedParameterPack;
345 DependentScopeDeclRefExpr *
346 DependentScopeDeclRefExpr::Create(ASTContext &C,
347 NestedNameSpecifierLoc QualifierLoc,
348 const DeclarationNameInfo &NameInfo,
349 const TemplateArgumentListInfo *Args) {
350 std::size_t size = sizeof(DependentScopeDeclRefExpr);
352 size += ASTTemplateArgumentListInfo::sizeFor(*Args);
353 void *Mem = C.Allocate(size);
354 return new (Mem) DependentScopeDeclRefExpr(C.DependentTy, QualifierLoc,
358 DependentScopeDeclRefExpr *
359 DependentScopeDeclRefExpr::CreateEmpty(ASTContext &C,
360 bool HasExplicitTemplateArgs,
361 unsigned NumTemplateArgs) {
362 std::size_t size = sizeof(DependentScopeDeclRefExpr);
363 if (HasExplicitTemplateArgs)
364 size += ASTTemplateArgumentListInfo::sizeFor(NumTemplateArgs);
365 void *Mem = C.Allocate(size);
366 DependentScopeDeclRefExpr *E
367 = new (Mem) DependentScopeDeclRefExpr(QualType(), NestedNameSpecifierLoc(),
368 DeclarationNameInfo(), 0);
369 E->HasExplicitTemplateArgs = HasExplicitTemplateArgs;
373 SourceRange CXXConstructExpr::getSourceRange() const {
374 if (isa<CXXTemporaryObjectExpr>(this))
375 return cast<CXXTemporaryObjectExpr>(this)->getSourceRange();
377 if (ParenRange.isValid())
378 return SourceRange(Loc, ParenRange.getEnd());
380 SourceLocation End = Loc;
381 for (unsigned I = getNumArgs(); I > 0; --I) {
382 const Expr *Arg = getArg(I-1);
383 if (!Arg->isDefaultArgument()) {
384 SourceLocation NewEnd = Arg->getLocEnd();
385 if (NewEnd.isValid()) {
392 return SourceRange(Loc, End);
395 SourceRange CXXOperatorCallExpr::getSourceRange() const {
396 OverloadedOperatorKind Kind = getOperator();
397 if (Kind == OO_PlusPlus || Kind == OO_MinusMinus) {
398 if (getNumArgs() == 1)
400 return SourceRange(getOperatorLoc(),
401 getArg(0)->getSourceRange().getEnd());
404 return SourceRange(getArg(0)->getSourceRange().getBegin(),
406 } else if (Kind == OO_Arrow) {
407 return getArg(0)->getSourceRange();
408 } else if (Kind == OO_Call) {
409 return SourceRange(getArg(0)->getSourceRange().getBegin(), getRParenLoc());
410 } else if (Kind == OO_Subscript) {
411 return SourceRange(getArg(0)->getSourceRange().getBegin(), getRParenLoc());
412 } else if (getNumArgs() == 1) {
413 return SourceRange(getOperatorLoc(), getArg(0)->getSourceRange().getEnd());
414 } else if (getNumArgs() == 2) {
415 return SourceRange(getArg(0)->getSourceRange().getBegin(),
416 getArg(1)->getSourceRange().getEnd());
418 return SourceRange();
422 Expr *CXXMemberCallExpr::getImplicitObjectArgument() const {
423 if (const MemberExpr *MemExpr =
424 dyn_cast<MemberExpr>(getCallee()->IgnoreParens()))
425 return MemExpr->getBase();
427 // FIXME: Will eventually need to cope with member pointers.
431 CXXMethodDecl *CXXMemberCallExpr::getMethodDecl() const {
432 if (const MemberExpr *MemExpr =
433 dyn_cast<MemberExpr>(getCallee()->IgnoreParens()))
434 return cast<CXXMethodDecl>(MemExpr->getMemberDecl());
436 // FIXME: Will eventually need to cope with member pointers.
441 CXXRecordDecl *CXXMemberCallExpr::getRecordDecl() {
442 Expr* ThisArg = getImplicitObjectArgument();
446 if (ThisArg->getType()->isAnyPointerType())
447 return ThisArg->getType()->getPointeeType()->getAsCXXRecordDecl();
449 return ThisArg->getType()->getAsCXXRecordDecl();
453 //===----------------------------------------------------------------------===//
455 //===----------------------------------------------------------------------===//
457 /// getCastName - Get the name of the C++ cast being used, e.g.,
458 /// "static_cast", "dynamic_cast", "reinterpret_cast", or
459 /// "const_cast". The returned pointer must not be freed.
460 const char *CXXNamedCastExpr::getCastName() const {
461 switch (getStmtClass()) {
462 case CXXStaticCastExprClass: return "static_cast";
463 case CXXDynamicCastExprClass: return "dynamic_cast";
464 case CXXReinterpretCastExprClass: return "reinterpret_cast";
465 case CXXConstCastExprClass: return "const_cast";
466 default: return "<invalid cast>";
470 CXXStaticCastExpr *CXXStaticCastExpr::Create(ASTContext &C, QualType T,
472 CastKind K, Expr *Op,
473 const CXXCastPath *BasePath,
474 TypeSourceInfo *WrittenTy,
476 SourceLocation RParenLoc) {
477 unsigned PathSize = (BasePath ? BasePath->size() : 0);
478 void *Buffer = C.Allocate(sizeof(CXXStaticCastExpr)
479 + PathSize * sizeof(CXXBaseSpecifier*));
480 CXXStaticCastExpr *E =
481 new (Buffer) CXXStaticCastExpr(T, VK, K, Op, PathSize, WrittenTy, L,
483 if (PathSize) E->setCastPath(*BasePath);
487 CXXStaticCastExpr *CXXStaticCastExpr::CreateEmpty(ASTContext &C,
490 C.Allocate(sizeof(CXXStaticCastExpr) + PathSize * sizeof(CXXBaseSpecifier*));
491 return new (Buffer) CXXStaticCastExpr(EmptyShell(), PathSize);
494 CXXDynamicCastExpr *CXXDynamicCastExpr::Create(ASTContext &C, QualType T,
496 CastKind K, Expr *Op,
497 const CXXCastPath *BasePath,
498 TypeSourceInfo *WrittenTy,
500 SourceLocation RParenLoc) {
501 unsigned PathSize = (BasePath ? BasePath->size() : 0);
502 void *Buffer = C.Allocate(sizeof(CXXDynamicCastExpr)
503 + PathSize * sizeof(CXXBaseSpecifier*));
504 CXXDynamicCastExpr *E =
505 new (Buffer) CXXDynamicCastExpr(T, VK, K, Op, PathSize, WrittenTy, L,
507 if (PathSize) E->setCastPath(*BasePath);
511 CXXDynamicCastExpr *CXXDynamicCastExpr::CreateEmpty(ASTContext &C,
514 C.Allocate(sizeof(CXXDynamicCastExpr) + PathSize * sizeof(CXXBaseSpecifier*));
515 return new (Buffer) CXXDynamicCastExpr(EmptyShell(), PathSize);
518 /// isAlwaysNull - Return whether the result of the dynamic_cast is proven
519 /// to always be null. For example:
522 /// struct B final : A { };
525 /// C *f(B* b) { return dynamic_cast<C*>(b); }
526 bool CXXDynamicCastExpr::isAlwaysNull() const
528 QualType SrcType = getSubExpr()->getType();
529 QualType DestType = getType();
531 if (const PointerType *SrcPTy = SrcType->getAs<PointerType>()) {
532 SrcType = SrcPTy->getPointeeType();
533 DestType = DestType->castAs<PointerType>()->getPointeeType();
536 const CXXRecordDecl *SrcRD =
537 cast<CXXRecordDecl>(SrcType->castAs<RecordType>()->getDecl());
539 if (!SrcRD->hasAttr<FinalAttr>())
542 const CXXRecordDecl *DestRD =
543 cast<CXXRecordDecl>(DestType->castAs<RecordType>()->getDecl());
545 return !DestRD->isDerivedFrom(SrcRD);
548 CXXReinterpretCastExpr *
549 CXXReinterpretCastExpr::Create(ASTContext &C, QualType T, ExprValueKind VK,
550 CastKind K, Expr *Op,
551 const CXXCastPath *BasePath,
552 TypeSourceInfo *WrittenTy, SourceLocation L,
553 SourceLocation RParenLoc) {
554 unsigned PathSize = (BasePath ? BasePath->size() : 0);
556 C.Allocate(sizeof(CXXReinterpretCastExpr) + PathSize * sizeof(CXXBaseSpecifier*));
557 CXXReinterpretCastExpr *E =
558 new (Buffer) CXXReinterpretCastExpr(T, VK, K, Op, PathSize, WrittenTy, L,
560 if (PathSize) E->setCastPath(*BasePath);
564 CXXReinterpretCastExpr *
565 CXXReinterpretCastExpr::CreateEmpty(ASTContext &C, unsigned PathSize) {
566 void *Buffer = C.Allocate(sizeof(CXXReinterpretCastExpr)
567 + PathSize * sizeof(CXXBaseSpecifier*));
568 return new (Buffer) CXXReinterpretCastExpr(EmptyShell(), PathSize);
571 CXXConstCastExpr *CXXConstCastExpr::Create(ASTContext &C, QualType T,
572 ExprValueKind VK, Expr *Op,
573 TypeSourceInfo *WrittenTy,
575 SourceLocation RParenLoc) {
576 return new (C) CXXConstCastExpr(T, VK, Op, WrittenTy, L, RParenLoc);
579 CXXConstCastExpr *CXXConstCastExpr::CreateEmpty(ASTContext &C) {
580 return new (C) CXXConstCastExpr(EmptyShell());
583 CXXFunctionalCastExpr *
584 CXXFunctionalCastExpr::Create(ASTContext &C, QualType T, ExprValueKind VK,
585 TypeSourceInfo *Written, SourceLocation L,
586 CastKind K, Expr *Op, const CXXCastPath *BasePath,
588 unsigned PathSize = (BasePath ? BasePath->size() : 0);
589 void *Buffer = C.Allocate(sizeof(CXXFunctionalCastExpr)
590 + PathSize * sizeof(CXXBaseSpecifier*));
591 CXXFunctionalCastExpr *E =
592 new (Buffer) CXXFunctionalCastExpr(T, VK, Written, L, K, Op, PathSize, R);
593 if (PathSize) E->setCastPath(*BasePath);
597 CXXFunctionalCastExpr *
598 CXXFunctionalCastExpr::CreateEmpty(ASTContext &C, unsigned PathSize) {
599 void *Buffer = C.Allocate(sizeof(CXXFunctionalCastExpr)
600 + PathSize * sizeof(CXXBaseSpecifier*));
601 return new (Buffer) CXXFunctionalCastExpr(EmptyShell(), PathSize);
606 CXXDefaultArgExpr::Create(ASTContext &C, SourceLocation Loc,
607 ParmVarDecl *Param, Expr *SubExpr) {
608 void *Mem = C.Allocate(sizeof(CXXDefaultArgExpr) + sizeof(Stmt *));
609 return new (Mem) CXXDefaultArgExpr(CXXDefaultArgExprClass, Loc, Param,
613 CXXTemporary *CXXTemporary::Create(ASTContext &C,
614 const CXXDestructorDecl *Destructor) {
615 return new (C) CXXTemporary(Destructor);
618 CXXBindTemporaryExpr *CXXBindTemporaryExpr::Create(ASTContext &C,
621 assert(SubExpr->getType()->isRecordType() &&
622 "Expression bound to a temporary must have record type!");
624 return new (C) CXXBindTemporaryExpr(Temp, SubExpr);
627 CXXTemporaryObjectExpr::CXXTemporaryObjectExpr(ASTContext &C,
628 CXXConstructorDecl *Cons,
629 TypeSourceInfo *Type,
632 SourceRange parenRange,
633 bool HadMultipleCandidates,
634 bool ZeroInitialization)
635 : CXXConstructExpr(C, CXXTemporaryObjectExprClass,
636 Type->getType().getNonReferenceType(),
637 Type->getTypeLoc().getBeginLoc(),
638 Cons, false, Args, NumArgs,
639 HadMultipleCandidates, ZeroInitialization,
640 CXXConstructExpr::CK_Complete, parenRange),
644 SourceRange CXXTemporaryObjectExpr::getSourceRange() const {
645 return SourceRange(Type->getTypeLoc().getBeginLoc(),
646 getParenRange().getEnd());
649 CXXConstructExpr *CXXConstructExpr::Create(ASTContext &C, QualType T,
651 CXXConstructorDecl *D, bool Elidable,
652 Expr **Args, unsigned NumArgs,
653 bool HadMultipleCandidates,
654 bool ZeroInitialization,
655 ConstructionKind ConstructKind,
656 SourceRange ParenRange) {
657 return new (C) CXXConstructExpr(C, CXXConstructExprClass, T, Loc, D,
658 Elidable, Args, NumArgs,
659 HadMultipleCandidates, ZeroInitialization,
660 ConstructKind, ParenRange);
663 CXXConstructExpr::CXXConstructExpr(ASTContext &C, StmtClass SC, QualType T,
665 CXXConstructorDecl *D, bool elidable,
666 Expr **args, unsigned numargs,
667 bool HadMultipleCandidates,
668 bool ZeroInitialization,
669 ConstructionKind ConstructKind,
670 SourceRange ParenRange)
671 : Expr(SC, T, VK_RValue, OK_Ordinary,
672 T->isDependentType(), T->isDependentType(),
673 T->isInstantiationDependentType(),
674 T->containsUnexpandedParameterPack()),
675 Constructor(D), Loc(Loc), ParenRange(ParenRange), NumArgs(numargs),
676 Elidable(elidable), HadMultipleCandidates(HadMultipleCandidates),
677 ZeroInitialization(ZeroInitialization),
678 ConstructKind(ConstructKind), Args(0)
681 Args = new (C) Stmt*[NumArgs];
683 for (unsigned i = 0; i != NumArgs; ++i) {
684 assert(args[i] && "NULL argument in CXXConstructExpr");
686 if (args[i]->isValueDependent())
687 ExprBits.ValueDependent = true;
688 if (args[i]->isInstantiationDependent())
689 ExprBits.InstantiationDependent = true;
690 if (args[i]->containsUnexpandedParameterPack())
691 ExprBits.ContainsUnexpandedParameterPack = true;
698 ExprWithCleanups::ExprWithCleanups(ASTContext &C,
700 CXXTemporary **temps,
702 : Expr(ExprWithCleanupsClass, subexpr->getType(),
703 subexpr->getValueKind(), subexpr->getObjectKind(),
704 subexpr->isTypeDependent(), subexpr->isValueDependent(),
705 subexpr->isInstantiationDependent(),
706 subexpr->containsUnexpandedParameterPack()),
707 SubExpr(subexpr), Temps(0), NumTemps(0) {
709 setNumTemporaries(C, numtemps);
710 for (unsigned i = 0; i != numtemps; ++i)
715 void ExprWithCleanups::setNumTemporaries(ASTContext &C, unsigned N) {
716 assert(Temps == 0 && "Cannot resize with this");
718 Temps = new (C) CXXTemporary*[NumTemps];
722 ExprWithCleanups *ExprWithCleanups::Create(ASTContext &C,
724 CXXTemporary **Temps,
726 return new (C) ExprWithCleanups(C, SubExpr, Temps, NumTemps);
729 CXXUnresolvedConstructExpr::CXXUnresolvedConstructExpr(TypeSourceInfo *Type,
730 SourceLocation LParenLoc,
733 SourceLocation RParenLoc)
734 : Expr(CXXUnresolvedConstructExprClass,
735 Type->getType().getNonReferenceType(),
736 (Type->getType()->isLValueReferenceType() ? VK_LValue
737 :Type->getType()->isRValueReferenceType()? VK_XValue
740 Type->getType()->isDependentType(), true, true,
741 Type->getType()->containsUnexpandedParameterPack()),
743 LParenLoc(LParenLoc),
744 RParenLoc(RParenLoc),
746 Stmt **StoredArgs = reinterpret_cast<Stmt **>(this + 1);
747 for (unsigned I = 0; I != NumArgs; ++I) {
748 if (Args[I]->containsUnexpandedParameterPack())
749 ExprBits.ContainsUnexpandedParameterPack = true;
751 StoredArgs[I] = Args[I];
755 CXXUnresolvedConstructExpr *
756 CXXUnresolvedConstructExpr::Create(ASTContext &C,
757 TypeSourceInfo *Type,
758 SourceLocation LParenLoc,
761 SourceLocation RParenLoc) {
762 void *Mem = C.Allocate(sizeof(CXXUnresolvedConstructExpr) +
763 sizeof(Expr *) * NumArgs);
764 return new (Mem) CXXUnresolvedConstructExpr(Type, LParenLoc,
765 Args, NumArgs, RParenLoc);
768 CXXUnresolvedConstructExpr *
769 CXXUnresolvedConstructExpr::CreateEmpty(ASTContext &C, unsigned NumArgs) {
770 Stmt::EmptyShell Empty;
771 void *Mem = C.Allocate(sizeof(CXXUnresolvedConstructExpr) +
772 sizeof(Expr *) * NumArgs);
773 return new (Mem) CXXUnresolvedConstructExpr(Empty, NumArgs);
776 SourceRange CXXUnresolvedConstructExpr::getSourceRange() const {
777 return SourceRange(Type->getTypeLoc().getBeginLoc(), RParenLoc);
780 CXXDependentScopeMemberExpr::CXXDependentScopeMemberExpr(ASTContext &C,
781 Expr *Base, QualType BaseType,
783 SourceLocation OperatorLoc,
784 NestedNameSpecifierLoc QualifierLoc,
785 NamedDecl *FirstQualifierFoundInScope,
786 DeclarationNameInfo MemberNameInfo,
787 const TemplateArgumentListInfo *TemplateArgs)
788 : Expr(CXXDependentScopeMemberExprClass, C.DependentTy,
789 VK_LValue, OK_Ordinary, true, true, true,
790 ((Base && Base->containsUnexpandedParameterPack()) ||
792 QualifierLoc.getNestedNameSpecifier()
793 ->containsUnexpandedParameterPack()) ||
794 MemberNameInfo.containsUnexpandedParameterPack())),
795 Base(Base), BaseType(BaseType), IsArrow(IsArrow),
796 HasExplicitTemplateArgs(TemplateArgs != 0),
797 OperatorLoc(OperatorLoc), QualifierLoc(QualifierLoc),
798 FirstQualifierFoundInScope(FirstQualifierFoundInScope),
799 MemberNameInfo(MemberNameInfo) {
801 bool Dependent = true;
802 bool InstantiationDependent = true;
803 bool ContainsUnexpandedParameterPack = false;
804 getExplicitTemplateArgs().initializeFrom(*TemplateArgs, Dependent,
805 InstantiationDependent,
806 ContainsUnexpandedParameterPack);
807 if (ContainsUnexpandedParameterPack)
808 ExprBits.ContainsUnexpandedParameterPack = true;
812 CXXDependentScopeMemberExpr::CXXDependentScopeMemberExpr(ASTContext &C,
813 Expr *Base, QualType BaseType,
815 SourceLocation OperatorLoc,
816 NestedNameSpecifierLoc QualifierLoc,
817 NamedDecl *FirstQualifierFoundInScope,
818 DeclarationNameInfo MemberNameInfo)
819 : Expr(CXXDependentScopeMemberExprClass, C.DependentTy,
820 VK_LValue, OK_Ordinary, true, true, true,
821 ((Base && Base->containsUnexpandedParameterPack()) ||
823 QualifierLoc.getNestedNameSpecifier()->
824 containsUnexpandedParameterPack()) ||
825 MemberNameInfo.containsUnexpandedParameterPack())),
826 Base(Base), BaseType(BaseType), IsArrow(IsArrow),
827 HasExplicitTemplateArgs(false), OperatorLoc(OperatorLoc),
828 QualifierLoc(QualifierLoc),
829 FirstQualifierFoundInScope(FirstQualifierFoundInScope),
830 MemberNameInfo(MemberNameInfo) { }
832 CXXDependentScopeMemberExpr *
833 CXXDependentScopeMemberExpr::Create(ASTContext &C,
834 Expr *Base, QualType BaseType, bool IsArrow,
835 SourceLocation OperatorLoc,
836 NestedNameSpecifierLoc QualifierLoc,
837 NamedDecl *FirstQualifierFoundInScope,
838 DeclarationNameInfo MemberNameInfo,
839 const TemplateArgumentListInfo *TemplateArgs) {
841 return new (C) CXXDependentScopeMemberExpr(C, Base, BaseType,
842 IsArrow, OperatorLoc,
844 FirstQualifierFoundInScope,
847 std::size_t size = sizeof(CXXDependentScopeMemberExpr);
849 size += ASTTemplateArgumentListInfo::sizeFor(*TemplateArgs);
851 void *Mem = C.Allocate(size, llvm::alignOf<CXXDependentScopeMemberExpr>());
852 return new (Mem) CXXDependentScopeMemberExpr(C, Base, BaseType,
853 IsArrow, OperatorLoc,
855 FirstQualifierFoundInScope,
856 MemberNameInfo, TemplateArgs);
859 CXXDependentScopeMemberExpr *
860 CXXDependentScopeMemberExpr::CreateEmpty(ASTContext &C,
861 bool HasExplicitTemplateArgs,
862 unsigned NumTemplateArgs) {
863 if (!HasExplicitTemplateArgs)
864 return new (C) CXXDependentScopeMemberExpr(C, 0, QualType(),
866 NestedNameSpecifierLoc(), 0,
867 DeclarationNameInfo());
869 std::size_t size = sizeof(CXXDependentScopeMemberExpr) +
870 ASTTemplateArgumentListInfo::sizeFor(NumTemplateArgs);
871 void *Mem = C.Allocate(size, llvm::alignOf<CXXDependentScopeMemberExpr>());
872 CXXDependentScopeMemberExpr *E
873 = new (Mem) CXXDependentScopeMemberExpr(C, 0, QualType(),
875 NestedNameSpecifierLoc(), 0,
876 DeclarationNameInfo(), 0);
877 E->HasExplicitTemplateArgs = true;
881 bool CXXDependentScopeMemberExpr::isImplicitAccess() const {
885 return cast<Expr>(Base)->isImplicitCXXThis();
888 static bool hasOnlyNonStaticMemberFunctions(UnresolvedSetIterator begin,
889 UnresolvedSetIterator end) {
891 NamedDecl *decl = *begin;
892 if (isa<UnresolvedUsingValueDecl>(decl))
894 if (isa<UsingShadowDecl>(decl))
895 decl = cast<UsingShadowDecl>(decl)->getUnderlyingDecl();
897 // Unresolved member expressions should only contain methods and
899 assert(isa<CXXMethodDecl>(decl) || isa<FunctionTemplateDecl>(decl));
901 if (isa<FunctionTemplateDecl>(decl))
902 decl = cast<FunctionTemplateDecl>(decl)->getTemplatedDecl();
903 if (cast<CXXMethodDecl>(decl)->isStatic())
905 } while (++begin != end);
910 UnresolvedMemberExpr::UnresolvedMemberExpr(ASTContext &C,
911 bool HasUnresolvedUsing,
912 Expr *Base, QualType BaseType,
914 SourceLocation OperatorLoc,
915 NestedNameSpecifierLoc QualifierLoc,
916 const DeclarationNameInfo &MemberNameInfo,
917 const TemplateArgumentListInfo *TemplateArgs,
918 UnresolvedSetIterator Begin,
919 UnresolvedSetIterator End)
920 : OverloadExpr(UnresolvedMemberExprClass, C, QualifierLoc, MemberNameInfo,
921 TemplateArgs, Begin, End,
923 ((Base && Base->isTypeDependent()) ||
924 BaseType->isDependentType()),
925 ((Base && Base->isInstantiationDependent()) ||
926 BaseType->isInstantiationDependentType()),
927 // Contains unexpanded parameter pack
928 ((Base && Base->containsUnexpandedParameterPack()) ||
929 BaseType->containsUnexpandedParameterPack())),
930 IsArrow(IsArrow), HasUnresolvedUsing(HasUnresolvedUsing),
931 Base(Base), BaseType(BaseType), OperatorLoc(OperatorLoc) {
933 // Check whether all of the members are non-static member functions,
934 // and if so, mark give this bound-member type instead of overload type.
935 if (hasOnlyNonStaticMemberFunctions(Begin, End))
936 setType(C.BoundMemberTy);
939 bool UnresolvedMemberExpr::isImplicitAccess() const {
943 return cast<Expr>(Base)->isImplicitCXXThis();
946 UnresolvedMemberExpr *
947 UnresolvedMemberExpr::Create(ASTContext &C,
948 bool HasUnresolvedUsing,
949 Expr *Base, QualType BaseType, bool IsArrow,
950 SourceLocation OperatorLoc,
951 NestedNameSpecifierLoc QualifierLoc,
952 const DeclarationNameInfo &MemberNameInfo,
953 const TemplateArgumentListInfo *TemplateArgs,
954 UnresolvedSetIterator Begin,
955 UnresolvedSetIterator End) {
956 std::size_t size = sizeof(UnresolvedMemberExpr);
958 size += ASTTemplateArgumentListInfo::sizeFor(*TemplateArgs);
960 void *Mem = C.Allocate(size, llvm::alignOf<UnresolvedMemberExpr>());
961 return new (Mem) UnresolvedMemberExpr(C,
962 HasUnresolvedUsing, Base, BaseType,
963 IsArrow, OperatorLoc, QualifierLoc,
964 MemberNameInfo, TemplateArgs, Begin, End);
967 UnresolvedMemberExpr *
968 UnresolvedMemberExpr::CreateEmpty(ASTContext &C, bool HasExplicitTemplateArgs,
969 unsigned NumTemplateArgs) {
970 std::size_t size = sizeof(UnresolvedMemberExpr);
971 if (HasExplicitTemplateArgs)
972 size += ASTTemplateArgumentListInfo::sizeFor(NumTemplateArgs);
974 void *Mem = C.Allocate(size, llvm::alignOf<UnresolvedMemberExpr>());
975 UnresolvedMemberExpr *E = new (Mem) UnresolvedMemberExpr(EmptyShell());
976 E->HasExplicitTemplateArgs = HasExplicitTemplateArgs;
980 CXXRecordDecl *UnresolvedMemberExpr::getNamingClass() const {
981 // Unlike for UnresolvedLookupExpr, it is very easy to re-derive this.
983 // If there was a nested name specifier, it names the naming class.
984 // It can't be dependent: after all, we were actually able to do the
986 CXXRecordDecl *Record = 0;
987 if (getQualifier()) {
988 const Type *T = getQualifier()->getAsType();
989 assert(T && "qualifier in member expression does not name type");
990 Record = T->getAsCXXRecordDecl();
991 assert(Record && "qualifier in member expression does not name record");
993 // Otherwise the naming class must have been the base class.
995 QualType BaseType = getBaseType().getNonReferenceType();
997 const PointerType *PT = BaseType->getAs<PointerType>();
998 assert(PT && "base of arrow member access is not pointer");
999 BaseType = PT->getPointeeType();
1002 Record = BaseType->getAsCXXRecordDecl();
1003 assert(Record && "base of member expression does not name record");
1009 SubstNonTypeTemplateParmPackExpr::
1010 SubstNonTypeTemplateParmPackExpr(QualType T,
1011 NonTypeTemplateParmDecl *Param,
1012 SourceLocation NameLoc,
1013 const TemplateArgument &ArgPack)
1014 : Expr(SubstNonTypeTemplateParmPackExprClass, T, VK_RValue, OK_Ordinary,
1015 true, true, true, true),
1016 Param(Param), Arguments(ArgPack.pack_begin()),
1017 NumArguments(ArgPack.pack_size()), NameLoc(NameLoc) { }
1019 TemplateArgument SubstNonTypeTemplateParmPackExpr::getArgumentPack() const {
1020 return TemplateArgument(Arguments, NumArguments);