2007-08-25 04:21:10 +08:00
|
|
|
//===--- ExprCXX.cpp - (C++) Expression AST Node Implementation -----------===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
2007-12-30 03:59:25 +08:00
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
2007-08-25 04:21:10 +08:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// This file implements the subclesses of Expr class declared in ExprCXX.h
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2008-11-15 00:09:21 +08:00
|
|
|
#include "clang/Basic/IdentifierTable.h"
|
|
|
|
#include "clang/AST/DeclCXX.h"
|
2009-07-01 06:34:41 +08:00
|
|
|
#include "clang/AST/DeclTemplate.h"
|
2007-08-25 04:21:10 +08:00
|
|
|
#include "clang/AST/ExprCXX.h"
|
2010-02-25 07:40:28 +08:00
|
|
|
#include "clang/AST/TypeLoc.h"
|
2007-08-25 04:21:10 +08:00
|
|
|
using namespace clang;
|
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Child Iterators for iterating over subexpressions/substatements
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2008-11-11 19:37:55 +08:00
|
|
|
// CXXTypeidExpr - has child iterators if the operand is an expression
|
|
|
|
Stmt::child_iterator CXXTypeidExpr::child_begin() {
|
2008-12-04 07:17:54 +08:00
|
|
|
return isTypeOperand() ? child_iterator() : &Operand.Ex;
|
2008-11-11 19:37:55 +08:00
|
|
|
}
|
|
|
|
Stmt::child_iterator CXXTypeidExpr::child_end() {
|
2008-12-04 07:17:54 +08:00
|
|
|
return isTypeOperand() ? child_iterator() : &Operand.Ex+1;
|
2008-11-11 19:37:55 +08:00
|
|
|
}
|
2007-08-25 04:21:10 +08:00
|
|
|
|
|
|
|
// CXXBoolLiteralExpr
|
2009-09-09 23:08:12 +08:00
|
|
|
Stmt::child_iterator CXXBoolLiteralExpr::child_begin() {
|
2007-10-19 07:28:49 +08:00
|
|
|
return child_iterator();
|
|
|
|
}
|
|
|
|
Stmt::child_iterator CXXBoolLiteralExpr::child_end() {
|
|
|
|
return child_iterator();
|
|
|
|
}
|
2008-02-26 08:51:44 +08:00
|
|
|
|
2009-05-11 02:38:11 +08:00
|
|
|
// CXXNullPtrLiteralExpr
|
2009-09-09 23:08:12 +08:00
|
|
|
Stmt::child_iterator CXXNullPtrLiteralExpr::child_begin() {
|
2009-05-11 02:38:11 +08:00
|
|
|
return child_iterator();
|
|
|
|
}
|
|
|
|
Stmt::child_iterator CXXNullPtrLiteralExpr::child_end() {
|
|
|
|
return child_iterator();
|
|
|
|
}
|
|
|
|
|
2008-11-04 22:32:21 +08:00
|
|
|
// CXXThisExpr
|
|
|
|
Stmt::child_iterator CXXThisExpr::child_begin() { return child_iterator(); }
|
|
|
|
Stmt::child_iterator CXXThisExpr::child_end() { return child_iterator(); }
|
|
|
|
|
2008-02-26 08:51:44 +08:00
|
|
|
// CXXThrowExpr
|
2008-06-17 11:11:08 +08:00
|
|
|
Stmt::child_iterator CXXThrowExpr::child_begin() { return &Op; }
|
2008-02-26 08:51:44 +08:00
|
|
|
Stmt::child_iterator CXXThrowExpr::child_end() {
|
|
|
|
// If Op is 0, we are processing throw; which has no children.
|
2008-06-17 11:11:08 +08:00
|
|
|
return Op ? &Op+1 : &Op;
|
2008-02-26 08:51:44 +08:00
|
|
|
}
|
2008-04-08 12:40:51 +08:00
|
|
|
|
|
|
|
// CXXDefaultArgExpr
|
|
|
|
Stmt::child_iterator CXXDefaultArgExpr::child_begin() {
|
2008-04-10 10:22:51 +08:00
|
|
|
return child_iterator();
|
2008-04-08 12:40:51 +08:00
|
|
|
}
|
|
|
|
Stmt::child_iterator CXXDefaultArgExpr::child_end() {
|
2008-04-10 10:22:51 +08:00
|
|
|
return child_iterator();
|
2008-04-08 12:40:51 +08:00
|
|
|
}
|
2008-08-22 23:38:55 +08:00
|
|
|
|
|
|
|
// CXXZeroInitValueExpr
|
2009-09-09 23:08:12 +08:00
|
|
|
Stmt::child_iterator CXXZeroInitValueExpr::child_begin() {
|
2008-08-22 23:38:55 +08:00
|
|
|
return child_iterator();
|
|
|
|
}
|
|
|
|
Stmt::child_iterator CXXZeroInitValueExpr::child_end() {
|
|
|
|
return child_iterator();
|
|
|
|
}
|
2008-09-10 07:47:53 +08:00
|
|
|
|
2008-11-22 03:14:01 +08:00
|
|
|
// CXXNewExpr
|
2010-02-12 06:51:03 +08:00
|
|
|
CXXNewExpr::CXXNewExpr(ASTContext &C, bool globalNew, FunctionDecl *operatorNew,
|
2008-11-22 03:14:01 +08:00
|
|
|
Expr **placementArgs, unsigned numPlaceArgs,
|
2008-12-02 22:43:59 +08:00
|
|
|
bool parenTypeId, Expr *arraySize,
|
2008-11-22 03:14:01 +08:00
|
|
|
CXXConstructorDecl *constructor, bool initializer,
|
|
|
|
Expr **constructorArgs, unsigned numConsArgs,
|
|
|
|
FunctionDecl *operatorDelete, QualType ty,
|
|
|
|
SourceLocation startLoc, SourceLocation endLoc)
|
2009-02-26 22:39:58 +08:00
|
|
|
: Expr(CXXNewExprClass, ty, ty->isDependentType(), ty->isDependentType()),
|
|
|
|
GlobalNew(globalNew), ParenTypeId(parenTypeId),
|
2008-12-02 22:43:59 +08:00
|
|
|
Initializer(initializer), Array(arraySize), NumPlacementArgs(numPlaceArgs),
|
2008-11-22 03:14:01 +08:00
|
|
|
NumConstructorArgs(numConsArgs), OperatorNew(operatorNew),
|
2008-12-02 22:43:59 +08:00
|
|
|
OperatorDelete(operatorDelete), Constructor(constructor),
|
2009-09-09 23:08:12 +08:00
|
|
|
StartLoc(startLoc), EndLoc(endLoc) {
|
2008-12-02 22:43:59 +08:00
|
|
|
unsigned TotalSize = Array + NumPlacementArgs + NumConstructorArgs;
|
2010-02-12 06:51:03 +08:00
|
|
|
SubExprs = new (C) Stmt*[TotalSize];
|
2008-11-22 03:14:01 +08:00
|
|
|
unsigned i = 0;
|
2008-12-02 22:43:59 +08:00
|
|
|
if (Array)
|
|
|
|
SubExprs[i++] = arraySize;
|
|
|
|
for (unsigned j = 0; j < NumPlacementArgs; ++j)
|
2008-11-22 03:14:01 +08:00
|
|
|
SubExprs[i++] = placementArgs[j];
|
2008-12-02 22:43:59 +08:00
|
|
|
for (unsigned j = 0; j < NumConstructorArgs; ++j)
|
2008-11-22 03:14:01 +08:00
|
|
|
SubExprs[i++] = constructorArgs[j];
|
|
|
|
assert(i == TotalSize);
|
|
|
|
}
|
|
|
|
|
2010-02-12 06:51:03 +08:00
|
|
|
void CXXNewExpr::DoDestroy(ASTContext &C) {
|
|
|
|
DestroyChildren(C);
|
|
|
|
if (SubExprs)
|
|
|
|
C.Deallocate(SubExprs);
|
|
|
|
this->~CXXNewExpr();
|
|
|
|
C.Deallocate((void*)this);
|
|
|
|
}
|
|
|
|
|
2008-11-22 03:14:01 +08:00
|
|
|
Stmt::child_iterator CXXNewExpr::child_begin() { return &SubExprs[0]; }
|
|
|
|
Stmt::child_iterator CXXNewExpr::child_end() {
|
2008-12-02 22:43:59 +08:00
|
|
|
return &SubExprs[0] + Array + getNumPlacementArgs() + getNumConstructorArgs();
|
2008-11-22 03:14:01 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// CXXDeleteExpr
|
|
|
|
Stmt::child_iterator CXXDeleteExpr::child_begin() { return &Argument; }
|
|
|
|
Stmt::child_iterator CXXDeleteExpr::child_end() { return &Argument+1; }
|
|
|
|
|
2009-09-05 01:36:40 +08:00
|
|
|
// CXXPseudoDestructorExpr
|
|
|
|
Stmt::child_iterator CXXPseudoDestructorExpr::child_begin() { return &Base; }
|
|
|
|
Stmt::child_iterator CXXPseudoDestructorExpr::child_end() {
|
|
|
|
return &Base + 1;
|
|
|
|
}
|
|
|
|
|
2010-02-25 09:56:36 +08:00
|
|
|
PseudoDestructorTypeStorage::PseudoDestructorTypeStorage(TypeSourceInfo *Info)
|
|
|
|
: Type(Info)
|
|
|
|
{
|
|
|
|
Location = Info->getTypeLoc().getSourceRange().getBegin();
|
|
|
|
}
|
|
|
|
|
|
|
|
QualType CXXPseudoDestructorExpr::getDestroyedType() const {
|
|
|
|
if (TypeSourceInfo *TInfo = DestroyedType.getTypeSourceInfo())
|
|
|
|
return TInfo->getType();
|
|
|
|
|
|
|
|
return QualType();
|
|
|
|
}
|
|
|
|
|
2010-02-25 07:40:28 +08:00
|
|
|
SourceRange CXXPseudoDestructorExpr::getSourceRange() const {
|
2010-02-25 09:56:36 +08:00
|
|
|
SourceLocation End = DestroyedType.getLocation();
|
|
|
|
if (TypeSourceInfo *TInfo = DestroyedType.getTypeSourceInfo())
|
|
|
|
End = TInfo->getTypeLoc().getSourceRange().getEnd();
|
|
|
|
return SourceRange(Base->getLocStart(), End);
|
2010-02-25 07:40:28 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-11-21 16:51:07 +08:00
|
|
|
// UnresolvedLookupExpr
|
2009-11-25 03:00:30 +08:00
|
|
|
UnresolvedLookupExpr *
|
|
|
|
UnresolvedLookupExpr::Create(ASTContext &C, bool Dependent,
|
2010-01-27 09:50:18 +08:00
|
|
|
CXXRecordDecl *NamingClass,
|
2009-11-25 03:00:30 +08:00
|
|
|
NestedNameSpecifier *Qualifier,
|
|
|
|
SourceRange QualifierRange, DeclarationName Name,
|
|
|
|
SourceLocation NameLoc, bool ADL,
|
|
|
|
const TemplateArgumentListInfo &Args)
|
|
|
|
{
|
|
|
|
void *Mem = C.Allocate(sizeof(UnresolvedLookupExpr) +
|
|
|
|
ExplicitTemplateArgumentList::sizeFor(Args));
|
|
|
|
UnresolvedLookupExpr *ULE
|
|
|
|
= new (Mem) UnresolvedLookupExpr(Dependent ? C.DependentTy : C.OverloadTy,
|
2010-01-27 09:50:18 +08:00
|
|
|
Dependent, NamingClass,
|
|
|
|
Qualifier, QualifierRange,
|
2009-11-25 03:00:30 +08:00
|
|
|
Name, NameLoc, ADL,
|
|
|
|
/*Overload*/ true,
|
|
|
|
/*ExplicitTemplateArgs*/ true);
|
|
|
|
|
|
|
|
reinterpret_cast<ExplicitTemplateArgumentList*>(ULE+1)->initializeFrom(Args);
|
|
|
|
|
|
|
|
return ULE;
|
|
|
|
}
|
|
|
|
|
2010-02-02 14:20:04 +08:00
|
|
|
bool OverloadExpr::ComputeDependence(UnresolvedSetIterator Begin,
|
|
|
|
UnresolvedSetIterator End,
|
|
|
|
const TemplateArgumentListInfo *Args) {
|
2010-01-20 08:46:10 +08:00
|
|
|
for (UnresolvedSetImpl::const_iterator I = Begin; I != End; ++I)
|
2009-11-25 03:00:30 +08:00
|
|
|
if ((*I)->getDeclContext()->isDependentContext())
|
|
|
|
return true;
|
|
|
|
|
|
|
|
if (Args && TemplateSpecializationType::anyDependentTemplateArguments(*Args))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2009-11-21 16:51:07 +08:00
|
|
|
Stmt::child_iterator UnresolvedLookupExpr::child_begin() {
|
2009-09-09 23:08:12 +08:00
|
|
|
return child_iterator();
|
2008-12-06 08:22:45 +08:00
|
|
|
}
|
2009-11-21 16:51:07 +08:00
|
|
|
Stmt::child_iterator UnresolvedLookupExpr::child_end() {
|
2008-12-06 08:22:45 +08:00
|
|
|
return child_iterator();
|
|
|
|
}
|
2009-01-06 04:52:13 +08:00
|
|
|
// UnaryTypeTraitExpr
|
|
|
|
Stmt::child_iterator UnaryTypeTraitExpr::child_begin() {
|
|
|
|
return child_iterator();
|
|
|
|
}
|
|
|
|
Stmt::child_iterator UnaryTypeTraitExpr::child_end() {
|
|
|
|
return child_iterator();
|
|
|
|
}
|
|
|
|
|
2009-11-20 06:55:06 +08:00
|
|
|
// DependentScopeDeclRefExpr
|
2009-11-25 03:00:30 +08:00
|
|
|
DependentScopeDeclRefExpr *
|
|
|
|
DependentScopeDeclRefExpr::Create(ASTContext &C,
|
|
|
|
NestedNameSpecifier *Qualifier,
|
|
|
|
SourceRange QualifierRange,
|
|
|
|
DeclarationName Name,
|
|
|
|
SourceLocation NameLoc,
|
|
|
|
const TemplateArgumentListInfo *Args) {
|
|
|
|
std::size_t size = sizeof(DependentScopeDeclRefExpr);
|
|
|
|
if (Args) size += ExplicitTemplateArgumentList::sizeFor(*Args);
|
|
|
|
void *Mem = C.Allocate(size);
|
|
|
|
|
|
|
|
DependentScopeDeclRefExpr *DRE
|
|
|
|
= new (Mem) DependentScopeDeclRefExpr(C.DependentTy,
|
|
|
|
Qualifier, QualifierRange,
|
|
|
|
Name, NameLoc,
|
|
|
|
Args != 0);
|
|
|
|
|
|
|
|
if (Args)
|
|
|
|
reinterpret_cast<ExplicitTemplateArgumentList*>(DRE+1)
|
|
|
|
->initializeFrom(*Args);
|
|
|
|
|
|
|
|
return DRE;
|
|
|
|
}
|
|
|
|
|
2009-11-20 06:55:06 +08:00
|
|
|
StmtIterator DependentScopeDeclRefExpr::child_begin() {
|
Introduce a new expression type, UnresolvedDeclRefExpr, that describes
dependent qualified-ids such as
Fibonacci<N - 1>::value
where N is a template parameter. These references are "unresolved"
because the name is dependent and, therefore, cannot be resolved to a
declaration node (as we would do for a DeclRefExpr or
QualifiedDeclRefExpr). UnresolvedDeclRefExprs instantiate to
DeclRefExprs, QualifiedDeclRefExprs, etc.
Also, be a bit more careful about keeping only a single set of
specializations for a class template, and instantiating from the
definition of that template rather than a previous declaration. In
general, we need a better solution for this for all TagDecls, because
it's too easy to accidentally look at a declaration that isn't the
definition.
We can now process a simple Fibonacci computation described as a
template metaprogram.
llvm-svn: 67308
2009-03-20 01:26:29 +08:00
|
|
|
return child_iterator();
|
|
|
|
}
|
|
|
|
|
2009-11-20 06:55:06 +08:00
|
|
|
StmtIterator DependentScopeDeclRefExpr::child_end() {
|
Introduce a new expression type, UnresolvedDeclRefExpr, that describes
dependent qualified-ids such as
Fibonacci<N - 1>::value
where N is a template parameter. These references are "unresolved"
because the name is dependent and, therefore, cannot be resolved to a
declaration node (as we would do for a DeclRefExpr or
QualifiedDeclRefExpr). UnresolvedDeclRefExprs instantiate to
DeclRefExprs, QualifiedDeclRefExprs, etc.
Also, be a bit more careful about keeping only a single set of
specializations for a class template, and instantiating from the
definition of that template rather than a previous declaration. In
general, we need a better solution for this for all TagDecls, because
it's too easy to accidentally look at a declaration that isn't the
definition.
We can now process a simple Fibonacci computation described as a
template metaprogram.
llvm-svn: 67308
2009-03-20 01:26:29 +08:00
|
|
|
return child_iterator();
|
2009-07-01 06:34:41 +08:00
|
|
|
}
|
|
|
|
|
2009-07-24 07:49:00 +08:00
|
|
|
bool UnaryTypeTraitExpr::EvaluateTrait(ASTContext& C) const {
|
2009-01-06 04:52:13 +08:00
|
|
|
switch(UTT) {
|
|
|
|
default: assert(false && "Unknown type trait or not implemented");
|
|
|
|
case UTT_IsPOD: return QueriedType->isPODType();
|
2009-12-03 08:13:20 +08:00
|
|
|
case UTT_IsLiteral: return QueriedType->isLiteralType();
|
2009-01-06 04:52:13 +08:00
|
|
|
case UTT_IsClass: // Fallthrough
|
|
|
|
case UTT_IsUnion:
|
2009-07-30 05:53:49 +08:00
|
|
|
if (const RecordType *Record = QueriedType->getAs<RecordType>()) {
|
2009-01-06 04:52:13 +08:00
|
|
|
bool Union = Record->getDecl()->isUnion();
|
|
|
|
return UTT == UTT_IsUnion ? Union : !Union;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
case UTT_IsEnum: return QueriedType->isEnumeralType();
|
|
|
|
case UTT_IsPolymorphic:
|
2009-07-30 05:53:49 +08:00
|
|
|
if (const RecordType *Record = QueriedType->getAs<RecordType>()) {
|
2009-01-06 04:52:13 +08:00
|
|
|
// Type traits are only parsed in C++, so we've got CXXRecords.
|
|
|
|
return cast<CXXRecordDecl>(Record->getDecl())->isPolymorphic();
|
|
|
|
}
|
|
|
|
return false;
|
2009-03-22 09:52:17 +08:00
|
|
|
case UTT_IsAbstract:
|
2009-07-30 05:53:49 +08:00
|
|
|
if (const RecordType *RT = QueriedType->getAs<RecordType>())
|
2009-03-22 09:52:17 +08:00
|
|
|
return cast<CXXRecordDecl>(RT->getDecl())->isAbstract();
|
|
|
|
return false;
|
2009-08-16 05:55:26 +08:00
|
|
|
case UTT_IsEmpty:
|
|
|
|
if (const RecordType *Record = QueriedType->getAs<RecordType>()) {
|
|
|
|
return !Record->getDecl()->isUnion()
|
|
|
|
&& cast<CXXRecordDecl>(Record->getDecl())->isEmpty();
|
|
|
|
}
|
|
|
|
return false;
|
2009-04-16 08:08:20 +08:00
|
|
|
case UTT_HasTrivialConstructor:
|
2009-07-24 07:49:00 +08:00
|
|
|
// http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html:
|
|
|
|
// If __is_pod (type) is true then the trait is true, else if type is
|
|
|
|
// a cv class or union type (or array thereof) with a trivial default
|
|
|
|
// constructor ([class.ctor]) then the trait is true, else it is false.
|
|
|
|
if (QueriedType->isPODType())
|
|
|
|
return true;
|
|
|
|
if (const RecordType *RT =
|
2009-07-30 05:53:49 +08:00
|
|
|
C.getBaseElementType(QueriedType)->getAs<RecordType>())
|
2009-04-16 08:08:20 +08:00
|
|
|
return cast<CXXRecordDecl>(RT->getDecl())->hasTrivialConstructor();
|
2009-04-17 10:34:54 +08:00
|
|
|
return false;
|
2009-07-24 07:49:00 +08:00
|
|
|
case UTT_HasTrivialCopy:
|
|
|
|
// http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html:
|
|
|
|
// If __is_pod (type) is true or type is a reference type then
|
|
|
|
// the trait is true, else if type is a cv class or union type
|
|
|
|
// with a trivial copy constructor ([class.copy]) then the trait
|
|
|
|
// is true, else it is false.
|
|
|
|
if (QueriedType->isPODType() || QueriedType->isReferenceType())
|
|
|
|
return true;
|
2009-07-30 05:53:49 +08:00
|
|
|
if (const RecordType *RT = QueriedType->getAs<RecordType>())
|
2009-07-24 07:49:00 +08:00
|
|
|
return cast<CXXRecordDecl>(RT->getDecl())->hasTrivialCopyConstructor();
|
|
|
|
return false;
|
|
|
|
case UTT_HasTrivialAssign:
|
|
|
|
// http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html:
|
|
|
|
// If type is const qualified or is a reference type then the
|
|
|
|
// trait is false. Otherwise if __is_pod (type) is true then the
|
|
|
|
// trait is true, else if type is a cv class or union type with
|
|
|
|
// a trivial copy assignment ([class.copy]) then the trait is
|
|
|
|
// true, else it is false.
|
|
|
|
// Note: the const and reference restrictions are interesting,
|
|
|
|
// given that const and reference members don't prevent a class
|
|
|
|
// from having a trivial copy assignment operator (but do cause
|
|
|
|
// errors if the copy assignment operator is actually used, q.v.
|
|
|
|
// [class.copy]p12).
|
|
|
|
|
|
|
|
if (C.getBaseElementType(QueriedType).isConstQualified())
|
|
|
|
return false;
|
|
|
|
if (QueriedType->isPODType())
|
|
|
|
return true;
|
2009-07-30 05:53:49 +08:00
|
|
|
if (const RecordType *RT = QueriedType->getAs<RecordType>())
|
2009-07-24 07:49:00 +08:00
|
|
|
return cast<CXXRecordDecl>(RT->getDecl())->hasTrivialCopyAssignment();
|
|
|
|
return false;
|
|
|
|
case UTT_HasTrivialDestructor:
|
|
|
|
// http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html:
|
|
|
|
// If __is_pod (type) is true or type is a reference type
|
|
|
|
// then the trait is true, else if type is a cv class or union
|
|
|
|
// type (or array thereof) with a trivial destructor
|
|
|
|
// ([class.dtor]) then the trait is true, else it is
|
|
|
|
// false.
|
|
|
|
if (QueriedType->isPODType() || QueriedType->isReferenceType())
|
|
|
|
return true;
|
|
|
|
if (const RecordType *RT =
|
2009-07-30 05:53:49 +08:00
|
|
|
C.getBaseElementType(QueriedType)->getAs<RecordType>())
|
2009-04-17 10:34:54 +08:00
|
|
|
return cast<CXXRecordDecl>(RT->getDecl())->hasTrivialDestructor();
|
|
|
|
return false;
|
2009-01-06 04:52:13 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-12-23 12:00:48 +08:00
|
|
|
SourceRange CXXConstructExpr::getSourceRange() const {
|
|
|
|
// FIXME: Should we know where the parentheses are, if there are any?
|
|
|
|
for (std::reverse_iterator<Stmt**> I(&Args[NumArgs]), E(&Args[0]); I!=E;++I) {
|
|
|
|
// Ignore CXXDefaultExprs when computing the range, as they don't
|
|
|
|
// have a range.
|
|
|
|
if (!isa<CXXDefaultArgExpr>(*I))
|
|
|
|
return SourceRange(Loc, (*I)->getLocEnd());
|
|
|
|
}
|
|
|
|
|
|
|
|
return SourceRange(Loc);
|
|
|
|
}
|
|
|
|
|
2008-11-15 00:09:21 +08:00
|
|
|
SourceRange CXXOperatorCallExpr::getSourceRange() const {
|
|
|
|
OverloadedOperatorKind Kind = getOperator();
|
|
|
|
if (Kind == OO_PlusPlus || Kind == OO_MinusMinus) {
|
|
|
|
if (getNumArgs() == 1)
|
|
|
|
// Prefix operator
|
2009-09-09 23:08:12 +08:00
|
|
|
return SourceRange(getOperatorLoc(),
|
2008-11-15 00:09:21 +08:00
|
|
|
getArg(0)->getSourceRange().getEnd());
|
|
|
|
else
|
|
|
|
// Postfix operator
|
|
|
|
return SourceRange(getArg(0)->getSourceRange().getEnd(),
|
|
|
|
getOperatorLoc());
|
|
|
|
} else if (Kind == OO_Call) {
|
|
|
|
return SourceRange(getArg(0)->getSourceRange().getBegin(), getRParenLoc());
|
|
|
|
} else if (Kind == OO_Subscript) {
|
|
|
|
return SourceRange(getArg(0)->getSourceRange().getBegin(), getRParenLoc());
|
|
|
|
} else if (getNumArgs() == 1) {
|
|
|
|
return SourceRange(getOperatorLoc(), getArg(0)->getSourceRange().getEnd());
|
|
|
|
} else if (getNumArgs() == 2) {
|
|
|
|
return SourceRange(getArg(0)->getSourceRange().getBegin(),
|
|
|
|
getArg(1)->getSourceRange().getEnd());
|
|
|
|
} else {
|
|
|
|
return SourceRange();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-12-22 13:46:06 +08:00
|
|
|
Expr *CXXMemberCallExpr::getImplicitObjectArgument() {
|
|
|
|
if (MemberExpr *MemExpr = dyn_cast<MemberExpr>(getCallee()->IgnoreParens()))
|
|
|
|
return MemExpr->getBase();
|
|
|
|
|
|
|
|
// FIXME: Will eventually need to cope with member pointers.
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-11-12 23:31:47 +08:00
|
|
|
SourceRange CXXMemberCallExpr::getSourceRange() const {
|
|
|
|
SourceLocation LocStart = getCallee()->getLocStart();
|
|
|
|
if (LocStart.isInvalid() && getNumArgs() > 0)
|
|
|
|
LocStart = getArg(0)->getLocStart();
|
|
|
|
return SourceRange(LocStart, getRParenLoc());
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-10-28 03:41:14 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Named casts
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
/// getCastName - Get the name of the C++ cast being used, e.g.,
|
|
|
|
/// "static_cast", "dynamic_cast", "reinterpret_cast", or
|
|
|
|
/// "const_cast". The returned pointer must not be freed.
|
|
|
|
const char *CXXNamedCastExpr::getCastName() const {
|
|
|
|
switch (getStmtClass()) {
|
|
|
|
case CXXStaticCastExprClass: return "static_cast";
|
|
|
|
case CXXDynamicCastExprClass: return "dynamic_cast";
|
|
|
|
case CXXReinterpretCastExprClass: return "reinterpret_cast";
|
|
|
|
case CXXConstCastExprClass: return "const_cast";
|
|
|
|
default: return "<invalid cast>";
|
|
|
|
}
|
|
|
|
}
|
2009-01-17 02:33:17 +08:00
|
|
|
|
2009-12-24 02:19:08 +08:00
|
|
|
CXXDefaultArgExpr *
|
2009-12-24 07:03:06 +08:00
|
|
|
CXXDefaultArgExpr::Create(ASTContext &C, SourceLocation Loc,
|
|
|
|
ParmVarDecl *Param, Expr *SubExpr) {
|
2009-12-24 02:19:08 +08:00
|
|
|
void *Mem = C.Allocate(sizeof(CXXDefaultArgExpr) + sizeof(Stmt *));
|
2009-12-24 07:03:06 +08:00
|
|
|
return new (Mem) CXXDefaultArgExpr(CXXDefaultArgExprClass, Loc, Param,
|
|
|
|
SubExpr);
|
2009-12-24 02:19:08 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void CXXDefaultArgExpr::DoDestroy(ASTContext &C) {
|
|
|
|
if (Param.getInt())
|
|
|
|
getExpr()->Destroy(C);
|
|
|
|
this->~CXXDefaultArgExpr();
|
|
|
|
C.Deallocate(this);
|
|
|
|
}
|
|
|
|
|
2009-09-09 23:08:12 +08:00
|
|
|
CXXTemporary *CXXTemporary::Create(ASTContext &C,
|
2009-05-31 04:34:37 +08:00
|
|
|
const CXXDestructorDecl *Destructor) {
|
2009-05-31 06:38:53 +08:00
|
|
|
return new (C) CXXTemporary(Destructor);
|
|
|
|
}
|
|
|
|
|
2009-08-07 14:08:38 +08:00
|
|
|
void CXXTemporary::Destroy(ASTContext &Ctx) {
|
2009-05-31 06:38:53 +08:00
|
|
|
this->~CXXTemporary();
|
2009-08-07 14:08:38 +08:00
|
|
|
Ctx.Deallocate(this);
|
2009-05-31 03:54:15 +08:00
|
|
|
}
|
|
|
|
|
2009-09-09 23:08:12 +08:00
|
|
|
CXXBindTemporaryExpr *CXXBindTemporaryExpr::Create(ASTContext &C,
|
2009-05-31 04:03:25 +08:00
|
|
|
CXXTemporary *Temp,
|
|
|
|
Expr* SubExpr) {
|
2009-09-09 23:08:12 +08:00
|
|
|
assert(SubExpr->getType()->isRecordType() &&
|
2009-05-31 04:03:25 +08:00
|
|
|
"Expression bound to a temporary must have record type!");
|
|
|
|
|
2009-05-31 04:34:37 +08:00
|
|
|
return new (C) CXXBindTemporaryExpr(Temp, SubExpr);
|
2009-05-31 04:03:25 +08:00
|
|
|
}
|
|
|
|
|
2009-08-07 14:08:38 +08:00
|
|
|
void CXXBindTemporaryExpr::DoDestroy(ASTContext &C) {
|
2009-05-31 06:38:53 +08:00
|
|
|
Temp->Destroy(C);
|
|
|
|
this->~CXXBindTemporaryExpr();
|
|
|
|
C.Deallocate(this);
|
|
|
|
}
|
|
|
|
|
2010-01-29 10:39:32 +08:00
|
|
|
CXXBindReferenceExpr *CXXBindReferenceExpr::Create(ASTContext &C, Expr *SubExpr,
|
|
|
|
bool ExtendsLifetime,
|
|
|
|
bool RequiresTemporaryCopy) {
|
|
|
|
return new (C) CXXBindReferenceExpr(SubExpr,
|
|
|
|
ExtendsLifetime,
|
|
|
|
RequiresTemporaryCopy);
|
|
|
|
}
|
|
|
|
|
|
|
|
void CXXBindReferenceExpr::DoDestroy(ASTContext &C) {
|
|
|
|
this->~CXXBindReferenceExpr();
|
|
|
|
C.Deallocate(this);
|
|
|
|
}
|
|
|
|
|
2009-05-31 04:56:46 +08:00
|
|
|
CXXTemporaryObjectExpr::CXXTemporaryObjectExpr(ASTContext &C,
|
2009-04-24 13:23:13 +08:00
|
|
|
CXXConstructorDecl *Cons,
|
2009-01-17 02:33:17 +08:00
|
|
|
QualType writtenTy,
|
2009-09-09 23:08:12 +08:00
|
|
|
SourceLocation tyBeginLoc,
|
2009-01-17 02:33:17 +08:00
|
|
|
Expr **Args,
|
2009-09-09 23:08:12 +08:00
|
|
|
unsigned NumArgs,
|
2009-01-17 02:33:17 +08:00
|
|
|
SourceLocation rParenLoc)
|
2009-12-16 09:38:02 +08:00
|
|
|
: CXXConstructExpr(C, CXXTemporaryObjectExprClass, writtenTy, tyBeginLoc,
|
|
|
|
Cons, false, Args, NumArgs),
|
2009-04-25 01:34:38 +08:00
|
|
|
TyBeginLoc(tyBeginLoc), RParenLoc(rParenLoc) {
|
2009-01-17 02:33:17 +08:00
|
|
|
}
|
2009-04-21 10:22:11 +08:00
|
|
|
|
2009-09-09 23:08:12 +08:00
|
|
|
CXXConstructExpr *CXXConstructExpr::Create(ASTContext &C, QualType T,
|
2009-12-16 09:38:02 +08:00
|
|
|
SourceLocation Loc,
|
2009-05-31 04:56:46 +08:00
|
|
|
CXXConstructorDecl *D, bool Elidable,
|
2009-12-17 02:50:27 +08:00
|
|
|
Expr **Args, unsigned NumArgs,
|
Rework base and member initialization in constructors, with several
(necessarily simultaneous) changes:
- CXXBaseOrMemberInitializer now contains only a single initializer
rather than a set of initialiation arguments + a constructor. The
single initializer covers all aspects of initialization, including
constructor calls as necessary but also cleanup of temporaries
created by the initializer (which we never handled
before!).
- Rework + simplify code generation for CXXBaseOrMemberInitializers,
since we can now just emit the initializer as an initializer.
- Switched base and member initialization over to the new
initialization code (InitializationSequence), so that it
- Improved diagnostics for the new initialization code when
initializing bases and members, to match the diagnostics produced
by the previous (special-purpose) code.
- Simplify the representation of type-checked constructor initializers in
templates; instead of keeping the fully-type-checked AST, which is
rather hard to undo at template instantiation time, throw away the
type-checked AST and store the raw expressions in the AST. This
simplifies instantiation, but loses a little but of information in
the AST.
- When type-checking implicit base or member initializers within a
dependent context, don't add the generated initializers into the
AST, because they'll look like they were explicit.
- Record in CXXConstructExpr when the constructor call is to
initialize a base class, so that CodeGen does not have to infer it
from context. This ensures that we call the right kind of
constructor.
There are also a few "opportunity" fixes here that were needed to not
regress, for example:
- Diagnose default-initialization of a const-qualified class that
does not have a user-declared default constructor. We had this
diagnostic specifically for bases and members, but missed it for
variables. That's fixed now.
- When defining the implicit constructors, destructor, and
copy-assignment operator, set the CurContext to that constructor
when we're defining the body.
llvm-svn: 94952
2010-01-31 17:12:51 +08:00
|
|
|
bool ZeroInitialization,
|
|
|
|
bool BaseInitialization) {
|
2009-12-16 09:38:02 +08:00
|
|
|
return new (C) CXXConstructExpr(C, CXXConstructExprClass, T, Loc, D,
|
Rework base and member initialization in constructors, with several
(necessarily simultaneous) changes:
- CXXBaseOrMemberInitializer now contains only a single initializer
rather than a set of initialiation arguments + a constructor. The
single initializer covers all aspects of initialization, including
constructor calls as necessary but also cleanup of temporaries
created by the initializer (which we never handled
before!).
- Rework + simplify code generation for CXXBaseOrMemberInitializers,
since we can now just emit the initializer as an initializer.
- Switched base and member initialization over to the new
initialization code (InitializationSequence), so that it
- Improved diagnostics for the new initialization code when
initializing bases and members, to match the diagnostics produced
by the previous (special-purpose) code.
- Simplify the representation of type-checked constructor initializers in
templates; instead of keeping the fully-type-checked AST, which is
rather hard to undo at template instantiation time, throw away the
type-checked AST and store the raw expressions in the AST. This
simplifies instantiation, but loses a little but of information in
the AST.
- When type-checking implicit base or member initializers within a
dependent context, don't add the generated initializers into the
AST, because they'll look like they were explicit.
- Record in CXXConstructExpr when the constructor call is to
initialize a base class, so that CodeGen does not have to infer it
from context. This ensures that we call the right kind of
constructor.
There are also a few "opportunity" fixes here that were needed to not
regress, for example:
- Diagnose default-initialization of a const-qualified class that
does not have a user-declared default constructor. We had this
diagnostic specifically for bases and members, but missed it for
variables. That's fixed now.
- When defining the implicit constructors, destructor, and
copy-assignment operator, set the CurContext to that constructor
when we're defining the body.
llvm-svn: 94952
2010-01-31 17:12:51 +08:00
|
|
|
Elidable, Args, NumArgs, ZeroInitialization,
|
|
|
|
BaseInitialization);
|
2009-04-23 10:32:43 +08:00
|
|
|
}
|
|
|
|
|
2009-09-09 23:08:12 +08:00
|
|
|
CXXConstructExpr::CXXConstructExpr(ASTContext &C, StmtClass SC, QualType T,
|
2009-12-16 09:38:02 +08:00
|
|
|
SourceLocation Loc,
|
2009-05-31 04:56:46 +08:00
|
|
|
CXXConstructorDecl *D, bool elidable,
|
2009-12-17 02:50:27 +08:00
|
|
|
Expr **args, unsigned numargs,
|
Rework base and member initialization in constructors, with several
(necessarily simultaneous) changes:
- CXXBaseOrMemberInitializer now contains only a single initializer
rather than a set of initialiation arguments + a constructor. The
single initializer covers all aspects of initialization, including
constructor calls as necessary but also cleanup of temporaries
created by the initializer (which we never handled
before!).
- Rework + simplify code generation for CXXBaseOrMemberInitializers,
since we can now just emit the initializer as an initializer.
- Switched base and member initialization over to the new
initialization code (InitializationSequence), so that it
- Improved diagnostics for the new initialization code when
initializing bases and members, to match the diagnostics produced
by the previous (special-purpose) code.
- Simplify the representation of type-checked constructor initializers in
templates; instead of keeping the fully-type-checked AST, which is
rather hard to undo at template instantiation time, throw away the
type-checked AST and store the raw expressions in the AST. This
simplifies instantiation, but loses a little but of information in
the AST.
- When type-checking implicit base or member initializers within a
dependent context, don't add the generated initializers into the
AST, because they'll look like they were explicit.
- Record in CXXConstructExpr when the constructor call is to
initialize a base class, so that CodeGen does not have to infer it
from context. This ensures that we call the right kind of
constructor.
There are also a few "opportunity" fixes here that were needed to not
regress, for example:
- Diagnose default-initialization of a const-qualified class that
does not have a user-declared default constructor. We had this
diagnostic specifically for bases and members, but missed it for
variables. That's fixed now.
- When defining the implicit constructors, destructor, and
copy-assignment operator, set the CurContext to that constructor
when we're defining the body.
llvm-svn: 94952
2010-01-31 17:12:51 +08:00
|
|
|
bool ZeroInitialization,
|
|
|
|
bool BaseInitialization)
|
2009-04-24 13:04:04 +08:00
|
|
|
: Expr(SC, T,
|
2009-04-23 10:32:43 +08:00
|
|
|
T->isDependentType(),
|
|
|
|
(T->isDependentType() ||
|
|
|
|
CallExpr::hasAnyValueDependentArguments(args, numargs))),
|
2009-12-17 02:50:27 +08:00
|
|
|
Constructor(D), Loc(Loc), Elidable(elidable),
|
Rework base and member initialization in constructors, with several
(necessarily simultaneous) changes:
- CXXBaseOrMemberInitializer now contains only a single initializer
rather than a set of initialiation arguments + a constructor. The
single initializer covers all aspects of initialization, including
constructor calls as necessary but also cleanup of temporaries
created by the initializer (which we never handled
before!).
- Rework + simplify code generation for CXXBaseOrMemberInitializers,
since we can now just emit the initializer as an initializer.
- Switched base and member initialization over to the new
initialization code (InitializationSequence), so that it
- Improved diagnostics for the new initialization code when
initializing bases and members, to match the diagnostics produced
by the previous (special-purpose) code.
- Simplify the representation of type-checked constructor initializers in
templates; instead of keeping the fully-type-checked AST, which is
rather hard to undo at template instantiation time, throw away the
type-checked AST and store the raw expressions in the AST. This
simplifies instantiation, but loses a little but of information in
the AST.
- When type-checking implicit base or member initializers within a
dependent context, don't add the generated initializers into the
AST, because they'll look like they were explicit.
- Record in CXXConstructExpr when the constructor call is to
initialize a base class, so that CodeGen does not have to infer it
from context. This ensures that we call the right kind of
constructor.
There are also a few "opportunity" fixes here that were needed to not
regress, for example:
- Diagnose default-initialization of a const-qualified class that
does not have a user-declared default constructor. We had this
diagnostic specifically for bases and members, but missed it for
variables. That's fixed now.
- When defining the implicit constructors, destructor, and
copy-assignment operator, set the CurContext to that constructor
when we're defining the body.
llvm-svn: 94952
2010-01-31 17:12:51 +08:00
|
|
|
ZeroInitialization(ZeroInitialization),
|
|
|
|
BaseInitialization(BaseInitialization), Args(0), NumArgs(numargs)
|
2009-12-17 02:50:27 +08:00
|
|
|
{
|
|
|
|
if (NumArgs) {
|
|
|
|
Args = new (C) Stmt*[NumArgs];
|
|
|
|
|
|
|
|
for (unsigned i = 0; i != NumArgs; ++i) {
|
|
|
|
assert(args[i] && "NULL argument in CXXConstructExpr");
|
|
|
|
Args[i] = args[i];
|
2009-04-23 10:32:43 +08:00
|
|
|
}
|
2009-12-17 02:50:27 +08:00
|
|
|
}
|
2009-04-23 10:32:43 +08:00
|
|
|
}
|
|
|
|
|
2009-09-10 07:08:42 +08:00
|
|
|
CXXConstructExpr::CXXConstructExpr(EmptyShell Empty, ASTContext &C,
|
|
|
|
unsigned numargs)
|
|
|
|
: Expr(CXXConstructExprClass, Empty), Args(0), NumArgs(numargs)
|
|
|
|
{
|
|
|
|
if (NumArgs)
|
|
|
|
Args = new (C) Stmt*[NumArgs];
|
|
|
|
}
|
|
|
|
|
2009-08-07 14:08:38 +08:00
|
|
|
void CXXConstructExpr::DoDestroy(ASTContext &C) {
|
2009-04-23 10:32:43 +08:00
|
|
|
DestroyChildren(C);
|
|
|
|
if (Args)
|
|
|
|
C.Deallocate(Args);
|
|
|
|
this->~CXXConstructExpr();
|
|
|
|
C.Deallocate(this);
|
|
|
|
}
|
|
|
|
|
2009-09-09 23:08:12 +08:00
|
|
|
CXXExprWithTemporaries::CXXExprWithTemporaries(Expr *subexpr,
|
|
|
|
CXXTemporary **temps,
|
2009-12-16 04:51:39 +08:00
|
|
|
unsigned numtemps)
|
2009-05-02 06:18:43 +08:00
|
|
|
: Expr(CXXExprWithTemporariesClass, subexpr->getType(),
|
2009-09-09 23:08:12 +08:00
|
|
|
subexpr->isTypeDependent(), subexpr->isValueDependent()),
|
2009-12-16 04:51:39 +08:00
|
|
|
SubExpr(subexpr), Temps(0), NumTemps(numtemps) {
|
2009-05-31 05:05:25 +08:00
|
|
|
if (NumTemps > 0) {
|
|
|
|
Temps = new CXXTemporary*[NumTemps];
|
|
|
|
for (unsigned i = 0; i < NumTemps; ++i)
|
|
|
|
Temps[i] = temps[i];
|
2009-04-25 06:47:04 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-09-09 23:08:12 +08:00
|
|
|
CXXExprWithTemporaries *CXXExprWithTemporaries::Create(ASTContext &C,
|
2009-05-31 06:38:53 +08:00
|
|
|
Expr *SubExpr,
|
2009-09-09 23:08:12 +08:00
|
|
|
CXXTemporary **Temps,
|
2009-12-16 04:51:39 +08:00
|
|
|
unsigned NumTemps) {
|
|
|
|
return new (C) CXXExprWithTemporaries(SubExpr, Temps, NumTemps);
|
2009-05-31 06:38:53 +08:00
|
|
|
}
|
|
|
|
|
2009-08-07 14:08:38 +08:00
|
|
|
void CXXExprWithTemporaries::DoDestroy(ASTContext &C) {
|
2009-05-31 06:38:53 +08:00
|
|
|
DestroyChildren(C);
|
|
|
|
this->~CXXExprWithTemporaries();
|
|
|
|
C.Deallocate(this);
|
|
|
|
}
|
|
|
|
|
2009-05-02 06:18:43 +08:00
|
|
|
CXXExprWithTemporaries::~CXXExprWithTemporaries() {
|
2009-05-31 05:05:25 +08:00
|
|
|
delete[] Temps;
|
2009-04-25 06:47:04 +08:00
|
|
|
}
|
|
|
|
|
2009-05-31 04:03:25 +08:00
|
|
|
// CXXBindTemporaryExpr
|
|
|
|
Stmt::child_iterator CXXBindTemporaryExpr::child_begin() {
|
|
|
|
return &SubExpr;
|
|
|
|
}
|
|
|
|
|
2009-09-09 23:08:12 +08:00
|
|
|
Stmt::child_iterator CXXBindTemporaryExpr::child_end() {
|
2009-05-31 04:03:25 +08:00
|
|
|
return &SubExpr + 1;
|
|
|
|
}
|
|
|
|
|
2010-01-29 10:39:32 +08:00
|
|
|
// CXXBindReferenceExpr
|
|
|
|
Stmt::child_iterator CXXBindReferenceExpr::child_begin() {
|
|
|
|
return &SubExpr;
|
|
|
|
}
|
|
|
|
|
|
|
|
Stmt::child_iterator CXXBindReferenceExpr::child_end() {
|
|
|
|
return &SubExpr + 1;
|
|
|
|
}
|
|
|
|
|
2009-04-23 10:32:43 +08:00
|
|
|
// CXXConstructExpr
|
|
|
|
Stmt::child_iterator CXXConstructExpr::child_begin() {
|
|
|
|
return &Args[0];
|
|
|
|
}
|
|
|
|
Stmt::child_iterator CXXConstructExpr::child_end() {
|
|
|
|
return &Args[0]+NumArgs;
|
|
|
|
}
|
|
|
|
|
2009-05-02 06:21:22 +08:00
|
|
|
// CXXExprWithTemporaries
|
|
|
|
Stmt::child_iterator CXXExprWithTemporaries::child_begin() {
|
|
|
|
return &SubExpr;
|
2009-04-21 10:22:11 +08:00
|
|
|
}
|
2009-04-25 06:47:04 +08:00
|
|
|
|
2009-09-09 23:08:12 +08:00
|
|
|
Stmt::child_iterator CXXExprWithTemporaries::child_end() {
|
2009-05-02 06:21:22 +08:00
|
|
|
return &SubExpr + 1;
|
|
|
|
}
|
2009-04-25 06:47:04 +08:00
|
|
|
|
Introduce a new expression type, CXXUnresolvedConstructExpr, to
describe the construction of a value of a given type using function
syntax, e.g.,
T(a1, a2, ..., aN)
when the type or any of its arguments are type-dependent. In this
case, we don't know what kind of type-construction this will be: it
might construct a temporary of type 'T' (which might be a class or
non-class type) or might perform a conversion to type 'T'. Also,
implement printing of and template instantiation for this new
expression type. Due to the change in Sema::ActOnCXXTypeConstructExpr,
our existing tests cover template instantiation of this new expression
node.
llvm-svn: 72176
2009-05-21 02:46:25 +08:00
|
|
|
CXXUnresolvedConstructExpr::CXXUnresolvedConstructExpr(
|
|
|
|
SourceLocation TyBeginLoc,
|
|
|
|
QualType T,
|
|
|
|
SourceLocation LParenLoc,
|
|
|
|
Expr **Args,
|
|
|
|
unsigned NumArgs,
|
|
|
|
SourceLocation RParenLoc)
|
|
|
|
: Expr(CXXUnresolvedConstructExprClass, T.getNonReferenceType(),
|
|
|
|
T->isDependentType(), true),
|
|
|
|
TyBeginLoc(TyBeginLoc),
|
|
|
|
Type(T),
|
|
|
|
LParenLoc(LParenLoc),
|
|
|
|
RParenLoc(RParenLoc),
|
|
|
|
NumArgs(NumArgs) {
|
|
|
|
Stmt **StoredArgs = reinterpret_cast<Stmt **>(this + 1);
|
|
|
|
memcpy(StoredArgs, Args, sizeof(Expr *) * NumArgs);
|
|
|
|
}
|
|
|
|
|
|
|
|
CXXUnresolvedConstructExpr *
|
2009-09-09 23:08:12 +08:00
|
|
|
CXXUnresolvedConstructExpr::Create(ASTContext &C,
|
Introduce a new expression type, CXXUnresolvedConstructExpr, to
describe the construction of a value of a given type using function
syntax, e.g.,
T(a1, a2, ..., aN)
when the type or any of its arguments are type-dependent. In this
case, we don't know what kind of type-construction this will be: it
might construct a temporary of type 'T' (which might be a class or
non-class type) or might perform a conversion to type 'T'. Also,
implement printing of and template instantiation for this new
expression type. Due to the change in Sema::ActOnCXXTypeConstructExpr,
our existing tests cover template instantiation of this new expression
node.
llvm-svn: 72176
2009-05-21 02:46:25 +08:00
|
|
|
SourceLocation TyBegin,
|
|
|
|
QualType T,
|
|
|
|
SourceLocation LParenLoc,
|
|
|
|
Expr **Args,
|
|
|
|
unsigned NumArgs,
|
|
|
|
SourceLocation RParenLoc) {
|
|
|
|
void *Mem = C.Allocate(sizeof(CXXUnresolvedConstructExpr) +
|
|
|
|
sizeof(Expr *) * NumArgs);
|
|
|
|
return new (Mem) CXXUnresolvedConstructExpr(TyBegin, T, LParenLoc,
|
|
|
|
Args, NumArgs, RParenLoc);
|
|
|
|
}
|
|
|
|
|
|
|
|
Stmt::child_iterator CXXUnresolvedConstructExpr::child_begin() {
|
|
|
|
return child_iterator(reinterpret_cast<Stmt **>(this + 1));
|
|
|
|
}
|
|
|
|
|
|
|
|
Stmt::child_iterator CXXUnresolvedConstructExpr::child_end() {
|
|
|
|
return child_iterator(reinterpret_cast<Stmt **>(this + 1) + NumArgs);
|
|
|
|
}
|
2009-05-17 02:50:46 +08:00
|
|
|
|
2009-11-20 06:55:06 +08:00
|
|
|
CXXDependentScopeMemberExpr::CXXDependentScopeMemberExpr(ASTContext &C,
|
2009-12-02 06:10:20 +08:00
|
|
|
Expr *Base, QualType BaseType,
|
|
|
|
bool IsArrow,
|
2009-09-09 08:23:06 +08:00
|
|
|
SourceLocation OperatorLoc,
|
|
|
|
NestedNameSpecifier *Qualifier,
|
|
|
|
SourceRange QualifierRange,
|
|
|
|
NamedDecl *FirstQualifierFoundInScope,
|
|
|
|
DeclarationName Member,
|
|
|
|
SourceLocation MemberLoc,
|
2009-11-23 09:53:49 +08:00
|
|
|
const TemplateArgumentListInfo *TemplateArgs)
|
2009-11-20 06:55:06 +08:00
|
|
|
: Expr(CXXDependentScopeMemberExprClass, C.DependentTy, true, true),
|
2009-12-02 06:10:20 +08:00
|
|
|
Base(Base), BaseType(BaseType), IsArrow(IsArrow),
|
|
|
|
HasExplicitTemplateArgs(TemplateArgs != 0),
|
2009-09-09 08:23:06 +08:00
|
|
|
OperatorLoc(OperatorLoc),
|
|
|
|
Qualifier(Qualifier), QualifierRange(QualifierRange),
|
|
|
|
FirstQualifierFoundInScope(FirstQualifierFoundInScope),
|
2009-09-09 23:08:12 +08:00
|
|
|
Member(Member), MemberLoc(MemberLoc) {
|
2009-11-23 09:53:49 +08:00
|
|
|
if (TemplateArgs)
|
|
|
|
getExplicitTemplateArgumentList()->initializeFrom(*TemplateArgs);
|
2009-09-09 08:23:06 +08:00
|
|
|
}
|
|
|
|
|
2009-11-20 06:55:06 +08:00
|
|
|
CXXDependentScopeMemberExpr *
|
|
|
|
CXXDependentScopeMemberExpr::Create(ASTContext &C,
|
2009-12-02 06:10:20 +08:00
|
|
|
Expr *Base, QualType BaseType, bool IsArrow,
|
2009-09-09 08:23:06 +08:00
|
|
|
SourceLocation OperatorLoc,
|
|
|
|
NestedNameSpecifier *Qualifier,
|
|
|
|
SourceRange QualifierRange,
|
|
|
|
NamedDecl *FirstQualifierFoundInScope,
|
|
|
|
DeclarationName Member,
|
|
|
|
SourceLocation MemberLoc,
|
2009-11-23 09:53:49 +08:00
|
|
|
const TemplateArgumentListInfo *TemplateArgs) {
|
|
|
|
if (!TemplateArgs)
|
2009-12-02 06:10:20 +08:00
|
|
|
return new (C) CXXDependentScopeMemberExpr(C, Base, BaseType,
|
|
|
|
IsArrow, OperatorLoc,
|
|
|
|
Qualifier, QualifierRange,
|
|
|
|
FirstQualifierFoundInScope,
|
|
|
|
Member, MemberLoc);
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-11-23 09:53:49 +08:00
|
|
|
std::size_t size = sizeof(CXXDependentScopeMemberExpr);
|
|
|
|
if (TemplateArgs)
|
|
|
|
size += ExplicitTemplateArgumentList::sizeFor(*TemplateArgs);
|
|
|
|
|
|
|
|
void *Mem = C.Allocate(size, llvm::alignof<CXXDependentScopeMemberExpr>());
|
2009-12-02 06:10:20 +08:00
|
|
|
return new (Mem) CXXDependentScopeMemberExpr(C, Base, BaseType,
|
|
|
|
IsArrow, OperatorLoc,
|
|
|
|
Qualifier, QualifierRange,
|
|
|
|
FirstQualifierFoundInScope,
|
|
|
|
Member, MemberLoc, TemplateArgs);
|
2009-09-09 08:23:06 +08:00
|
|
|
}
|
|
|
|
|
2009-11-20 06:55:06 +08:00
|
|
|
Stmt::child_iterator CXXDependentScopeMemberExpr::child_begin() {
|
2009-05-23 05:13:27 +08:00
|
|
|
return child_iterator(&Base);
|
|
|
|
}
|
|
|
|
|
2009-11-20 06:55:06 +08:00
|
|
|
Stmt::child_iterator CXXDependentScopeMemberExpr::child_end() {
|
2009-12-02 06:10:20 +08:00
|
|
|
if (isImplicitAccess())
|
|
|
|
return child_iterator(&Base);
|
2009-05-23 05:13:27 +08:00
|
|
|
return child_iterator(&Base + 1);
|
|
|
|
}
|
2009-12-01 06:42:35 +08:00
|
|
|
|
|
|
|
UnresolvedMemberExpr::UnresolvedMemberExpr(QualType T, bool Dependent,
|
|
|
|
bool HasUnresolvedUsing,
|
2009-12-02 06:10:20 +08:00
|
|
|
Expr *Base, QualType BaseType,
|
|
|
|
bool IsArrow,
|
2009-12-01 06:42:35 +08:00
|
|
|
SourceLocation OperatorLoc,
|
|
|
|
NestedNameSpecifier *Qualifier,
|
|
|
|
SourceRange QualifierRange,
|
|
|
|
DeclarationName MemberName,
|
|
|
|
SourceLocation MemberLoc,
|
|
|
|
const TemplateArgumentListInfo *TemplateArgs)
|
2010-02-02 14:20:04 +08:00
|
|
|
: OverloadExpr(UnresolvedMemberExprClass, T, Dependent,
|
|
|
|
Qualifier, QualifierRange, MemberName, MemberLoc,
|
|
|
|
TemplateArgs != 0),
|
|
|
|
IsArrow(IsArrow), HasUnresolvedUsing(HasUnresolvedUsing),
|
|
|
|
Base(Base), BaseType(BaseType), OperatorLoc(OperatorLoc) {
|
2009-12-01 06:42:35 +08:00
|
|
|
if (TemplateArgs)
|
2010-02-02 14:20:04 +08:00
|
|
|
getExplicitTemplateArgs().initializeFrom(*TemplateArgs);
|
2009-12-01 06:42:35 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
UnresolvedMemberExpr *
|
|
|
|
UnresolvedMemberExpr::Create(ASTContext &C, bool Dependent,
|
|
|
|
bool HasUnresolvedUsing,
|
2009-12-02 06:10:20 +08:00
|
|
|
Expr *Base, QualType BaseType, bool IsArrow,
|
2009-12-01 06:42:35 +08:00
|
|
|
SourceLocation OperatorLoc,
|
|
|
|
NestedNameSpecifier *Qualifier,
|
|
|
|
SourceRange QualifierRange,
|
|
|
|
DeclarationName Member,
|
|
|
|
SourceLocation MemberLoc,
|
|
|
|
const TemplateArgumentListInfo *TemplateArgs) {
|
|
|
|
std::size_t size = sizeof(UnresolvedMemberExpr);
|
|
|
|
if (TemplateArgs)
|
|
|
|
size += ExplicitTemplateArgumentList::sizeFor(*TemplateArgs);
|
|
|
|
|
|
|
|
void *Mem = C.Allocate(size, llvm::alignof<UnresolvedMemberExpr>());
|
|
|
|
return new (Mem) UnresolvedMemberExpr(
|
|
|
|
Dependent ? C.DependentTy : C.OverloadTy,
|
2009-12-02 06:10:20 +08:00
|
|
|
Dependent, HasUnresolvedUsing, Base, BaseType,
|
|
|
|
IsArrow, OperatorLoc, Qualifier, QualifierRange,
|
2009-12-01 06:42:35 +08:00
|
|
|
Member, MemberLoc, TemplateArgs);
|
|
|
|
}
|
|
|
|
|
2010-01-27 09:50:18 +08:00
|
|
|
CXXRecordDecl *UnresolvedMemberExpr::getNamingClass() const {
|
|
|
|
// Unlike for UnresolvedLookupExpr, it is very easy to re-derive this.
|
|
|
|
|
|
|
|
// If there was a nested name specifier, it names the naming class.
|
|
|
|
// It can't be dependent: after all, we were actually able to do the
|
|
|
|
// lookup.
|
|
|
|
const RecordType *RT;
|
2010-02-02 14:20:04 +08:00
|
|
|
if (getQualifier()) {
|
|
|
|
Type *T = getQualifier()->getAsType();
|
2010-01-27 09:50:18 +08:00
|
|
|
assert(T && "qualifier in member expression does not name type");
|
|
|
|
RT = T->getAs<RecordType>();
|
|
|
|
assert(RT && "qualifier in member expression does not name record");
|
|
|
|
|
|
|
|
// Otherwise the naming class must have been the base class.
|
|
|
|
} else {
|
|
|
|
QualType BaseType = getBaseType().getNonReferenceType();
|
|
|
|
if (isArrow()) {
|
|
|
|
const PointerType *PT = BaseType->getAs<PointerType>();
|
|
|
|
assert(PT && "base of arrow member access is not pointer");
|
|
|
|
BaseType = PT->getPointeeType();
|
|
|
|
}
|
|
|
|
|
|
|
|
RT = BaseType->getAs<RecordType>();
|
|
|
|
assert(RT && "base of member expression does not name record");
|
|
|
|
}
|
|
|
|
|
|
|
|
return cast<CXXRecordDecl>(RT->getDecl());
|
|
|
|
}
|
|
|
|
|
2009-12-01 06:42:35 +08:00
|
|
|
Stmt::child_iterator UnresolvedMemberExpr::child_begin() {
|
|
|
|
return child_iterator(&Base);
|
|
|
|
}
|
|
|
|
|
|
|
|
Stmt::child_iterator UnresolvedMemberExpr::child_end() {
|
2009-12-02 06:10:20 +08:00
|
|
|
if (isImplicitAccess())
|
|
|
|
return child_iterator(&Base);
|
2009-12-01 06:42:35 +08:00
|
|
|
return child_iterator(&Base + 1);
|
|
|
|
}
|