mirrors/llvm-project
0
0
Fork 0
mirror of https://github.com/llvm/llvm-project.git synced 2025-04-29 10:26:06 +00:00
Code Issues Projects Releases Wiki Activity

It's an error to try to allocate an abstract object using new.

Browse Source 
llvm-svn: 67542
This commit is contained in:
Anders Carlsson 2009-03-23 17:49:10 +00:00
parent 893c2c963a
commit 0d5ca29b78
6 changed files with 21 additions and 6 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
clang/include/clang/Basic/DiagnosticSemaKinds.td
View File

@ -220,7 +220,9 @@ def err_static_assert_expression_is_not_constant : Error<
def err_static_assert_failed : Error<"static_assert failed \"%0\"">;
def err_abstract_type_in_decl : Error<
"%select{return|parameter|variable|field}0 type %1 is an abstract class">;
"%select{return|parameter|variable|field}1 type %0 is an abstract class">;
def err_allocation_of_abstract_type : Error<
"allocation of an object of abstract type %0">;
def note_pure_virtual_function : Note<
"pure virtual function %0">;

3
clang/lib/Sema/Sema.h
View File

@ -1634,7 +1634,8 @@ public:
SourceLocation Loc, SourceRange Range);
std::string getAmbiguousPathsDisplayString(BasePaths &Paths);
bool RequireNonAbstractType(SourceLocation Loc, QualType T, unsigned SelID);
bool RequireNonAbstractType(SourceLocation Loc, QualType T,
unsigned DiagID, unsigned SelID);
//===--------------------------------------------------------------------===//
// C++ Overloaded Operators [C++ 13.5]

9
clang/lib/Sema/SemaDecl.cpp
View File

@ -1641,7 +1641,9 @@ Sema::ActOnVariableDeclarator(Scope* S, Declarator& D, DeclContext* DC,
}
// The variable can not have an abstract class type.
if (RequireNonAbstractType(D.getIdentifierLoc(), R, 2 /* variable type */))
if (RequireNonAbstractType(D.getIdentifierLoc(), R,
diag::err_abstract_type_in_decl,
2 /* variable type */))
InvalidDecl = true;
// The variable can not
@ -1815,6 +1817,7 @@ Sema::ActOnFunctionDeclarator(Scope* S, Declarator& D, DeclContext* DC,
// Check that the return type is not an abstract class type.
if (RequireNonAbstractType(D.getIdentifierLoc(),
R->getAsFunctionType()->getResultType(),
diag::err_abstract_type_in_decl,
0 /* return type */))
InvalidDecl = true;
@ -1996,6 +1999,7 @@ Sema::ActOnFunctionDeclarator(Scope* S, Declarator& D, DeclContext* DC,
// Function parameters cannot have abstract class types.
if (RequireNonAbstractType(PVD->getLocation(), PVD->getType(),
diag::err_abstract_type_in_decl,
1 /* parameter type */))
InvalidDecl = true;
Params.push_back(PVD);
@ -3534,7 +3538,8 @@ FieldDecl *Sema::CheckFieldDecl(DeclarationName Name, QualType T,
}
// Fields can not have abstract class types
if (RequireNonAbstractType(Loc, T, 3 /* field type */))
if (RequireNonAbstractType(Loc, T, diag::err_abstract_type_in_decl,
3 /* field type */))
InvalidDecl = true;
// If this is declared as a bit-field, check the bit-field.

4
clang/lib/Sema/SemaDeclCXX.cpp
View File

@ -784,7 +784,7 @@ namespace {
}
bool Sema::RequireNonAbstractType(SourceLocation Loc, QualType T,
unsigned SelID) {
unsigned DiagID, unsigned SelID) {
if (!getLangOptions().CPlusPlus)
return false;
@ -800,7 +800,7 @@ bool Sema::RequireNonAbstractType(SourceLocation Loc, QualType T,
if (!RD->isAbstract())
return false;
Diag(Loc, diag::err_abstract_type_in_decl) << SelID << RD->getDeclName();
Diag(Loc, DiagID) << RD->getDeclName() << SelID;
// Check if we've already emitted the list of pure virtual functions for this
// class.

4
clang/lib/Sema/SemaExprCXX.cpp
View File

@ -238,6 +238,10 @@ Sema::ActOnCXXNew(SourceLocation StartLoc, bool UseGlobal,
if (CheckAllocatedType(AllocType, D))
return ExprError();
if (RequireNonAbstractType(D.getSourceRange().getBegin(), AllocType,
diag::err_allocation_of_abstract_type, 0))
return ExprError();
QualType ResultType = AllocType->isDependentType()
? Context.DependentTy
: Context.getPointerType(AllocType);

3
clang/test/SemaCXX/abstract.cpp
View File

@ -25,6 +25,8 @@ class E : D {
static_assert(!__is_abstract(E), "E inherits from an abstract class but implements f");
C *d = new C; // expected-error {{allocation of an object of abstract type 'C'}}
C c; // expected-error {{variable type 'C' is an abstract class}}
void t1(C c); // expected-error {{parameter type 'C' is an abstract class}}
void t2(C); // expected-error {{parameter type 'C' is an abstract class}}
@ -32,3 +34,4 @@ void t2(C); // expected-error {{parameter type 'C' is an abstract class}}
struct S {
C c; // expected-error {{field type 'C' is an abstract class}}
};