Change struct forward declarations and definitions to use unique RecordDecls, as opposed to creating a single RecordDecl and reusing it.
This change effects both RecordDecls and CXXRecordDecls, but does not effect EnumDecls (yet).
The motivation of this patch is as follows:
- Capture more source information, necessary for refactoring/rewriting clients.
- Pave the way to resolve ownership issues with RecordDecls with the forthcoming
addition of DeclGroups.
Current caveats:
- Until DeclGroups are in place, we will leak RecordDecls not explicitly
referenced by the AST. For example:
typedef struct { ... } x;
The RecordDecl for the struct will be leaked because the TypedefDecl doesn't
refer to it. This will be solved with DeclGroups.
- This patch also (temporarily) breaks CodeGen. More below.
High-level changes:
- As before, TagType still refers to a TagDecl, but it doesn't own it. When
a struct/union/class is first referenced, a RecordType and RecordDecl are
created for it, and the RecordType refers to that RecordDecl. Later, if
a new RecordDecl is created, the pointer to a RecordDecl in RecordType is
updated to point to the RecordDecl that defines the struct/union/class.
- TagDecl and RecordDecl now how a method 'getDefinition()' to return the
TagDecl*/RecordDecl* that refers to the TagDecl* that defines a particular
enum/struct/class/union. This is useful from going from a RecordDecl* that
defines a forward declaration to the RecordDecl* that provides the actual
definition. Note that this also works for EnumDecls, except that in this case
there is no distinction between forward declarations and definitions (yet).
- Clients should no longer assume that 'isDefinition()' returns true from a
RecordDecl if the corresponding struct/union/class has been defined.
isDefinition() only returns true if a particular RecordDecl is the defining
Decl. Use 'getDefinition()' instead to determine if a struct has been defined.
- The main changes to Sema happen in ActOnTag. To make the changes more
incremental, I split off the processing of enums and structs et al into two
code paths. Enums use the original code path (which is in ActOnTag) and
structs use the ActOnTagStruct. Eventually the two code paths will be merged,
but the idea was to preserve the original logic both for comparison and not to
change the logic for both enums and structs all at once.
- There is NO CHAINING of RecordDecls for the same RecordType. All RecordDecls
that correspond to the same type simply have a pointer to that type. If we
need to figure out what are all the RecordDecls for a given type we can build
a backmap.
- The diff in CXXRecordDecl.[cpp,h] is actually very small; it just mimics the
changes to RecordDecl. For some reason 'svn' marks the entire file as changed.
Why is CodeGen broken:
- Codegen assumes that there is an equivalence between RecordDecl* and
RecordType*. This was true before because we only created one RecordDecl* for
a given RecordType*, but it is no longer true. I believe this shouldn't be too
hard to change, but the patch was big enough as it is.
I have tested this patch on both the clang test suite, and by running the static analyzer over Postgresql and a large Apple-internal project (mix of Objective-C and C).
llvm-svn: 55839
2008-09-06 01:16:31 +08:00
|
|
|
//===--- DeclCXX.cpp - C++ Declaration AST Node Implementation ------------===//
|
|
|
|
|
//
|
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
|
//
|
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
|
//
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
//
|
|
|
|
|
// This file implements the C++ related Decl classes.
|
|
|
|
|
//
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
|
|
#include "clang/AST/DeclCXX.h"
|
2009-03-26 05:17:03 +08:00
|
|
|
#include "clang/AST/DeclTemplate.h"
|
Change struct forward declarations and definitions to use unique RecordDecls, as opposed to creating a single RecordDecl and reusing it.
This change effects both RecordDecls and CXXRecordDecls, but does not effect EnumDecls (yet).
The motivation of this patch is as follows:
- Capture more source information, necessary for refactoring/rewriting clients.
- Pave the way to resolve ownership issues with RecordDecls with the forthcoming
addition of DeclGroups.
Current caveats:
- Until DeclGroups are in place, we will leak RecordDecls not explicitly
referenced by the AST. For example:
typedef struct { ... } x;
The RecordDecl for the struct will be leaked because the TypedefDecl doesn't
refer to it. This will be solved with DeclGroups.
- This patch also (temporarily) breaks CodeGen. More below.
High-level changes:
- As before, TagType still refers to a TagDecl, but it doesn't own it. When
a struct/union/class is first referenced, a RecordType and RecordDecl are
created for it, and the RecordType refers to that RecordDecl. Later, if
a new RecordDecl is created, the pointer to a RecordDecl in RecordType is
updated to point to the RecordDecl that defines the struct/union/class.
- TagDecl and RecordDecl now how a method 'getDefinition()' to return the
TagDecl*/RecordDecl* that refers to the TagDecl* that defines a particular
enum/struct/class/union. This is useful from going from a RecordDecl* that
defines a forward declaration to the RecordDecl* that provides the actual
definition. Note that this also works for EnumDecls, except that in this case
there is no distinction between forward declarations and definitions (yet).
- Clients should no longer assume that 'isDefinition()' returns true from a
RecordDecl if the corresponding struct/union/class has been defined.
isDefinition() only returns true if a particular RecordDecl is the defining
Decl. Use 'getDefinition()' instead to determine if a struct has been defined.
- The main changes to Sema happen in ActOnTag. To make the changes more
incremental, I split off the processing of enums and structs et al into two
code paths. Enums use the original code path (which is in ActOnTag) and
structs use the ActOnTagStruct. Eventually the two code paths will be merged,
but the idea was to preserve the original logic both for comparison and not to
change the logic for both enums and structs all at once.
- There is NO CHAINING of RecordDecls for the same RecordType. All RecordDecls
that correspond to the same type simply have a pointer to that type. If we
need to figure out what are all the RecordDecls for a given type we can build
a backmap.
- The diff in CXXRecordDecl.[cpp,h] is actually very small; it just mimics the
changes to RecordDecl. For some reason 'svn' marks the entire file as changed.
Why is CodeGen broken:
- Codegen assumes that there is an equivalence between RecordDecl* and
RecordType*. This was true before because we only created one RecordDecl* for
a given RecordType*, but it is no longer true. I believe this shouldn't be too
hard to change, but the patch was big enough as it is.
I have tested this patch on both the clang test suite, and by running the static analyzer over Postgresql and a large Apple-internal project (mix of Objective-C and C).
llvm-svn: 55839
2008-09-06 01:16:31 +08:00
|
|
|
#include "clang/AST/ASTContext.h"
|
2009-03-14 08:25:26 +08:00
|
|
|
#include "clang/AST/Expr.h"
|
2008-11-13 07:21:09 +08:00
|
|
|
#include "clang/Basic/IdentifierTable.h"
|
2008-12-24 05:31:30 +08:00
|
|
|
#include "llvm/ADT/STLExtras.h"
|
2009-09-13 03:52:10 +08:00
|
|
|
#include "llvm/ADT/SmallPtrSet.h"
|
Change struct forward declarations and definitions to use unique RecordDecls, as opposed to creating a single RecordDecl and reusing it.
This change effects both RecordDecls and CXXRecordDecls, but does not effect EnumDecls (yet).
The motivation of this patch is as follows:
- Capture more source information, necessary for refactoring/rewriting clients.
- Pave the way to resolve ownership issues with RecordDecls with the forthcoming
addition of DeclGroups.
Current caveats:
- Until DeclGroups are in place, we will leak RecordDecls not explicitly
referenced by the AST. For example:
typedef struct { ... } x;
The RecordDecl for the struct will be leaked because the TypedefDecl doesn't
refer to it. This will be solved with DeclGroups.
- This patch also (temporarily) breaks CodeGen. More below.
High-level changes:
- As before, TagType still refers to a TagDecl, but it doesn't own it. When
a struct/union/class is first referenced, a RecordType and RecordDecl are
created for it, and the RecordType refers to that RecordDecl. Later, if
a new RecordDecl is created, the pointer to a RecordDecl in RecordType is
updated to point to the RecordDecl that defines the struct/union/class.
- TagDecl and RecordDecl now how a method 'getDefinition()' to return the
TagDecl*/RecordDecl* that refers to the TagDecl* that defines a particular
enum/struct/class/union. This is useful from going from a RecordDecl* that
defines a forward declaration to the RecordDecl* that provides the actual
definition. Note that this also works for EnumDecls, except that in this case
there is no distinction between forward declarations and definitions (yet).
- Clients should no longer assume that 'isDefinition()' returns true from a
RecordDecl if the corresponding struct/union/class has been defined.
isDefinition() only returns true if a particular RecordDecl is the defining
Decl. Use 'getDefinition()' instead to determine if a struct has been defined.
- The main changes to Sema happen in ActOnTag. To make the changes more
incremental, I split off the processing of enums and structs et al into two
code paths. Enums use the original code path (which is in ActOnTag) and
structs use the ActOnTagStruct. Eventually the two code paths will be merged,
but the idea was to preserve the original logic both for comparison and not to
change the logic for both enums and structs all at once.
- There is NO CHAINING of RecordDecls for the same RecordType. All RecordDecls
that correspond to the same type simply have a pointer to that type. If we
need to figure out what are all the RecordDecls for a given type we can build
a backmap.
- The diff in CXXRecordDecl.[cpp,h] is actually very small; it just mimics the
changes to RecordDecl. For some reason 'svn' marks the entire file as changed.
Why is CodeGen broken:
- Codegen assumes that there is an equivalence between RecordDecl* and
RecordType*. This was true before because we only created one RecordDecl* for
a given RecordType*, but it is no longer true. I believe this shouldn't be too
hard to change, but the patch was big enough as it is.
I have tested this patch on both the clang test suite, and by running the static analyzer over Postgresql and a large Apple-internal project (mix of Objective-C and C).
llvm-svn: 55839
2008-09-06 01:16:31 +08:00
|
|
|
using namespace clang;
|
|
|
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
// Decl Allocation/Deallocation Method Implementations
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
2008-12-06 02:15:24 +08:00
|
|
|
|
Added ClassTemplateSpecializationDecl, which is a subclass of
CXXRecordDecl that is used to represent class template
specializations. These are canonical declarations that can refer to
either an actual class template specialization in the code, e.g.,
template<> class vector<bool> { };
or to a template instantiation. However, neither of these features is
actually implemented yet, so really we're just using (and uniqing) the
declarations to make sure that, e.g., A<int> is a different type from
A<float>. Note that we carefully distinguish between what the user
wrote in the source code (e.g., "A<FLOAT>") and the semantic entity it
represents (e.g., "A<float, int>"); the former is in the sugared Type,
the latter is an actual Decl.
llvm-svn: 64716
2009-02-17 09:05:43 +08:00
|
|
|
CXXRecordDecl::CXXRecordDecl(Kind K, TagKind TK, DeclContext *DC,
|
2009-07-21 22:46:17 +08:00
|
|
|
SourceLocation L, IdentifierInfo *Id,
|
2009-07-30 07:36:44 +08:00
|
|
|
CXXRecordDecl *PrevDecl,
|
2009-09-09 23:08:12 +08:00
|
|
|
SourceLocation TKL)
|
2009-07-30 07:36:44 +08:00
|
|
|
: RecordDecl(K, TK, DC, L, Id, PrevDecl, TKL),
|
2008-11-13 07:21:09 +08:00
|
|
|
UserDeclaredConstructor(false), UserDeclaredCopyConstructor(false),
|
2009-01-06 04:52:13 +08:00
|
|
|
UserDeclaredCopyAssignment(false), UserDeclaredDestructor(false),
|
2009-08-16 06:23:00 +08:00
|
|
|
Aggregate(true), PlainOldData(true), Empty(true), Polymorphic(false),
|
|
|
|
|
Abstract(false), HasTrivialConstructor(true),
|
|
|
|
|
HasTrivialCopyConstructor(true), HasTrivialCopyAssignment(true),
|
2009-09-13 02:26:03 +08:00
|
|
|
HasTrivialDestructor(true), ComputedVisibleConversions(false),
|
|
|
|
|
Bases(0), NumBases(0), VBases(0), NumVBases(0),
|
2009-07-11 04:13:23 +08:00
|
|
|
Conversions(DC, DeclarationName()),
|
2009-09-12 05:44:33 +08:00
|
|
|
VisibleConversions(DC, DeclarationName()),
|
2009-03-26 05:17:03 +08:00
|
|
|
TemplateOrInstantiation() { }
|
2008-11-13 07:21:09 +08:00
|
|
|
|
Change struct forward declarations and definitions to use unique RecordDecls, as opposed to creating a single RecordDecl and reusing it.
This change effects both RecordDecls and CXXRecordDecls, but does not effect EnumDecls (yet).
The motivation of this patch is as follows:
- Capture more source information, necessary for refactoring/rewriting clients.
- Pave the way to resolve ownership issues with RecordDecls with the forthcoming
addition of DeclGroups.
Current caveats:
- Until DeclGroups are in place, we will leak RecordDecls not explicitly
referenced by the AST. For example:
typedef struct { ... } x;
The RecordDecl for the struct will be leaked because the TypedefDecl doesn't
refer to it. This will be solved with DeclGroups.
- This patch also (temporarily) breaks CodeGen. More below.
High-level changes:
- As before, TagType still refers to a TagDecl, but it doesn't own it. When
a struct/union/class is first referenced, a RecordType and RecordDecl are
created for it, and the RecordType refers to that RecordDecl. Later, if
a new RecordDecl is created, the pointer to a RecordDecl in RecordType is
updated to point to the RecordDecl that defines the struct/union/class.
- TagDecl and RecordDecl now how a method 'getDefinition()' to return the
TagDecl*/RecordDecl* that refers to the TagDecl* that defines a particular
enum/struct/class/union. This is useful from going from a RecordDecl* that
defines a forward declaration to the RecordDecl* that provides the actual
definition. Note that this also works for EnumDecls, except that in this case
there is no distinction between forward declarations and definitions (yet).
- Clients should no longer assume that 'isDefinition()' returns true from a
RecordDecl if the corresponding struct/union/class has been defined.
isDefinition() only returns true if a particular RecordDecl is the defining
Decl. Use 'getDefinition()' instead to determine if a struct has been defined.
- The main changes to Sema happen in ActOnTag. To make the changes more
incremental, I split off the processing of enums and structs et al into two
code paths. Enums use the original code path (which is in ActOnTag) and
structs use the ActOnTagStruct. Eventually the two code paths will be merged,
but the idea was to preserve the original logic both for comparison and not to
change the logic for both enums and structs all at once.
- There is NO CHAINING of RecordDecls for the same RecordType. All RecordDecls
that correspond to the same type simply have a pointer to that type. If we
need to figure out what are all the RecordDecls for a given type we can build
a backmap.
- The diff in CXXRecordDecl.[cpp,h] is actually very small; it just mimics the
changes to RecordDecl. For some reason 'svn' marks the entire file as changed.
Why is CodeGen broken:
- Codegen assumes that there is an equivalence between RecordDecl* and
RecordType*. This was true before because we only created one RecordDecl* for
a given RecordType*, but it is no longer true. I believe this shouldn't be too
hard to change, but the patch was big enough as it is.
I have tested this patch on both the clang test suite, and by running the static analyzer over Postgresql and a large Apple-internal project (mix of Objective-C and C).
llvm-svn: 55839
2008-09-06 01:16:31 +08:00
|
|
|
CXXRecordDecl *CXXRecordDecl::Create(ASTContext &C, TagKind TK, DeclContext *DC,
|
|
|
|
|
SourceLocation L, IdentifierInfo *Id,
|
2009-07-21 22:46:17 +08:00
|
|
|
SourceLocation TKL,
|
2009-05-16 03:11:46 +08:00
|
|
|
CXXRecordDecl* PrevDecl,
|
|
|
|
|
bool DelayTypeCreation) {
|
2009-09-09 23:08:12 +08:00
|
|
|
CXXRecordDecl* R = new (C) CXXRecordDecl(CXXRecord, TK, DC, L, Id,
|
2009-07-30 07:36:44 +08:00
|
|
|
PrevDecl, TKL);
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-07-30 07:36:44 +08:00
|
|
|
// FIXME: DelayTypeCreation seems like such a hack
|
2009-05-16 03:11:46 +08:00
|
|
|
if (!DelayTypeCreation)
|
2009-09-09 23:08:12 +08:00
|
|
|
C.getTypeDeclType(R, PrevDecl);
|
Change struct forward declarations and definitions to use unique RecordDecls, as opposed to creating a single RecordDecl and reusing it.
This change effects both RecordDecls and CXXRecordDecls, but does not effect EnumDecls (yet).
The motivation of this patch is as follows:
- Capture more source information, necessary for refactoring/rewriting clients.
- Pave the way to resolve ownership issues with RecordDecls with the forthcoming
addition of DeclGroups.
Current caveats:
- Until DeclGroups are in place, we will leak RecordDecls not explicitly
referenced by the AST. For example:
typedef struct { ... } x;
The RecordDecl for the struct will be leaked because the TypedefDecl doesn't
refer to it. This will be solved with DeclGroups.
- This patch also (temporarily) breaks CodeGen. More below.
High-level changes:
- As before, TagType still refers to a TagDecl, but it doesn't own it. When
a struct/union/class is first referenced, a RecordType and RecordDecl are
created for it, and the RecordType refers to that RecordDecl. Later, if
a new RecordDecl is created, the pointer to a RecordDecl in RecordType is
updated to point to the RecordDecl that defines the struct/union/class.
- TagDecl and RecordDecl now how a method 'getDefinition()' to return the
TagDecl*/RecordDecl* that refers to the TagDecl* that defines a particular
enum/struct/class/union. This is useful from going from a RecordDecl* that
defines a forward declaration to the RecordDecl* that provides the actual
definition. Note that this also works for EnumDecls, except that in this case
there is no distinction between forward declarations and definitions (yet).
- Clients should no longer assume that 'isDefinition()' returns true from a
RecordDecl if the corresponding struct/union/class has been defined.
isDefinition() only returns true if a particular RecordDecl is the defining
Decl. Use 'getDefinition()' instead to determine if a struct has been defined.
- The main changes to Sema happen in ActOnTag. To make the changes more
incremental, I split off the processing of enums and structs et al into two
code paths. Enums use the original code path (which is in ActOnTag) and
structs use the ActOnTagStruct. Eventually the two code paths will be merged,
but the idea was to preserve the original logic both for comparison and not to
change the logic for both enums and structs all at once.
- There is NO CHAINING of RecordDecls for the same RecordType. All RecordDecls
that correspond to the same type simply have a pointer to that type. If we
need to figure out what are all the RecordDecls for a given type we can build
a backmap.
- The diff in CXXRecordDecl.[cpp,h] is actually very small; it just mimics the
changes to RecordDecl. For some reason 'svn' marks the entire file as changed.
Why is CodeGen broken:
- Codegen assumes that there is an equivalence between RecordDecl* and
RecordType*. This was true before because we only created one RecordDecl* for
a given RecordType*, but it is no longer true. I believe this shouldn't be too
hard to change, but the patch was big enough as it is.
I have tested this patch on both the clang test suite, and by running the static analyzer over Postgresql and a large Apple-internal project (mix of Objective-C and C).
llvm-svn: 55839
2008-09-06 01:16:31 +08:00
|
|
|
return R;
|
|
|
|
|
}
|
|
|
|
|
|
2008-10-23 01:49:05 +08:00
|
|
|
CXXRecordDecl::~CXXRecordDecl() {
|
2009-07-03 02:26:15 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void CXXRecordDecl::Destroy(ASTContext &C) {
|
|
|
|
|
C.Deallocate(Bases);
|
2009-07-23 01:41:53 +08:00
|
|
|
C.Deallocate(VBases);
|
2009-07-03 02:26:15 +08:00
|
|
|
this->RecordDecl::Destroy(C);
|
2008-10-23 01:49:05 +08:00
|
|
|
}
|
|
|
|
|
|
2009-09-09 23:08:12 +08:00
|
|
|
void
|
2009-07-03 02:26:15 +08:00
|
|
|
CXXRecordDecl::setBases(ASTContext &C,
|
2009-09-09 23:08:12 +08:00
|
|
|
CXXBaseSpecifier const * const *Bases,
|
2008-10-24 02:13:27 +08:00
|
|
|
unsigned NumBases) {
|
2009-09-09 23:08:12 +08:00
|
|
|
// C++ [dcl.init.aggr]p1:
|
2008-11-06 00:20:31 +08:00
|
|
|
// An aggregate is an array or a class (clause 9) with [...]
|
|
|
|
|
// no base classes [...].
|
|
|
|
|
Aggregate = false;
|
|
|
|
|
|
2008-10-24 02:13:27 +08:00
|
|
|
if (this->Bases)
|
2009-07-03 02:26:15 +08:00
|
|
|
C.Deallocate(this->Bases);
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-07-11 04:13:23 +08:00
|
|
|
int vbaseCount = 0;
|
|
|
|
|
llvm::SmallVector<const CXXBaseSpecifier*, 8> UniqueVbases;
|
|
|
|
|
bool hasDirectVirtualBase = false;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-07-03 02:26:15 +08:00
|
|
|
this->Bases = new(C) CXXBaseSpecifier [NumBases];
|
2008-10-24 02:13:27 +08:00
|
|
|
this->NumBases = NumBases;
|
2009-07-11 04:13:23 +08:00
|
|
|
for (unsigned i = 0; i < NumBases; ++i) {
|
2008-10-24 02:13:27 +08:00
|
|
|
this->Bases[i] = *Bases[i];
|
2009-07-11 04:13:23 +08:00
|
|
|
// Keep track of inherited vbases for this base class.
|
|
|
|
|
const CXXBaseSpecifier *Base = Bases[i];
|
|
|
|
|
QualType BaseType = Base->getType();
|
2009-09-09 23:08:12 +08:00
|
|
|
// Skip template types.
|
2009-07-11 04:13:23 +08:00
|
|
|
// FIXME. This means that this list must be rebuilt during template
|
|
|
|
|
// instantiation.
|
|
|
|
|
if (BaseType->isDependentType())
|
|
|
|
|
continue;
|
|
|
|
|
CXXRecordDecl *BaseClassDecl
|
2009-07-30 05:53:49 +08:00
|
|
|
= cast<CXXRecordDecl>(BaseType->getAs<RecordType>()->getDecl());
|
2009-07-11 04:13:23 +08:00
|
|
|
if (Base->isVirtual())
|
|
|
|
|
hasDirectVirtualBase = true;
|
2009-09-09 23:08:12 +08:00
|
|
|
for (CXXRecordDecl::base_class_iterator VBase =
|
2009-07-11 04:13:23 +08:00
|
|
|
BaseClassDecl->vbases_begin(),
|
|
|
|
|
E = BaseClassDecl->vbases_end(); VBase != E; ++VBase) {
|
2009-09-09 23:08:12 +08:00
|
|
|
// Add this vbase to the array of vbases for current class if it is
|
2009-07-11 04:13:23 +08:00
|
|
|
// not already in the list.
|
|
|
|
|
// FIXME. Note that we do a linear search as number of such classes are
|
|
|
|
|
// very few.
|
|
|
|
|
int i;
|
|
|
|
|
for (i = 0; i < vbaseCount; ++i)
|
|
|
|
|
if (UniqueVbases[i]->getType() == VBase->getType())
|
|
|
|
|
break;
|
|
|
|
|
if (i == vbaseCount) {
|
|
|
|
|
UniqueVbases.push_back(VBase);
|
|
|
|
|
++vbaseCount;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if (hasDirectVirtualBase) {
|
|
|
|
|
// Iterate one more time through the direct bases and add the virtual
|
|
|
|
|
// base to the list of vritual bases for current class.
|
|
|
|
|
for (unsigned i = 0; i < NumBases; ++i) {
|
|
|
|
|
const CXXBaseSpecifier *VBase = Bases[i];
|
|
|
|
|
if (!VBase->isVirtual())
|
|
|
|
|
continue;
|
2009-07-11 22:32:10 +08:00
|
|
|
int j;
|
|
|
|
|
for (j = 0; j < vbaseCount; ++j)
|
|
|
|
|
if (UniqueVbases[j]->getType() == VBase->getType())
|
2009-07-11 04:13:23 +08:00
|
|
|
break;
|
2009-07-11 22:32:10 +08:00
|
|
|
if (j == vbaseCount) {
|
2009-07-11 04:13:23 +08:00
|
|
|
UniqueVbases.push_back(VBase);
|
|
|
|
|
++vbaseCount;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if (vbaseCount > 0) {
|
|
|
|
|
// build AST for inhireted, direct or indirect, virtual bases.
|
2009-07-23 02:25:24 +08:00
|
|
|
this->VBases = new (C) CXXBaseSpecifier [vbaseCount];
|
2009-07-11 04:13:23 +08:00
|
|
|
this->NumVBases = vbaseCount;
|
|
|
|
|
for (int i = 0; i < vbaseCount; i++) {
|
|
|
|
|
QualType QT = UniqueVbases[i]->getType();
|
|
|
|
|
CXXRecordDecl *VBaseClassDecl
|
2009-07-30 05:53:49 +08:00
|
|
|
= cast<CXXRecordDecl>(QT->getAs<RecordType>()->getDecl());
|
2009-09-09 23:08:12 +08:00
|
|
|
this->VBases[i] =
|
2009-07-23 04:55:49 +08:00
|
|
|
CXXBaseSpecifier(VBaseClassDecl->getSourceRange(), true,
|
|
|
|
|
VBaseClassDecl->getTagKind() == RecordDecl::TK_class,
|
|
|
|
|
UniqueVbases[i]->getAccessSpecifier(), QT);
|
2009-07-11 04:13:23 +08:00
|
|
|
}
|
|
|
|
|
}
|
2008-10-24 02:13:27 +08:00
|
|
|
}
|
|
|
|
|
|
2008-11-04 01:51:48 +08:00
|
|
|
bool CXXRecordDecl::hasConstCopyConstructor(ASTContext &Context) const {
|
2009-09-25 03:53:00 +08:00
|
|
|
return getCopyConstructor(Context, Qualifiers::Const) != 0;
|
2009-06-23 07:34:40 +08:00
|
|
|
}
|
|
|
|
|
|
2009-09-09 23:08:12 +08:00
|
|
|
CXXConstructorDecl *CXXRecordDecl::getCopyConstructor(ASTContext &Context,
|
2009-06-23 07:34:40 +08:00
|
|
|
unsigned TypeQuals) const{
|
2009-01-06 04:52:13 +08:00
|
|
|
QualType ClassType
|
|
|
|
|
= Context.getTypeDeclType(const_cast<CXXRecordDecl*>(this));
|
2009-09-09 23:08:12 +08:00
|
|
|
DeclarationName ConstructorName
|
2008-12-16 05:24:18 +08:00
|
|
|
= Context.DeclarationNames.getCXXConstructorName(
|
2009-06-23 07:34:40 +08:00
|
|
|
Context.getCanonicalType(ClassType));
|
|
|
|
|
unsigned FoundTQs;
|
2008-12-24 05:31:30 +08:00
|
|
|
DeclContext::lookup_const_iterator Con, ConEnd;
|
2009-06-30 10:36:12 +08:00
|
|
|
for (llvm::tie(Con, ConEnd) = this->lookup(ConstructorName);
|
2008-12-24 05:31:30 +08:00
|
|
|
Con != ConEnd; ++Con) {
|
2009-09-04 22:46:39 +08:00
|
|
|
// C++ [class.copy]p2:
|
|
|
|
|
// A non-template constructor for class X is a copy constructor if [...]
|
|
|
|
|
if (isa<FunctionTemplateDecl>(*Con))
|
|
|
|
|
continue;
|
|
|
|
|
|
2009-09-09 23:08:12 +08:00
|
|
|
if (cast<CXXConstructorDecl>(*Con)->isCopyConstructor(Context,
|
2009-06-23 07:34:40 +08:00
|
|
|
FoundTQs)) {
|
2009-09-25 03:53:00 +08:00
|
|
|
if (((TypeQuals & Qualifiers::Const) == (FoundTQs & Qualifiers::Const)) ||
|
|
|
|
|
(!(TypeQuals & Qualifiers::Const) && (FoundTQs & Qualifiers::Const)))
|
2009-06-23 07:34:40 +08:00
|
|
|
return cast<CXXConstructorDecl>(*Con);
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-06-23 07:34:40 +08:00
|
|
|
}
|
2008-11-04 01:51:48 +08:00
|
|
|
}
|
2009-06-23 07:34:40 +08:00
|
|
|
return 0;
|
2008-11-04 01:51:48 +08:00
|
|
|
}
|
|
|
|
|
|
2009-08-13 07:34:46 +08:00
|
|
|
bool CXXRecordDecl::hasConstCopyAssignment(ASTContext &Context,
|
|
|
|
|
const CXXMethodDecl *& MD) const {
|
2009-01-06 04:52:13 +08:00
|
|
|
QualType ClassType = Context.getCanonicalType(Context.getTypeDeclType(
|
|
|
|
|
const_cast<CXXRecordDecl*>(this)));
|
|
|
|
|
DeclarationName OpName =Context.DeclarationNames.getCXXOperatorName(OO_Equal);
|
|
|
|
|
|
|
|
|
|
DeclContext::lookup_const_iterator Op, OpEnd;
|
2009-06-30 10:36:12 +08:00
|
|
|
for (llvm::tie(Op, OpEnd) = this->lookup(OpName);
|
2009-01-06 04:52:13 +08:00
|
|
|
Op != OpEnd; ++Op) {
|
|
|
|
|
// C++ [class.copy]p9:
|
|
|
|
|
// A user-declared copy assignment operator is a non-static non-template
|
|
|
|
|
// member function of class X with exactly one parameter of type X, X&,
|
|
|
|
|
// const X&, volatile X& or const volatile X&.
|
|
|
|
|
const CXXMethodDecl* Method = cast<CXXMethodDecl>(*Op);
|
|
|
|
|
if (Method->isStatic())
|
|
|
|
|
continue;
|
|
|
|
|
// TODO: Skip templates? Or is this implicitly done due to parameter types?
|
2009-02-27 07:50:07 +08:00
|
|
|
const FunctionProtoType *FnType =
|
2009-09-22 07:43:11 +08:00
|
|
|
Method->getType()->getAs<FunctionProtoType>();
|
2009-01-06 04:52:13 +08:00
|
|
|
assert(FnType && "Overloaded operator has no prototype.");
|
|
|
|
|
// Don't assert on this; an invalid decl might have been left in the AST.
|
|
|
|
|
if (FnType->getNumArgs() != 1 || FnType->isVariadic())
|
|
|
|
|
continue;
|
|
|
|
|
bool AcceptsConst = true;
|
|
|
|
|
QualType ArgType = FnType->getArgType(0);
|
2009-07-30 05:53:49 +08:00
|
|
|
if (const LValueReferenceType *Ref = ArgType->getAs<LValueReferenceType>()) {
|
2009-01-06 04:52:13 +08:00
|
|
|
ArgType = Ref->getPointeeType();
|
2009-03-21 04:21:37 +08:00
|
|
|
// Is it a non-const lvalue reference?
|
2009-01-06 04:52:13 +08:00
|
|
|
if (!ArgType.isConstQualified())
|
|
|
|
|
AcceptsConst = false;
|
|
|
|
|
}
|
|
|
|
|
if (Context.getCanonicalType(ArgType).getUnqualifiedType() != ClassType)
|
|
|
|
|
continue;
|
2009-08-13 07:34:46 +08:00
|
|
|
MD = Method;
|
2009-01-06 04:52:13 +08:00
|
|
|
// We have a single argument of type cv X or cv X&, i.e. we've found the
|
|
|
|
|
// copy assignment operator. Return whether it accepts const arguments.
|
|
|
|
|
return AcceptsConst;
|
|
|
|
|
}
|
|
|
|
|
assert(isInvalidDecl() &&
|
|
|
|
|
"No copy assignment operator declared in valid code.");
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
2009-09-09 23:08:12 +08:00
|
|
|
CXXRecordDecl::addedConstructor(ASTContext &Context,
|
2008-12-16 05:24:18 +08:00
|
|
|
CXXConstructorDecl *ConDecl) {
|
2009-06-18 06:44:31 +08:00
|
|
|
assert(!ConDecl->isImplicit() && "addedConstructor - not for implicit decl");
|
|
|
|
|
// Note that we have a user-declared constructor.
|
|
|
|
|
UserDeclaredConstructor = true;
|
|
|
|
|
|
2009-09-09 23:08:12 +08:00
|
|
|
// C++ [dcl.init.aggr]p1:
|
2009-06-18 06:44:31 +08:00
|
|
|
// An aggregate is an array or a class (clause 9) with no
|
|
|
|
|
// user-declared constructors (12.1) [...].
|
|
|
|
|
Aggregate = false;
|
|
|
|
|
|
|
|
|
|
// C++ [class]p4:
|
|
|
|
|
// A POD-struct is an aggregate class [...]
|
|
|
|
|
PlainOldData = false;
|
|
|
|
|
|
|
|
|
|
// C++ [class.ctor]p5:
|
|
|
|
|
// A constructor is trivial if it is an implicitly-declared default
|
|
|
|
|
// constructor.
|
2009-07-23 02:25:24 +08:00
|
|
|
// FIXME: C++0x: don't do this for "= default" default constructors.
|
2009-06-18 06:44:31 +08:00
|
|
|
HasTrivialConstructor = false;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-06-18 06:44:31 +08:00
|
|
|
// Note when we have a user-declared copy constructor, which will
|
|
|
|
|
// suppress the implicit declaration of a copy constructor.
|
2009-07-23 02:25:24 +08:00
|
|
|
if (ConDecl->isCopyConstructor(Context)) {
|
2009-06-18 06:44:31 +08:00
|
|
|
UserDeclaredCopyConstructor = true;
|
2009-07-23 02:25:24 +08:00
|
|
|
|
|
|
|
|
// C++ [class.copy]p6:
|
|
|
|
|
// A copy constructor is trivial if it is implicitly declared.
|
|
|
|
|
// FIXME: C++0x: don't do this for "= default" copy constructors.
|
|
|
|
|
HasTrivialCopyConstructor = false;
|
|
|
|
|
}
|
2008-11-01 04:25:05 +08:00
|
|
|
}
|
|
|
|
|
|
2009-01-06 04:52:13 +08:00
|
|
|
void CXXRecordDecl::addedAssignmentOperator(ASTContext &Context,
|
|
|
|
|
CXXMethodDecl *OpDecl) {
|
|
|
|
|
// We're interested specifically in copy assignment operators.
|
2009-09-22 07:43:11 +08:00
|
|
|
const FunctionProtoType *FnType = OpDecl->getType()->getAs<FunctionProtoType>();
|
2009-01-06 04:52:13 +08:00
|
|
|
assert(FnType && "Overloaded operator has no proto function type.");
|
|
|
|
|
assert(FnType->getNumArgs() == 1 && !FnType->isVariadic());
|
|
|
|
|
QualType ArgType = FnType->getArgType(0);
|
2009-07-30 05:53:49 +08:00
|
|
|
if (const LValueReferenceType *Ref = ArgType->getAs<LValueReferenceType>())
|
2009-01-06 04:52:13 +08:00
|
|
|
ArgType = Ref->getPointeeType();
|
|
|
|
|
|
|
|
|
|
ArgType = ArgType.getUnqualifiedType();
|
|
|
|
|
QualType ClassType = Context.getCanonicalType(Context.getTypeDeclType(
|
|
|
|
|
const_cast<CXXRecordDecl*>(this)));
|
|
|
|
|
|
|
|
|
|
if (ClassType != Context.getCanonicalType(ArgType))
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
// This is a copy assignment operator.
|
|
|
|
|
// Suppress the implicit declaration of a copy constructor.
|
|
|
|
|
UserDeclaredCopyAssignment = true;
|
|
|
|
|
|
2009-07-23 02:25:24 +08:00
|
|
|
// C++ [class.copy]p11:
|
|
|
|
|
// A copy assignment operator is trivial if it is implicitly declared.
|
|
|
|
|
// FIXME: C++0x: don't do this for "= default" copy operators.
|
|
|
|
|
HasTrivialCopyAssignment = false;
|
|
|
|
|
|
2009-01-06 04:52:13 +08:00
|
|
|
// C++ [class]p4:
|
|
|
|
|
// A POD-struct is an aggregate class that [...] has no user-defined copy
|
|
|
|
|
// assignment operator [...].
|
|
|
|
|
PlainOldData = false;
|
|
|
|
|
}
|
|
|
|
|
|
2009-10-08 04:43:36 +08:00
|
|
|
void
|
|
|
|
|
CXXRecordDecl::collectConversionFunctions(
|
|
|
|
|
llvm::SmallPtrSet<QualType, 8>& ConversionsTypeSet) {
|
|
|
|
|
OverloadedFunctionDecl *TopConversions = getConversionFunctions();
|
|
|
|
|
for (OverloadedFunctionDecl::function_iterator
|
|
|
|
|
TFunc = TopConversions->function_begin(),
|
|
|
|
|
TFuncEnd = TopConversions->function_end();
|
|
|
|
|
TFunc != TFuncEnd; ++TFunc) {
|
|
|
|
|
NamedDecl *TopConv = TFunc->get();
|
|
|
|
|
QualType TConvType;
|
|
|
|
|
if (FunctionTemplateDecl *TConversionTemplate =
|
|
|
|
|
dyn_cast<FunctionTemplateDecl>(TopConv))
|
|
|
|
|
TConvType =
|
|
|
|
|
getASTContext().getCanonicalType(
|
|
|
|
|
TConversionTemplate->getTemplatedDecl()->getResultType());
|
|
|
|
|
else
|
|
|
|
|
TConvType =
|
|
|
|
|
getASTContext().getCanonicalType(
|
|
|
|
|
cast<CXXConversionDecl>(TopConv)->getConversionType());
|
|
|
|
|
ConversionsTypeSet.insert(TConvType);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2009-09-13 02:26:03 +08:00
|
|
|
/// getNestedVisibleConversionFunctions - imports unique conversion
|
|
|
|
|
/// functions from base classes into the visible conversion function
|
|
|
|
|
/// list of the class 'RD'. This is a private helper method.
|
2009-10-08 04:43:36 +08:00
|
|
|
/// TopConversionsTypeSet is the set of conversion functions of the class
|
|
|
|
|
/// we are interested in. HiddenConversionTypes is set of conversion functions
|
|
|
|
|
/// of the immediate derived class which hides the conversion functions found
|
|
|
|
|
/// in current class.
|
2009-09-13 02:26:03 +08:00
|
|
|
void
|
2009-10-08 04:43:36 +08:00
|
|
|
CXXRecordDecl::getNestedVisibleConversionFunctions(CXXRecordDecl *RD,
|
|
|
|
|
const llvm::SmallPtrSet<QualType, 8> &TopConversionsTypeSet,
|
|
|
|
|
const llvm::SmallPtrSet<QualType, 8> &HiddenConversionTypes) {
|
|
|
|
|
bool inTopClass = (RD == this);
|
2009-09-13 02:26:03 +08:00
|
|
|
QualType ClassType = getASTContext().getTypeDeclType(this);
|
2009-09-12 05:44:33 +08:00
|
|
|
if (const RecordType *Record = ClassType->getAs<RecordType>()) {
|
|
|
|
|
OverloadedFunctionDecl *Conversions
|
|
|
|
|
= cast<CXXRecordDecl>(Record->getDecl())->getConversionFunctions();
|
2009-09-13 03:52:10 +08:00
|
|
|
|
2009-09-12 05:44:33 +08:00
|
|
|
for (OverloadedFunctionDecl::function_iterator
|
|
|
|
|
Func = Conversions->function_begin(),
|
|
|
|
|
FuncEnd = Conversions->function_end();
|
|
|
|
|
Func != FuncEnd; ++Func) {
|
2009-09-13 02:26:03 +08:00
|
|
|
NamedDecl *Conv = Func->get();
|
2009-09-12 05:44:33 +08:00
|
|
|
// Only those conversions not exact match of conversions in current
|
|
|
|
|
// class are candidateconversion routines.
|
2009-09-13 03:52:10 +08:00
|
|
|
QualType ConvType;
|
|
|
|
|
if (FunctionTemplateDecl *ConversionTemplate =
|
|
|
|
|
dyn_cast<FunctionTemplateDecl>(Conv))
|
|
|
|
|
ConvType =
|
|
|
|
|
getASTContext().getCanonicalType(
|
2009-09-16 07:02:16 +08:00
|
|
|
ConversionTemplate->getTemplatedDecl()->getResultType());
|
2009-09-13 03:52:10 +08:00
|
|
|
else
|
|
|
|
|
ConvType =
|
2009-09-16 06:15:23 +08:00
|
|
|
getASTContext().getCanonicalType(
|
|
|
|
|
cast<CXXConversionDecl>(Conv)->getConversionType());
|
2009-10-08 04:43:36 +08:00
|
|
|
// We only add conversion functions found in the base class if they
|
|
|
|
|
// are not hidden by those found in HiddenConversionTypes which are
|
|
|
|
|
// the conversion functions in its derived class.
|
|
|
|
|
if (inTopClass ||
|
|
|
|
|
(!TopConversionsTypeSet.count(ConvType) &&
|
|
|
|
|
!HiddenConversionTypes.count(ConvType)) ) {
|
2009-09-13 02:26:03 +08:00
|
|
|
if (FunctionTemplateDecl *ConversionTemplate =
|
|
|
|
|
dyn_cast<FunctionTemplateDecl>(Conv))
|
|
|
|
|
RD->addVisibleConversionFunction(ConversionTemplate);
|
|
|
|
|
else
|
|
|
|
|
RD->addVisibleConversionFunction(cast<CXXConversionDecl>(Conv));
|
2009-09-12 05:44:33 +08:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (CXXRecordDecl::base_class_iterator VBase = vbases_begin(),
|
|
|
|
|
E = vbases_end(); VBase != E; ++VBase) {
|
|
|
|
|
CXXRecordDecl *VBaseClassDecl
|
|
|
|
|
= cast<CXXRecordDecl>(VBase->getType()->getAs<RecordType>()->getDecl());
|
2009-10-08 04:43:36 +08:00
|
|
|
if (inTopClass)
|
|
|
|
|
VBaseClassDecl->getNestedVisibleConversionFunctions(RD,
|
|
|
|
|
TopConversionsTypeSet,
|
|
|
|
|
TopConversionsTypeSet);
|
|
|
|
|
else {
|
|
|
|
|
llvm::SmallPtrSet<QualType, 8> HiddenConversionTypes;
|
|
|
|
|
collectConversionFunctions(HiddenConversionTypes);
|
|
|
|
|
VBaseClassDecl->getNestedVisibleConversionFunctions(RD,
|
|
|
|
|
TopConversionsTypeSet,
|
|
|
|
|
HiddenConversionTypes);
|
|
|
|
|
}
|
2009-09-12 05:44:33 +08:00
|
|
|
}
|
|
|
|
|
for (CXXRecordDecl::base_class_iterator Base = bases_begin(),
|
|
|
|
|
E = bases_end(); Base != E; ++Base) {
|
|
|
|
|
if (Base->isVirtual())
|
|
|
|
|
continue;
|
|
|
|
|
CXXRecordDecl *BaseClassDecl
|
|
|
|
|
= cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
|
2009-10-08 04:43:36 +08:00
|
|
|
if (inTopClass)
|
|
|
|
|
BaseClassDecl->getNestedVisibleConversionFunctions(RD,
|
|
|
|
|
TopConversionsTypeSet,
|
|
|
|
|
TopConversionsTypeSet);
|
|
|
|
|
else {
|
|
|
|
|
llvm::SmallPtrSet<QualType, 8> HiddenConversionTypes;
|
|
|
|
|
collectConversionFunctions(HiddenConversionTypes);
|
|
|
|
|
BaseClassDecl->getNestedVisibleConversionFunctions(RD,
|
|
|
|
|
TopConversionsTypeSet,
|
|
|
|
|
HiddenConversionTypes);
|
|
|
|
|
}
|
2009-09-12 05:44:33 +08:00
|
|
|
}
|
2009-09-13 02:26:03 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// getVisibleConversionFunctions - get all conversion functions visible
|
|
|
|
|
/// in current class; including conversion function templates.
|
|
|
|
|
OverloadedFunctionDecl *
|
|
|
|
|
CXXRecordDecl::getVisibleConversionFunctions() {
|
|
|
|
|
// If root class, all conversions are visible.
|
|
|
|
|
if (bases_begin() == bases_end())
|
|
|
|
|
return &Conversions;
|
|
|
|
|
// If visible conversion list is already evaluated, return it.
|
|
|
|
|
if (ComputedVisibleConversions)
|
|
|
|
|
return &VisibleConversions;
|
2009-10-08 04:43:36 +08:00
|
|
|
llvm::SmallPtrSet<QualType, 8> TopConversionsTypeSet;
|
|
|
|
|
collectConversionFunctions(TopConversionsTypeSet);
|
|
|
|
|
getNestedVisibleConversionFunctions(this, TopConversionsTypeSet,
|
|
|
|
|
TopConversionsTypeSet);
|
2009-09-13 02:26:03 +08:00
|
|
|
ComputedVisibleConversions = true;
|
2009-09-12 05:44:33 +08:00
|
|
|
return &VisibleConversions;
|
|
|
|
|
}
|
|
|
|
|
|
2009-09-13 02:26:03 +08:00
|
|
|
void CXXRecordDecl::addVisibleConversionFunction(
|
2009-09-12 05:44:33 +08:00
|
|
|
CXXConversionDecl *ConvDecl) {
|
|
|
|
|
assert(!ConvDecl->getDescribedFunctionTemplate() &&
|
|
|
|
|
"Conversion function templates should cast to FunctionTemplateDecl.");
|
|
|
|
|
VisibleConversions.addOverload(ConvDecl);
|
|
|
|
|
}
|
|
|
|
|
|
2009-09-13 02:26:03 +08:00
|
|
|
void CXXRecordDecl::addVisibleConversionFunction(
|
2009-09-12 05:44:33 +08:00
|
|
|
FunctionTemplateDecl *ConvDecl) {
|
|
|
|
|
assert(isa<CXXConversionDecl>(ConvDecl->getTemplatedDecl()) &&
|
|
|
|
|
"Function template is not a conversion function template");
|
|
|
|
|
VisibleConversions.addOverload(ConvDecl);
|
|
|
|
|
}
|
|
|
|
|
|
2009-09-13 03:02:34 +08:00
|
|
|
void CXXRecordDecl::addConversionFunction(CXXConversionDecl *ConvDecl) {
|
2009-08-22 07:19:43 +08:00
|
|
|
assert(!ConvDecl->getDescribedFunctionTemplate() &&
|
|
|
|
|
"Conversion function templates should cast to FunctionTemplateDecl.");
|
2008-11-08 04:08:42 +08:00
|
|
|
Conversions.addOverload(ConvDecl);
|
|
|
|
|
}
|
|
|
|
|
|
2009-09-13 03:02:34 +08:00
|
|
|
void CXXRecordDecl::addConversionFunction(FunctionTemplateDecl *ConvDecl) {
|
2009-08-22 07:19:43 +08:00
|
|
|
assert(isa<CXXConversionDecl>(ConvDecl->getTemplatedDecl()) &&
|
|
|
|
|
"Function template is not a conversion function template");
|
|
|
|
|
Conversions.addOverload(ConvDecl);
|
|
|
|
|
}
|
2009-06-20 03:55:27 +08:00
|
|
|
|
|
|
|
|
CXXConstructorDecl *
|
|
|
|
|
CXXRecordDecl::getDefaultConstructor(ASTContext &Context) {
|
|
|
|
|
QualType ClassType = Context.getTypeDeclType(this);
|
|
|
|
|
DeclarationName ConstructorName
|
|
|
|
|
= Context.DeclarationNames.getCXXConstructorName(
|
|
|
|
|
Context.getCanonicalType(ClassType.getUnqualifiedType()));
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-06-20 03:55:27 +08:00
|
|
|
DeclContext::lookup_const_iterator Con, ConEnd;
|
2009-06-30 10:36:12 +08:00
|
|
|
for (llvm::tie(Con, ConEnd) = lookup(ConstructorName);
|
2009-06-20 03:55:27 +08:00
|
|
|
Con != ConEnd; ++Con) {
|
2009-09-04 22:46:39 +08:00
|
|
|
// FIXME: In C++0x, a constructor template can be a default constructor.
|
|
|
|
|
if (isa<FunctionTemplateDecl>(*Con))
|
|
|
|
|
continue;
|
|
|
|
|
|
2009-06-20 03:55:27 +08:00
|
|
|
CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(*Con);
|
|
|
|
|
if (Constructor->isDefaultConstructor())
|
|
|
|
|
return Constructor;
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2009-05-30 05:03:38 +08:00
|
|
|
const CXXDestructorDecl *
|
|
|
|
|
CXXRecordDecl::getDestructor(ASTContext &Context) {
|
|
|
|
|
QualType ClassType = Context.getTypeDeclType(this);
|
2009-09-09 23:08:12 +08:00
|
|
|
|
|
|
|
|
DeclarationName Name
|
2009-08-05 13:36:45 +08:00
|
|
|
= Context.DeclarationNames.getCXXDestructorName(
|
|
|
|
|
Context.getCanonicalType(ClassType));
|
2009-05-30 05:03:38 +08:00
|
|
|
|
|
|
|
|
DeclContext::lookup_iterator I, E;
|
2009-09-09 23:08:12 +08:00
|
|
|
llvm::tie(I, E) = lookup(Name);
|
2009-05-30 05:03:38 +08:00
|
|
|
assert(I != E && "Did not find a destructor!");
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-05-30 05:03:38 +08:00
|
|
|
const CXXDestructorDecl *Dtor = cast<CXXDestructorDecl>(*I);
|
|
|
|
|
assert(++I == E && "Found more than one destructor!");
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-05-30 05:03:38 +08:00
|
|
|
return Dtor;
|
|
|
|
|
}
|
|
|
|
|
|
Change struct forward declarations and definitions to use unique RecordDecls, as opposed to creating a single RecordDecl and reusing it.
This change effects both RecordDecls and CXXRecordDecls, but does not effect EnumDecls (yet).
The motivation of this patch is as follows:
- Capture more source information, necessary for refactoring/rewriting clients.
- Pave the way to resolve ownership issues with RecordDecls with the forthcoming
addition of DeclGroups.
Current caveats:
- Until DeclGroups are in place, we will leak RecordDecls not explicitly
referenced by the AST. For example:
typedef struct { ... } x;
The RecordDecl for the struct will be leaked because the TypedefDecl doesn't
refer to it. This will be solved with DeclGroups.
- This patch also (temporarily) breaks CodeGen. More below.
High-level changes:
- As before, TagType still refers to a TagDecl, but it doesn't own it. When
a struct/union/class is first referenced, a RecordType and RecordDecl are
created for it, and the RecordType refers to that RecordDecl. Later, if
a new RecordDecl is created, the pointer to a RecordDecl in RecordType is
updated to point to the RecordDecl that defines the struct/union/class.
- TagDecl and RecordDecl now how a method 'getDefinition()' to return the
TagDecl*/RecordDecl* that refers to the TagDecl* that defines a particular
enum/struct/class/union. This is useful from going from a RecordDecl* that
defines a forward declaration to the RecordDecl* that provides the actual
definition. Note that this also works for EnumDecls, except that in this case
there is no distinction between forward declarations and definitions (yet).
- Clients should no longer assume that 'isDefinition()' returns true from a
RecordDecl if the corresponding struct/union/class has been defined.
isDefinition() only returns true if a particular RecordDecl is the defining
Decl. Use 'getDefinition()' instead to determine if a struct has been defined.
- The main changes to Sema happen in ActOnTag. To make the changes more
incremental, I split off the processing of enums and structs et al into two
code paths. Enums use the original code path (which is in ActOnTag) and
structs use the ActOnTagStruct. Eventually the two code paths will be merged,
but the idea was to preserve the original logic both for comparison and not to
change the logic for both enums and structs all at once.
- There is NO CHAINING of RecordDecls for the same RecordType. All RecordDecls
that correspond to the same type simply have a pointer to that type. If we
need to figure out what are all the RecordDecls for a given type we can build
a backmap.
- The diff in CXXRecordDecl.[cpp,h] is actually very small; it just mimics the
changes to RecordDecl. For some reason 'svn' marks the entire file as changed.
Why is CodeGen broken:
- Codegen assumes that there is an equivalence between RecordDecl* and
RecordType*. This was true before because we only created one RecordDecl* for
a given RecordType*, but it is no longer true. I believe this shouldn't be too
hard to change, but the patch was big enough as it is.
I have tested this patch on both the clang test suite, and by running the static analyzer over Postgresql and a large Apple-internal project (mix of Objective-C and C).
llvm-svn: 55839
2008-09-06 01:16:31 +08:00
|
|
|
CXXMethodDecl *
|
|
|
|
|
CXXMethodDecl::Create(ASTContext &C, CXXRecordDecl *RD,
|
2008-11-18 06:58:34 +08:00
|
|
|
SourceLocation L, DeclarationName N,
|
2009-08-19 09:27:57 +08:00
|
|
|
QualType T, DeclaratorInfo *DInfo,
|
|
|
|
|
bool isStatic, bool isInline) {
|
|
|
|
|
return new (C) CXXMethodDecl(CXXMethod, RD, L, N, T, DInfo,
|
|
|
|
|
isStatic, isInline);
|
Change struct forward declarations and definitions to use unique RecordDecls, as opposed to creating a single RecordDecl and reusing it.
This change effects both RecordDecls and CXXRecordDecls, but does not effect EnumDecls (yet).
The motivation of this patch is as follows:
- Capture more source information, necessary for refactoring/rewriting clients.
- Pave the way to resolve ownership issues with RecordDecls with the forthcoming
addition of DeclGroups.
Current caveats:
- Until DeclGroups are in place, we will leak RecordDecls not explicitly
referenced by the AST. For example:
typedef struct { ... } x;
The RecordDecl for the struct will be leaked because the TypedefDecl doesn't
refer to it. This will be solved with DeclGroups.
- This patch also (temporarily) breaks CodeGen. More below.
High-level changes:
- As before, TagType still refers to a TagDecl, but it doesn't own it. When
a struct/union/class is first referenced, a RecordType and RecordDecl are
created for it, and the RecordType refers to that RecordDecl. Later, if
a new RecordDecl is created, the pointer to a RecordDecl in RecordType is
updated to point to the RecordDecl that defines the struct/union/class.
- TagDecl and RecordDecl now how a method 'getDefinition()' to return the
TagDecl*/RecordDecl* that refers to the TagDecl* that defines a particular
enum/struct/class/union. This is useful from going from a RecordDecl* that
defines a forward declaration to the RecordDecl* that provides the actual
definition. Note that this also works for EnumDecls, except that in this case
there is no distinction between forward declarations and definitions (yet).
- Clients should no longer assume that 'isDefinition()' returns true from a
RecordDecl if the corresponding struct/union/class has been defined.
isDefinition() only returns true if a particular RecordDecl is the defining
Decl. Use 'getDefinition()' instead to determine if a struct has been defined.
- The main changes to Sema happen in ActOnTag. To make the changes more
incremental, I split off the processing of enums and structs et al into two
code paths. Enums use the original code path (which is in ActOnTag) and
structs use the ActOnTagStruct. Eventually the two code paths will be merged,
but the idea was to preserve the original logic both for comparison and not to
change the logic for both enums and structs all at once.
- There is NO CHAINING of RecordDecls for the same RecordType. All RecordDecls
that correspond to the same type simply have a pointer to that type. If we
need to figure out what are all the RecordDecls for a given type we can build
a backmap.
- The diff in CXXRecordDecl.[cpp,h] is actually very small; it just mimics the
changes to RecordDecl. For some reason 'svn' marks the entire file as changed.
Why is CodeGen broken:
- Codegen assumes that there is an equivalence between RecordDecl* and
RecordType*. This was true before because we only created one RecordDecl* for
a given RecordType*, but it is no longer true. I believe this shouldn't be too
hard to change, but the patch was big enough as it is.
I have tested this patch on both the clang test suite, and by running the static analyzer over Postgresql and a large Apple-internal project (mix of Objective-C and C).
llvm-svn: 55839
2008-09-06 01:16:31 +08:00
|
|
|
}
|
|
|
|
|
|
2009-09-30 02:16:17 +08:00
|
|
|
bool CXXMethodDecl::isUsualDeallocationFunction() const {
|
|
|
|
|
if (getOverloadedOperator() != OO_Delete &&
|
|
|
|
|
getOverloadedOperator() != OO_Array_Delete)
|
|
|
|
|
return false;
|
|
|
|
|
|
|
|
|
|
// C++ [basic.stc.dynamic.deallocation]p2:
|
|
|
|
|
// If a class T has a member deallocation function named operator delete
|
|
|
|
|
// with exactly one parameter, then that function is a usual (non-placement)
|
|
|
|
|
// deallocation function. [...]
|
|
|
|
|
if (getNumParams() == 1)
|
|
|
|
|
return true;
|
|
|
|
|
|
|
|
|
|
// C++ [basic.stc.dynamic.deallocation]p2:
|
|
|
|
|
// [...] If class T does not declare such an operator delete but does
|
|
|
|
|
// declare a member deallocation function named operator delete with
|
|
|
|
|
// exactly two parameters, the second of which has type std::size_t (18.1),
|
|
|
|
|
// then this function is a usual deallocation function.
|
|
|
|
|
ASTContext &Context = getASTContext();
|
|
|
|
|
if (getNumParams() != 2 ||
|
|
|
|
|
!Context.hasSameType(getParamDecl(1)->getType(), Context.getSizeType()))
|
|
|
|
|
return false;
|
|
|
|
|
|
|
|
|
|
// This function is a usual deallocation function if there are no
|
|
|
|
|
// single-parameter deallocation functions of the same kind.
|
|
|
|
|
for (DeclContext::lookup_const_result R = getDeclContext()->lookup(getDeclName());
|
|
|
|
|
R.first != R.second; ++R.first) {
|
|
|
|
|
if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(*R.first))
|
|
|
|
|
if (FD->getNumParams() == 1)
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
2009-09-09 23:08:12 +08:00
|
|
|
typedef llvm::DenseMap<const CXXMethodDecl*,
|
|
|
|
|
std::vector<const CXXMethodDecl *> *>
|
2009-05-17 07:58:37 +08:00
|
|
|
OverriddenMethodsMapTy;
|
|
|
|
|
|
2009-08-21 09:45:00 +08:00
|
|
|
// FIXME: We hate static data. This doesn't survive PCH saving/loading, and
|
|
|
|
|
// the vtable building code uses it at CG time.
|
2009-05-17 07:58:37 +08:00
|
|
|
static OverriddenMethodsMapTy *OverriddenMethods = 0;
|
|
|
|
|
|
|
|
|
|
void CXXMethodDecl::addOverriddenMethod(const CXXMethodDecl *MD) {
|
|
|
|
|
// FIXME: The CXXMethodDecl dtor needs to remove and free the entry.
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-05-17 07:58:37 +08:00
|
|
|
if (!OverriddenMethods)
|
|
|
|
|
OverriddenMethods = new OverriddenMethodsMapTy();
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-05-17 07:58:37 +08:00
|
|
|
std::vector<const CXXMethodDecl *> *&Methods = (*OverriddenMethods)[this];
|
|
|
|
|
if (!Methods)
|
|
|
|
|
Methods = new std::vector<const CXXMethodDecl *>;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-05-17 07:58:37 +08:00
|
|
|
Methods->push_back(MD);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
CXXMethodDecl::method_iterator CXXMethodDecl::begin_overridden_methods() const {
|
|
|
|
|
if (!OverriddenMethods)
|
|
|
|
|
return 0;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-05-17 07:58:37 +08:00
|
|
|
OverriddenMethodsMapTy::iterator it = OverriddenMethods->find(this);
|
2009-08-02 07:40:20 +08:00
|
|
|
if (it == OverriddenMethods->end() || it->second->empty())
|
2009-05-17 07:58:37 +08:00
|
|
|
return 0;
|
2009-08-02 07:40:20 +08:00
|
|
|
|
2009-05-17 07:58:37 +08:00
|
|
|
return &(*it->second)[0];
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
CXXMethodDecl::method_iterator CXXMethodDecl::end_overridden_methods() const {
|
|
|
|
|
if (!OverriddenMethods)
|
|
|
|
|
return 0;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-05-17 07:58:37 +08:00
|
|
|
OverriddenMethodsMapTy::iterator it = OverriddenMethods->find(this);
|
2009-08-02 07:40:20 +08:00
|
|
|
if (it == OverriddenMethods->end() || it->second->empty())
|
2009-05-17 07:58:37 +08:00
|
|
|
return 0;
|
|
|
|
|
|
2009-08-02 09:48:29 +08:00
|
|
|
return &(*it->second)[0] + it->second->size();
|
2009-05-17 07:58:37 +08:00
|
|
|
}
|
|
|
|
|
|
Change struct forward declarations and definitions to use unique RecordDecls, as opposed to creating a single RecordDecl and reusing it.
This change effects both RecordDecls and CXXRecordDecls, but does not effect EnumDecls (yet).
The motivation of this patch is as follows:
- Capture more source information, necessary for refactoring/rewriting clients.
- Pave the way to resolve ownership issues with RecordDecls with the forthcoming
addition of DeclGroups.
Current caveats:
- Until DeclGroups are in place, we will leak RecordDecls not explicitly
referenced by the AST. For example:
typedef struct { ... } x;
The RecordDecl for the struct will be leaked because the TypedefDecl doesn't
refer to it. This will be solved with DeclGroups.
- This patch also (temporarily) breaks CodeGen. More below.
High-level changes:
- As before, TagType still refers to a TagDecl, but it doesn't own it. When
a struct/union/class is first referenced, a RecordType and RecordDecl are
created for it, and the RecordType refers to that RecordDecl. Later, if
a new RecordDecl is created, the pointer to a RecordDecl in RecordType is
updated to point to the RecordDecl that defines the struct/union/class.
- TagDecl and RecordDecl now how a method 'getDefinition()' to return the
TagDecl*/RecordDecl* that refers to the TagDecl* that defines a particular
enum/struct/class/union. This is useful from going from a RecordDecl* that
defines a forward declaration to the RecordDecl* that provides the actual
definition. Note that this also works for EnumDecls, except that in this case
there is no distinction between forward declarations and definitions (yet).
- Clients should no longer assume that 'isDefinition()' returns true from a
RecordDecl if the corresponding struct/union/class has been defined.
isDefinition() only returns true if a particular RecordDecl is the defining
Decl. Use 'getDefinition()' instead to determine if a struct has been defined.
- The main changes to Sema happen in ActOnTag. To make the changes more
incremental, I split off the processing of enums and structs et al into two
code paths. Enums use the original code path (which is in ActOnTag) and
structs use the ActOnTagStruct. Eventually the two code paths will be merged,
but the idea was to preserve the original logic both for comparison and not to
change the logic for both enums and structs all at once.
- There is NO CHAINING of RecordDecls for the same RecordType. All RecordDecls
that correspond to the same type simply have a pointer to that type. If we
need to figure out what are all the RecordDecls for a given type we can build
a backmap.
- The diff in CXXRecordDecl.[cpp,h] is actually very small; it just mimics the
changes to RecordDecl. For some reason 'svn' marks the entire file as changed.
Why is CodeGen broken:
- Codegen assumes that there is an equivalence between RecordDecl* and
RecordType*. This was true before because we only created one RecordDecl* for
a given RecordType*, but it is no longer true. I believe this shouldn't be too
hard to change, but the patch was big enough as it is.
I have tested this patch on both the clang test suite, and by running the static analyzer over Postgresql and a large Apple-internal project (mix of Objective-C and C).
llvm-svn: 55839
2008-09-06 01:16:31 +08:00
|
|
|
QualType CXXMethodDecl::getThisType(ASTContext &C) const {
|
2008-10-25 06:28:18 +08:00
|
|
|
// C++ 9.3.2p1: The type of this in a member function of a class X is X*.
|
|
|
|
|
// If the member function is declared const, the type of this is const X*,
|
|
|
|
|
// if the member function is declared volatile, the type of this is
|
|
|
|
|
// volatile X*, and if the member function is declared const volatile,
|
|
|
|
|
// the type of this is const volatile X*.
|
|
|
|
|
|
Change struct forward declarations and definitions to use unique RecordDecls, as opposed to creating a single RecordDecl and reusing it.
This change effects both RecordDecls and CXXRecordDecls, but does not effect EnumDecls (yet).
The motivation of this patch is as follows:
- Capture more source information, necessary for refactoring/rewriting clients.
- Pave the way to resolve ownership issues with RecordDecls with the forthcoming
addition of DeclGroups.
Current caveats:
- Until DeclGroups are in place, we will leak RecordDecls not explicitly
referenced by the AST. For example:
typedef struct { ... } x;
The RecordDecl for the struct will be leaked because the TypedefDecl doesn't
refer to it. This will be solved with DeclGroups.
- This patch also (temporarily) breaks CodeGen. More below.
High-level changes:
- As before, TagType still refers to a TagDecl, but it doesn't own it. When
a struct/union/class is first referenced, a RecordType and RecordDecl are
created for it, and the RecordType refers to that RecordDecl. Later, if
a new RecordDecl is created, the pointer to a RecordDecl in RecordType is
updated to point to the RecordDecl that defines the struct/union/class.
- TagDecl and RecordDecl now how a method 'getDefinition()' to return the
TagDecl*/RecordDecl* that refers to the TagDecl* that defines a particular
enum/struct/class/union. This is useful from going from a RecordDecl* that
defines a forward declaration to the RecordDecl* that provides the actual
definition. Note that this also works for EnumDecls, except that in this case
there is no distinction between forward declarations and definitions (yet).
- Clients should no longer assume that 'isDefinition()' returns true from a
RecordDecl if the corresponding struct/union/class has been defined.
isDefinition() only returns true if a particular RecordDecl is the defining
Decl. Use 'getDefinition()' instead to determine if a struct has been defined.
- The main changes to Sema happen in ActOnTag. To make the changes more
incremental, I split off the processing of enums and structs et al into two
code paths. Enums use the original code path (which is in ActOnTag) and
structs use the ActOnTagStruct. Eventually the two code paths will be merged,
but the idea was to preserve the original logic both for comparison and not to
change the logic for both enums and structs all at once.
- There is NO CHAINING of RecordDecls for the same RecordType. All RecordDecls
that correspond to the same type simply have a pointer to that type. If we
need to figure out what are all the RecordDecls for a given type we can build
a backmap.
- The diff in CXXRecordDecl.[cpp,h] is actually very small; it just mimics the
changes to RecordDecl. For some reason 'svn' marks the entire file as changed.
Why is CodeGen broken:
- Codegen assumes that there is an equivalence between RecordDecl* and
RecordType*. This was true before because we only created one RecordDecl* for
a given RecordType*, but it is no longer true. I believe this shouldn't be too
hard to change, but the patch was big enough as it is.
I have tested this patch on both the clang test suite, and by running the static analyzer over Postgresql and a large Apple-internal project (mix of Objective-C and C).
llvm-svn: 55839
2008-09-06 01:16:31 +08:00
|
|
|
assert(isInstance() && "No 'this' for static methods!");
|
2009-06-13 10:59:33 +08:00
|
|
|
|
|
|
|
|
QualType ClassTy;
|
|
|
|
|
if (ClassTemplateDecl *TD = getParent()->getDescribedClassTemplate())
|
|
|
|
|
ClassTy = TD->getInjectedClassNameType(C);
|
|
|
|
|
else
|
2009-08-08 02:05:12 +08:00
|
|
|
ClassTy = C.getTagDeclType(getParent());
|
2009-09-25 03:53:00 +08:00
|
|
|
ClassTy = C.getQualifiedType(ClassTy,
|
|
|
|
|
Qualifiers::fromCVRMask(getTypeQualifiers()));
|
2009-07-11 05:35:09 +08:00
|
|
|
return C.getPointerType(ClassTy);
|
Change struct forward declarations and definitions to use unique RecordDecls, as opposed to creating a single RecordDecl and reusing it.
This change effects both RecordDecls and CXXRecordDecls, but does not effect EnumDecls (yet).
The motivation of this patch is as follows:
- Capture more source information, necessary for refactoring/rewriting clients.
- Pave the way to resolve ownership issues with RecordDecls with the forthcoming
addition of DeclGroups.
Current caveats:
- Until DeclGroups are in place, we will leak RecordDecls not explicitly
referenced by the AST. For example:
typedef struct { ... } x;
The RecordDecl for the struct will be leaked because the TypedefDecl doesn't
refer to it. This will be solved with DeclGroups.
- This patch also (temporarily) breaks CodeGen. More below.
High-level changes:
- As before, TagType still refers to a TagDecl, but it doesn't own it. When
a struct/union/class is first referenced, a RecordType and RecordDecl are
created for it, and the RecordType refers to that RecordDecl. Later, if
a new RecordDecl is created, the pointer to a RecordDecl in RecordType is
updated to point to the RecordDecl that defines the struct/union/class.
- TagDecl and RecordDecl now how a method 'getDefinition()' to return the
TagDecl*/RecordDecl* that refers to the TagDecl* that defines a particular
enum/struct/class/union. This is useful from going from a RecordDecl* that
defines a forward declaration to the RecordDecl* that provides the actual
definition. Note that this also works for EnumDecls, except that in this case
there is no distinction between forward declarations and definitions (yet).
- Clients should no longer assume that 'isDefinition()' returns true from a
RecordDecl if the corresponding struct/union/class has been defined.
isDefinition() only returns true if a particular RecordDecl is the defining
Decl. Use 'getDefinition()' instead to determine if a struct has been defined.
- The main changes to Sema happen in ActOnTag. To make the changes more
incremental, I split off the processing of enums and structs et al into two
code paths. Enums use the original code path (which is in ActOnTag) and
structs use the ActOnTagStruct. Eventually the two code paths will be merged,
but the idea was to preserve the original logic both for comparison and not to
change the logic for both enums and structs all at once.
- There is NO CHAINING of RecordDecls for the same RecordType. All RecordDecls
that correspond to the same type simply have a pointer to that type. If we
need to figure out what are all the RecordDecls for a given type we can build
a backmap.
- The diff in CXXRecordDecl.[cpp,h] is actually very small; it just mimics the
changes to RecordDecl. For some reason 'svn' marks the entire file as changed.
Why is CodeGen broken:
- Codegen assumes that there is an equivalence between RecordDecl* and
RecordType*. This was true before because we only created one RecordDecl* for
a given RecordType*, but it is no longer true. I believe this shouldn't be too
hard to change, but the patch was big enough as it is.
I have tested this patch on both the clang test suite, and by running the static analyzer over Postgresql and a large Apple-internal project (mix of Objective-C and C).
llvm-svn: 55839
2008-09-06 01:16:31 +08:00
|
|
|
}
|
|
|
|
|
|
2008-11-05 12:29:56 +08:00
|
|
|
CXXBaseOrMemberInitializer::
|
2009-06-30 08:02:17 +08:00
|
|
|
CXXBaseOrMemberInitializer(QualType BaseType, Expr **Args, unsigned NumArgs,
|
2009-07-23 08:42:24 +08:00
|
|
|
CXXConstructorDecl *C,
|
2009-09-09 23:08:12 +08:00
|
|
|
SourceLocation L, SourceLocation R)
|
2009-09-02 05:04:42 +08:00
|
|
|
: Args(0), NumArgs(0), CtorOrAnonUnion(), IdLoc(L), RParenLoc(R) {
|
2008-11-05 12:29:56 +08:00
|
|
|
BaseOrMember = reinterpret_cast<uintptr_t>(BaseType.getTypePtr());
|
|
|
|
|
assert((BaseOrMember & 0x01) == 0 && "Invalid base class type pointer");
|
|
|
|
|
BaseOrMember |= 0x01;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2008-11-05 12:29:56 +08:00
|
|
|
if (NumArgs > 0) {
|
|
|
|
|
this->NumArgs = NumArgs;
|
2009-07-25 01:57:02 +08:00
|
|
|
// FIXME. Allocation via Context
|
|
|
|
|
this->Args = new Stmt*[NumArgs];
|
2008-11-05 12:29:56 +08:00
|
|
|
for (unsigned Idx = 0; Idx < NumArgs; ++Idx)
|
|
|
|
|
this->Args[Idx] = Args[Idx];
|
|
|
|
|
}
|
2009-09-02 05:04:42 +08:00
|
|
|
CtorOrAnonUnion = C;
|
2008-11-05 12:29:56 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
CXXBaseOrMemberInitializer::
|
2009-06-30 08:02:17 +08:00
|
|
|
CXXBaseOrMemberInitializer(FieldDecl *Member, Expr **Args, unsigned NumArgs,
|
2009-07-23 08:42:24 +08:00
|
|
|
CXXConstructorDecl *C,
|
2009-08-29 09:31:33 +08:00
|
|
|
SourceLocation L, SourceLocation R)
|
2009-09-02 05:04:42 +08:00
|
|
|
: Args(0), NumArgs(0), CtorOrAnonUnion(), IdLoc(L), RParenLoc(R) {
|
2008-11-05 12:29:56 +08:00
|
|
|
BaseOrMember = reinterpret_cast<uintptr_t>(Member);
|
2009-09-09 23:08:12 +08:00
|
|
|
assert((BaseOrMember & 0x01) == 0 && "Invalid member pointer");
|
2008-11-05 12:29:56 +08:00
|
|
|
|
|
|
|
|
if (NumArgs > 0) {
|
|
|
|
|
this->NumArgs = NumArgs;
|
2009-07-25 01:57:02 +08:00
|
|
|
this->Args = new Stmt*[NumArgs];
|
2008-11-05 12:29:56 +08:00
|
|
|
for (unsigned Idx = 0; Idx < NumArgs; ++Idx)
|
|
|
|
|
this->Args[Idx] = Args[Idx];
|
|
|
|
|
}
|
2009-09-02 05:04:42 +08:00
|
|
|
CtorOrAnonUnion = C;
|
2008-11-05 12:29:56 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
CXXBaseOrMemberInitializer::~CXXBaseOrMemberInitializer() {
|
|
|
|
|
delete [] Args;
|
|
|
|
|
}
|
|
|
|
|
|
2008-10-31 17:07:45 +08:00
|
|
|
CXXConstructorDecl *
|
|
|
|
|
CXXConstructorDecl::Create(ASTContext &C, CXXRecordDecl *RD,
|
2008-11-17 22:58:09 +08:00
|
|
|
SourceLocation L, DeclarationName N,
|
2009-08-19 09:27:57 +08:00
|
|
|
QualType T, DeclaratorInfo *DInfo,
|
|
|
|
|
bool isExplicit,
|
2008-10-31 17:07:45 +08:00
|
|
|
bool isInline, bool isImplicitlyDeclared) {
|
2008-11-17 22:58:09 +08:00
|
|
|
assert(N.getNameKind() == DeclarationName::CXXConstructorName &&
|
|
|
|
|
"Name must refer to a constructor");
|
2009-08-19 09:27:57 +08:00
|
|
|
return new (C) CXXConstructorDecl(RD, L, N, T, DInfo, isExplicit, isInline,
|
2008-10-31 17:07:45 +08:00
|
|
|
isImplicitlyDeclared);
|
|
|
|
|
}
|
|
|
|
|
|
2008-11-01 04:25:05 +08:00
|
|
|
bool CXXConstructorDecl::isDefaultConstructor() const {
|
|
|
|
|
// C++ [class.ctor]p5:
|
2008-11-06 00:20:31 +08:00
|
|
|
// A default constructor for a class X is a constructor of class
|
|
|
|
|
// X that can be called without an argument.
|
2008-11-01 04:25:05 +08:00
|
|
|
return (getNumParams() == 0) ||
|
2009-08-25 13:12:04 +08:00
|
|
|
(getNumParams() > 0 && getParamDecl(0)->hasDefaultArg());
|
2008-11-01 04:25:05 +08:00
|
|
|
}
|
|
|
|
|
|
2009-09-09 23:08:12 +08:00
|
|
|
bool
|
|
|
|
|
CXXConstructorDecl::isCopyConstructor(ASTContext &Context,
|
2008-11-01 04:25:05 +08:00
|
|
|
unsigned &TypeQuals) const {
|
|
|
|
|
// C++ [class.copy]p2:
|
2008-11-06 00:20:31 +08:00
|
|
|
// A non-template constructor for class X is a copy constructor
|
|
|
|
|
// if its first parameter is of type X&, const X&, volatile X& or
|
|
|
|
|
// const volatile X&, and either there are no other parameters
|
|
|
|
|
// or else all other parameters have default arguments (8.3.6).
|
2008-11-01 04:25:05 +08:00
|
|
|
if ((getNumParams() < 1) ||
|
2009-06-06 12:14:07 +08:00
|
|
|
(getNumParams() > 1 && !getParamDecl(1)->hasDefaultArg()))
|
2008-11-01 04:25:05 +08:00
|
|
|
return false;
|
|
|
|
|
|
|
|
|
|
const ParmVarDecl *Param = getParamDecl(0);
|
|
|
|
|
|
2009-03-17 07:22:08 +08:00
|
|
|
// Do we have a reference type? Rvalue references don't count.
|
|
|
|
|
const LValueReferenceType *ParamRefType =
|
2009-07-30 05:53:49 +08:00
|
|
|
Param->getType()->getAs<LValueReferenceType>();
|
2008-11-01 04:25:05 +08:00
|
|
|
if (!ParamRefType)
|
|
|
|
|
return false;
|
|
|
|
|
|
|
|
|
|
// Is it a reference to our class type?
|
2009-09-16 04:50:23 +08:00
|
|
|
CanQualType PointeeType
|
2008-11-01 04:25:05 +08:00
|
|
|
= Context.getCanonicalType(ParamRefType->getPointeeType());
|
2009-09-16 04:50:23 +08:00
|
|
|
CanQualType ClassTy
|
|
|
|
|
= Context.getCanonicalType(Context.getTagDeclType(getParent()));
|
2008-11-01 04:25:05 +08:00
|
|
|
if (PointeeType.getUnqualifiedType() != ClassTy)
|
|
|
|
|
return false;
|
|
|
|
|
|
2009-09-25 03:53:00 +08:00
|
|
|
// FIXME: other qualifiers?
|
|
|
|
|
|
2008-11-01 04:25:05 +08:00
|
|
|
// We have a copy constructor.
|
|
|
|
|
TypeQuals = PointeeType.getCVRQualifiers();
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
2009-08-29 00:57:08 +08:00
|
|
|
bool CXXConstructorDecl::isConvertingConstructor(bool AllowExplicit) const {
|
2008-11-01 00:23:19 +08:00
|
|
|
// C++ [class.conv.ctor]p1:
|
|
|
|
|
// A constructor declared without the function-specifier explicit
|
|
|
|
|
// that can be called with a single parameter specifies a
|
|
|
|
|
// conversion from the type of its first parameter to the type of
|
|
|
|
|
// its class. Such a constructor is called a converting
|
|
|
|
|
// constructor.
|
2009-08-29 00:57:08 +08:00
|
|
|
if (isExplicit() && !AllowExplicit)
|
2008-11-01 00:23:19 +08:00
|
|
|
return false;
|
|
|
|
|
|
2009-09-09 23:08:12 +08:00
|
|
|
return (getNumParams() == 0 &&
|
2009-09-22 07:43:11 +08:00
|
|
|
getType()->getAs<FunctionProtoType>()->isVariadic()) ||
|
2008-11-01 00:23:19 +08:00
|
|
|
(getNumParams() == 1) ||
|
2009-06-06 12:14:07 +08:00
|
|
|
(getNumParams() > 1 && getParamDecl(1)->hasDefaultArg());
|
2008-11-01 00:23:19 +08:00
|
|
|
}
|
2008-10-31 17:07:45 +08:00
|
|
|
|
2008-11-06 04:51:48 +08:00
|
|
|
CXXDestructorDecl *
|
|
|
|
|
CXXDestructorDecl::Create(ASTContext &C, CXXRecordDecl *RD,
|
2008-11-17 22:58:09 +08:00
|
|
|
SourceLocation L, DeclarationName N,
|
2009-09-09 23:08:12 +08:00
|
|
|
QualType T, bool isInline,
|
2008-11-06 04:51:48 +08:00
|
|
|
bool isImplicitlyDeclared) {
|
2008-11-17 22:58:09 +08:00
|
|
|
assert(N.getNameKind() == DeclarationName::CXXDestructorName &&
|
|
|
|
|
"Name must refer to a destructor");
|
2009-09-09 23:08:12 +08:00
|
|
|
return new (C) CXXDestructorDecl(RD, L, N, T, isInline,
|
2009-01-28 05:25:57 +08:00
|
|
|
isImplicitlyDeclared);
|
2008-11-06 04:51:48 +08:00
|
|
|
}
|
|
|
|
|
|
2009-07-16 06:34:08 +08:00
|
|
|
void
|
2009-07-22 06:36:06 +08:00
|
|
|
CXXDestructorDecl::Destroy(ASTContext& C) {
|
|
|
|
|
C.Deallocate(BaseOrMemberDestructions);
|
|
|
|
|
CXXMethodDecl::Destroy(C);
|
|
|
|
|
}
|
|
|
|
|
|
2009-07-02 07:35:25 +08:00
|
|
|
void
|
|
|
|
|
CXXConstructorDecl::Destroy(ASTContext& C) {
|
|
|
|
|
C.Deallocate(BaseOrMemberInitializers);
|
2009-07-08 00:24:08 +08:00
|
|
|
CXXMethodDecl::Destroy(C);
|
2009-07-02 07:35:25 +08:00
|
|
|
}
|
|
|
|
|
|
2008-11-08 04:08:42 +08:00
|
|
|
CXXConversionDecl *
|
|
|
|
|
CXXConversionDecl::Create(ASTContext &C, CXXRecordDecl *RD,
|
2008-11-17 22:58:09 +08:00
|
|
|
SourceLocation L, DeclarationName N,
|
2009-08-19 09:27:57 +08:00
|
|
|
QualType T, DeclaratorInfo *DInfo,
|
|
|
|
|
bool isInline, bool isExplicit) {
|
2008-11-17 22:58:09 +08:00
|
|
|
assert(N.getNameKind() == DeclarationName::CXXConversionFunctionName &&
|
|
|
|
|
"Name must refer to a conversion function");
|
2009-08-19 09:27:57 +08:00
|
|
|
return new (C) CXXConversionDecl(RD, L, N, T, DInfo, isInline, isExplicit);
|
2008-11-08 04:08:42 +08:00
|
|
|
}
|
|
|
|
|
|
2008-10-22 00:13:35 +08:00
|
|
|
OverloadedFunctionDecl *
|
|
|
|
|
OverloadedFunctionDecl::Create(ASTContext &C, DeclContext *DC,
|
2008-11-17 22:58:09 +08:00
|
|
|
DeclarationName N) {
|
2009-01-28 05:25:57 +08:00
|
|
|
return new (C) OverloadedFunctionDecl(DC, N);
|
2008-10-22 00:13:35 +08:00
|
|
|
}
|
2008-11-05 00:51:42 +08:00
|
|
|
|
2009-08-22 02:42:58 +08:00
|
|
|
OverloadIterator::OverloadIterator(NamedDecl *ND) : D(0) {
|
|
|
|
|
if (!ND)
|
|
|
|
|
return;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-08-22 02:42:58 +08:00
|
|
|
if (isa<FunctionDecl>(ND) || isa<FunctionTemplateDecl>(ND))
|
|
|
|
|
D = ND;
|
|
|
|
|
else if (OverloadedFunctionDecl *Ovl = dyn_cast<OverloadedFunctionDecl>(ND)) {
|
2009-09-02 00:58:52 +08:00
|
|
|
if (Ovl->size() != 0) {
|
|
|
|
|
D = ND;
|
|
|
|
|
Iter = Ovl->function_begin();
|
|
|
|
|
}
|
2009-08-22 02:42:58 +08:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2009-06-28 05:05:07 +08:00
|
|
|
void OverloadedFunctionDecl::addOverload(AnyFunctionDecl F) {
|
|
|
|
|
Functions.push_back(F);
|
|
|
|
|
this->setLocation(F.get()->getLocation());
|
2009-06-26 06:08:12 +08:00
|
|
|
}
|
|
|
|
|
|
2009-07-08 18:57:20 +08:00
|
|
|
OverloadIterator::reference OverloadIterator::operator*() const {
|
|
|
|
|
if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
|
|
|
|
|
return FD;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-07-08 18:57:20 +08:00
|
|
|
if (FunctionTemplateDecl *FTD = dyn_cast<FunctionTemplateDecl>(D))
|
|
|
|
|
return FTD;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-07-08 18:57:20 +08:00
|
|
|
assert(isa<OverloadedFunctionDecl>(D));
|
|
|
|
|
return *Iter;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
OverloadIterator &OverloadIterator::operator++() {
|
|
|
|
|
if (isa<FunctionDecl>(D) || isa<FunctionTemplateDecl>(D)) {
|
|
|
|
|
D = 0;
|
|
|
|
|
return *this;
|
|
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-07-08 18:57:20 +08:00
|
|
|
if (++Iter == cast<OverloadedFunctionDecl>(D)->function_end())
|
|
|
|
|
D = 0;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-07-08 18:57:20 +08:00
|
|
|
return *this;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool OverloadIterator::Equals(const OverloadIterator &Other) const {
|
|
|
|
|
if (!D || !Other.D)
|
|
|
|
|
return D == Other.D;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-07-08 18:57:20 +08:00
|
|
|
if (D != Other.D)
|
|
|
|
|
return false;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-07-08 18:57:20 +08:00
|
|
|
return !isa<OverloadedFunctionDecl>(D) || Iter == Other.Iter;
|
|
|
|
|
}
|
|
|
|
|
|
2009-08-28 15:59:38 +08:00
|
|
|
FriendDecl *FriendDecl::Create(ASTContext &C, DeclContext *DC,
|
|
|
|
|
SourceLocation L,
|
|
|
|
|
FriendUnion Friend,
|
|
|
|
|
SourceLocation FriendL) {
|
2009-09-01 03:16:38 +08:00
|
|
|
#ifndef NDEBUG
|
2009-08-28 15:59:38 +08:00
|
|
|
if (Friend.is<NamedDecl*>()) {
|
|
|
|
|
NamedDecl *D = Friend.get<NamedDecl*>();
|
|
|
|
|
assert(isa<FunctionDecl>(D) ||
|
|
|
|
|
isa<CXXRecordDecl>(D) ||
|
|
|
|
|
isa<FunctionTemplateDecl>(D) ||
|
|
|
|
|
isa<ClassTemplateDecl>(D));
|
|
|
|
|
assert(D->getFriendObjectKind());
|
|
|
|
|
}
|
2009-09-01 03:16:38 +08:00
|
|
|
#endif
|
2009-08-12 05:13:21 +08:00
|
|
|
|
2009-08-28 15:59:38 +08:00
|
|
|
return new (C) FriendDecl(DC, L, Friend, FriendL);
|
2009-09-09 23:08:12 +08:00
|
|
|
}
|
2009-08-11 14:59:38 +08:00
|
|
|
|
2008-11-05 00:51:42 +08:00
|
|
|
LinkageSpecDecl *LinkageSpecDecl::Create(ASTContext &C,
|
2009-09-09 23:08:12 +08:00
|
|
|
DeclContext *DC,
|
2008-11-05 00:51:42 +08:00
|
|
|
SourceLocation L,
|
2009-01-06 03:45:36 +08:00
|
|
|
LanguageIDs Lang, bool Braces) {
|
2009-01-28 05:25:57 +08:00
|
|
|
return new (C) LinkageSpecDecl(DC, L, Lang, Braces);
|
2008-12-17 06:23:02 +08:00
|
|
|
}
|
2009-02-04 03:21:40 +08:00
|
|
|
|
|
|
|
|
UsingDirectiveDecl *UsingDirectiveDecl::Create(ASTContext &C, DeclContext *DC,
|
|
|
|
|
SourceLocation L,
|
|
|
|
|
SourceLocation NamespaceLoc,
|
2009-05-30 14:31:56 +08:00
|
|
|
SourceRange QualifierRange,
|
|
|
|
|
NestedNameSpecifier *Qualifier,
|
2009-02-04 03:21:40 +08:00
|
|
|
SourceLocation IdentLoc,
|
|
|
|
|
NamespaceDecl *Used,
|
|
|
|
|
DeclContext *CommonAncestor) {
|
2009-09-09 23:08:12 +08:00
|
|
|
return new (C) UsingDirectiveDecl(DC, L, NamespaceLoc, QualifierRange,
|
2009-05-30 14:31:56 +08:00
|
|
|
Qualifier, IdentLoc, Used, CommonAncestor);
|
2009-02-04 03:21:40 +08:00
|
|
|
}
|
|
|
|
|
|
2009-09-09 23:08:12 +08:00
|
|
|
NamespaceAliasDecl *NamespaceAliasDecl::Create(ASTContext &C, DeclContext *DC,
|
|
|
|
|
SourceLocation L,
|
|
|
|
|
SourceLocation AliasLoc,
|
|
|
|
|
IdentifierInfo *Alias,
|
2009-05-30 14:48:27 +08:00
|
|
|
SourceRange QualifierRange,
|
|
|
|
|
NestedNameSpecifier *Qualifier,
|
2009-09-09 23:08:12 +08:00
|
|
|
SourceLocation IdentLoc,
|
2009-03-29 06:58:02 +08:00
|
|
|
NamedDecl *Namespace) {
|
2009-09-09 23:08:12 +08:00
|
|
|
return new (C) NamespaceAliasDecl(DC, L, AliasLoc, Alias, QualifierRange,
|
2009-05-30 14:48:27 +08:00
|
|
|
Qualifier, IdentLoc, Namespace);
|
2009-03-29 06:58:02 +08:00
|
|
|
}
|
|
|
|
|
|
2009-06-20 08:51:54 +08:00
|
|
|
UsingDecl *UsingDecl::Create(ASTContext &C, DeclContext *DC,
|
|
|
|
|
SourceLocation L, SourceRange NNR, SourceLocation TargetNL,
|
|
|
|
|
SourceLocation UL, NamedDecl* Target,
|
|
|
|
|
NestedNameSpecifier* TargetNNS, bool IsTypeNameArg) {
|
|
|
|
|
return new (C) UsingDecl(DC, L, NNR, TargetNL, UL, Target,
|
|
|
|
|
TargetNNS, IsTypeNameArg);
|
|
|
|
|
}
|
|
|
|
|
|
2009-08-28 13:30:28 +08:00
|
|
|
UnresolvedUsingDecl *UnresolvedUsingDecl::Create(ASTContext &C, DeclContext *DC,
|
|
|
|
|
SourceLocation UsingLoc,
|
|
|
|
|
SourceRange TargetNNR,
|
|
|
|
|
NestedNameSpecifier *TargetNNS,
|
|
|
|
|
SourceLocation TargetNameLoc,
|
|
|
|
|
DeclarationName TargetName,
|
|
|
|
|
bool IsTypeNameArg) {
|
|
|
|
|
return new (C) UnresolvedUsingDecl(DC, UsingLoc, TargetNNR, TargetNNS,
|
|
|
|
|
TargetNameLoc, TargetName, IsTypeNameArg);
|
|
|
|
|
}
|
|
|
|
|
|
2009-03-14 08:25:26 +08:00
|
|
|
StaticAssertDecl *StaticAssertDecl::Create(ASTContext &C, DeclContext *DC,
|
|
|
|
|
SourceLocation L, Expr *AssertExpr,
|
|
|
|
|
StringLiteral *Message) {
|
|
|
|
|
return new (C) StaticAssertDecl(DC, L, AssertExpr, Message);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void StaticAssertDecl::Destroy(ASTContext& C) {
|
|
|
|
|
AssertExpr->Destroy(C);
|
|
|
|
|
Message->Destroy(C);
|
|
|
|
|
this->~StaticAssertDecl();
|
|
|
|
|
C.Deallocate((void *)this);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
StaticAssertDecl::~StaticAssertDecl() {
|
|
|
|
|
}
|
|
|
|
|
|
2009-03-27 07:46:50 +08:00
|
|
|
static const char *getAccessName(AccessSpecifier AS) {
|
|
|
|
|
switch (AS) {
|
|
|
|
|
default:
|
|
|
|
|
case AS_none:
|
|
|
|
|
assert("Invalid access specifier!");
|
|
|
|
|
return 0;
|
|
|
|
|
case AS_public:
|
|
|
|
|
return "public";
|
|
|
|
|
case AS_private:
|
|
|
|
|
return "private";
|
|
|
|
|
case AS_protected:
|
|
|
|
|
return "protected";
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const DiagnosticBuilder &clang::operator<<(const DiagnosticBuilder &DB,
|
|
|
|
|
AccessSpecifier AS) {
|
|
|
|
|
return DB << getAccessName(AS);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|