Make sure to use RequireCompleteType rather than testing for
incomplete types. RequireCompleteType is needed when the type may be
completed by instantiating a template.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@67643 91177308-0d34-0410-b5e6-96231b3b80d8
diff --git a/lib/Sema/SemaDecl.cpp b/lib/Sema/SemaDecl.cpp
index a3b6004..b76126a 100644
--- a/lib/Sema/SemaDecl.cpp
+++ b/lib/Sema/SemaDecl.cpp
@@ -881,6 +881,8 @@
// C99 6.7.5.3p4: the parameters in a parameter type list in a
// function declarator that is part of a function definition of
// that function shall not have incomplete type.
+ //
+ // This is also C++ [dcl.fct]p6.
if (!Param->isInvalidDecl() &&
RequireCompleteType(Param->getLocation(), Param->getType(),
diag::err_typecheck_decl_incomplete_type)) {
@@ -2723,12 +2725,12 @@
}
// The return type of a function definition must be complete
- // (C99 6.9.1p3)
- if (FD->getResultType()->isIncompleteType() &&
- !FD->getResultType()->isVoidType()) {
- Diag(FD->getLocation(), diag::err_func_def_incomplete_result) << FD;
+ // (C99 6.9.1p3, C++ [dcl.fct]p6).
+ QualType ResultType = FD->getResultType();
+ if (!ResultType->isDependentType() && !ResultType->isVoidType() &&
+ RequireCompleteType(FD->getLocation(), ResultType,
+ diag::err_func_def_incomplete_result))
FD->setInvalidDecl();
- }
PushDeclContext(FnBodyScope, FD);
@@ -3726,33 +3728,27 @@
if (FD->isInvalidDecl())
continue;
- // C99 6.7.2.1p2 - A field may not be a function type.
+ // C99 6.7.2.1p2:
+ // A structure or union shall not contain a member with
+ // incomplete or function type (hence, a structure shall not
+ // contain an instance of itself, but may contain a pointer to
+ // an instance of itself), except that the last member of a
+ // structure with more than one named member may have incomplete
+ // array type; such a structure (and any union containing,
+ // possibly recursively, a member that is such a structure)
+ // shall not be a member of a structure or an element of an
+ // array.
if (FDTy->isFunctionType()) {
+ // Field declared as a function.
Diag(FD->getLocation(), diag::err_field_declared_as_function)
<< FD->getDeclName();
FD->setInvalidDecl();
EnclosingDecl->setInvalidDecl();
continue;
- }
- // C99 6.7.2.1p2 - A field may not be an incomplete type except...
- if (FDTy->isIncompleteType()) {
- if (!Record) { // Incomplete ivar type is always an error.
- RequireCompleteType(FD->getLocation(), FD->getType(),
- diag::err_field_incomplete);
- FD->setInvalidDecl();
- EnclosingDecl->setInvalidDecl();
- continue;
- }
- if (i != NumFields-1 || // ... that the last member ...
- !Record->isStruct() || // ... of a structure ...
- !FDTy->isArrayType()) { //... may have incomplete array type.
- RequireCompleteType(FD->getLocation(), FD->getType(),
- diag::err_field_incomplete);
- FD->setInvalidDecl();
- EnclosingDecl->setInvalidDecl();
- continue;
- }
- if (NumNamedMembers < 1) { //... must have more than named member ...
+ } else if (FDTy->isIncompleteArrayType() && i == NumFields - 1 &&
+ Record && Record->isStruct()) {
+ // Flexible array member.
+ if (NumNamedMembers < 1) {
Diag(FD->getLocation(), diag::err_flexible_array_empty_struct)
<< FD->getDeclName();
FD->setInvalidDecl();
@@ -3762,10 +3758,14 @@
// Okay, we have a legal flexible array member at the end of the struct.
if (Record)
Record->setHasFlexibleArrayMember(true);
- }
- /// C99 6.7.2.1p2 - a struct ending in a flexible array member cannot be the
- /// field of another structure or the element of an array.
- if (const RecordType *FDTTy = FDTy->getAsRecordType()) {
+ } else if (!FDTy->isDependentType() &&
+ RequireCompleteType(FD->getLocation(), FD->getType(),
+ diag::err_field_incomplete)) {
+ // Incomplete type
+ FD->setInvalidDecl();
+ EnclosingDecl->setInvalidDecl();
+ continue;
+ } else if (const RecordType *FDTTy = FDTy->getAsRecordType()) {
if (FDTTy->getDecl()->hasFlexibleArrayMember()) {
// If this is a member of a union, then entire union becomes "flexible".
if (Record && Record->isUnion()) {
@@ -3787,9 +3787,8 @@
}
}
}
- }
- /// A field cannot be an Objective-c object
- if (FDTy->isObjCInterfaceType()) {
+ } else if (FDTy->isObjCInterfaceType()) {
+ /// A field cannot be an Objective-c object
Diag(FD->getLocation(), diag::err_statically_allocated_object);
FD->setInvalidDecl();
EnclosingDecl->setInvalidDecl();
diff --git a/lib/Sema/SemaExpr.cpp b/lib/Sema/SemaExpr.cpp
index 2732a54..03d8501 100644
--- a/lib/Sema/SemaExpr.cpp
+++ b/lib/Sema/SemaExpr.cpp
@@ -1593,14 +1593,20 @@
return ExprError(Diag(IndexExpr->getLocStart(),
diag::err_typecheck_subscript) << IndexExpr->getSourceRange());
- // C99 6.5.2.1p1: "shall have type "pointer to *object* type". In practice,
- // the following check catches trying to index a pointer to a function (e.g.
- // void (*)(int)) and pointers to incomplete types. Functions are not
- // objects in C99.
- if (!ResultType->isObjectType() && !ResultType->isDependentType())
- return ExprError(Diag(BaseExpr->getLocStart(),
- diag::err_typecheck_subscript_not_object)
- << BaseExpr->getType() << BaseExpr->getSourceRange());
+ // C99 6.5.2.1p1: "shall have type "pointer to *object* type". Similarly,
+ // C++ [expr.sub]p1: The type "T" shall be a completely-defined object
+ // type. Note that Functions are not objects, and that (in C99 parlance)
+ // incomplete types are not object types.
+ if (ResultType->isFunctionType()) {
+ Diag(BaseExpr->getLocStart(), diag::err_subscript_function_type)
+ << ResultType << BaseExpr->getSourceRange();
+ return ExprError();
+ }
+ if (!ResultType->isDependentType() &&
+ RequireCompleteType(BaseExpr->getLocStart(), ResultType,
+ diag::err_subscript_incomplete_type,
+ BaseExpr->getSourceRange()))
+ return ExprError();
Base.release();
Idx.release();
@@ -3155,35 +3161,33 @@
if (const PointerType* PTy = PExp->getType()->getAsPointerType()) {
if (IExp->getType()->isIntegerType()) {
// Check for arithmetic on pointers to incomplete types
- if (!PTy->getPointeeType()->isObjectType()) {
- if (PTy->getPointeeType()->isVoidType()) {
- if (getLangOptions().CPlusPlus) {
- Diag(Loc, diag::err_typecheck_pointer_arith_void_type)
- << lex->getSourceRange() << rex->getSourceRange();
- return QualType();
- }
-
- // GNU extension: arithmetic on pointer to void
- Diag(Loc, diag::ext_gnu_void_ptr)
+ if (PTy->getPointeeType()->isVoidType()) {
+ if (getLangOptions().CPlusPlus) {
+ Diag(Loc, diag::err_typecheck_pointer_arith_void_type)
<< lex->getSourceRange() << rex->getSourceRange();
- } else if (PTy->getPointeeType()->isFunctionType()) {
- if (getLangOptions().CPlusPlus) {
- Diag(Loc, diag::err_typecheck_pointer_arith_function_type)
- << lex->getType() << lex->getSourceRange();
- return QualType();
- }
-
- // GNU extension: arithmetic on pointer to function
- Diag(Loc, diag::ext_gnu_ptr_func_arith)
- << lex->getType() << lex->getSourceRange();
- } else {
- RequireCompleteType(Loc, PTy->getPointeeType(),
- diag::err_typecheck_arithmetic_incomplete_type,
- lex->getSourceRange(), SourceRange(),
- lex->getType());
return QualType();
}
- }
+
+ // GNU extension: arithmetic on pointer to void
+ Diag(Loc, diag::ext_gnu_void_ptr)
+ << lex->getSourceRange() << rex->getSourceRange();
+ } else if (PTy->getPointeeType()->isFunctionType()) {
+ if (getLangOptions().CPlusPlus) {
+ Diag(Loc, diag::err_typecheck_pointer_arith_function_type)
+ << lex->getType() << lex->getSourceRange();
+ return QualType();
+ }
+
+ // GNU extension: arithmetic on pointer to function
+ Diag(Loc, diag::ext_gnu_ptr_func_arith)
+ << lex->getType() << lex->getSourceRange();
+ } else if (!PTy->isDependentType() &&
+ RequireCompleteType(Loc, PTy->getPointeeType(),
+ diag::err_typecheck_arithmetic_incomplete_type,
+ lex->getSourceRange(), SourceRange(),
+ lex->getType()))
+ return QualType();
+
return PExp->getType();
}
}
@@ -3209,61 +3213,80 @@
if (const PointerType *LHSPTy = lex->getType()->getAsPointerType()) {
QualType lpointee = LHSPTy->getPointeeType();
- // The LHS must be an object type, not incomplete, function, etc.
- if (!lpointee->isObjectType()) {
- // Handle the GNU void* extension.
- if (lpointee->isVoidType()) {
- Diag(Loc, diag::ext_gnu_void_ptr)
- << lex->getSourceRange() << rex->getSourceRange();
- } else if (lpointee->isFunctionType()) {
- if (getLangOptions().CPlusPlus) {
- Diag(Loc, diag::err_typecheck_pointer_arith_function_type)
- << lex->getType() << lex->getSourceRange();
- return QualType();
- }
+ // The LHS must be an completely-defined object type.
- // GNU extension: arithmetic on pointer to function
- Diag(Loc, diag::ext_gnu_ptr_func_arith)
- << lex->getType() << lex->getSourceRange();
- } else {
- Diag(Loc, diag::err_typecheck_sub_ptr_object)
+ bool ComplainAboutVoid = false;
+ Expr *ComplainAboutFunc = 0;
+ if (lpointee->isVoidType()) {
+ if (getLangOptions().CPlusPlus) {
+ Diag(Loc, diag::err_typecheck_pointer_arith_void_type)
+ << lex->getSourceRange() << rex->getSourceRange();
+ return QualType();
+ }
+
+ // GNU C extension: arithmetic on pointer to void
+ ComplainAboutVoid = true;
+ } else if (lpointee->isFunctionType()) {
+ if (getLangOptions().CPlusPlus) {
+ Diag(Loc, diag::err_typecheck_pointer_arith_function_type)
<< lex->getType() << lex->getSourceRange();
return QualType();
}
- }
+
+ // GNU C extension: arithmetic on pointer to function
+ ComplainAboutFunc = lex;
+ } else if (!lpointee->isDependentType() &&
+ RequireCompleteType(Loc, lpointee,
+ diag::err_typecheck_sub_ptr_object,
+ lex->getSourceRange(),
+ SourceRange(),
+ lex->getType()))
+ return QualType();
// The result type of a pointer-int computation is the pointer type.
- if (rex->getType()->isIntegerType())
+ if (rex->getType()->isIntegerType()) {
+ if (ComplainAboutVoid)
+ Diag(Loc, diag::ext_gnu_void_ptr)
+ << lex->getSourceRange() << rex->getSourceRange();
+ if (ComplainAboutFunc)
+ Diag(Loc, diag::ext_gnu_ptr_func_arith)
+ << ComplainAboutFunc->getType()
+ << ComplainAboutFunc->getSourceRange();
+
return lex->getType();
+ }
// Handle pointer-pointer subtractions.
if (const PointerType *RHSPTy = rex->getType()->getAsPointerType()) {
QualType rpointee = RHSPTy->getPointeeType();
- // RHS must be an object type, unless void (GNU).
- if (!rpointee->isObjectType()) {
- // Handle the GNU void* extension.
- if (rpointee->isVoidType()) {
- if (!lpointee->isVoidType())
- Diag(Loc, diag::ext_gnu_void_ptr)
- << lex->getSourceRange() << rex->getSourceRange();
- } else if (rpointee->isFunctionType()) {
- if (getLangOptions().CPlusPlus) {
- Diag(Loc, diag::err_typecheck_pointer_arith_function_type)
- << rex->getType() << rex->getSourceRange();
- return QualType();
- }
+ // RHS must be a completely-type object type.
+ // Handle the GNU void* extension.
+ if (rpointee->isVoidType()) {
+ if (getLangOptions().CPlusPlus) {
+ Diag(Loc, diag::err_typecheck_pointer_arith_void_type)
+ << lex->getSourceRange() << rex->getSourceRange();
+ return QualType();
+ }
- // GNU extension: arithmetic on pointer to function
- if (!lpointee->isFunctionType())
- Diag(Loc, diag::ext_gnu_ptr_func_arith)
- << lex->getType() << lex->getSourceRange();
- } else {
- Diag(Loc, diag::err_typecheck_sub_ptr_object)
+ ComplainAboutVoid = true;
+ } else if (rpointee->isFunctionType()) {
+ if (getLangOptions().CPlusPlus) {
+ Diag(Loc, diag::err_typecheck_pointer_arith_function_type)
<< rex->getType() << rex->getSourceRange();
return QualType();
}
- }
+
+ // GNU extension: arithmetic on pointer to function
+ if (!ComplainAboutFunc)
+ ComplainAboutFunc = rex;
+ } else if (!rpointee->isDependentType() &&
+ RequireCompleteType(Loc, rpointee,
+ diag::err_typecheck_sub_ptr_object,
+ rex->getSourceRange(),
+ SourceRange(),
+ rex->getType()))
+ return QualType();
// Pointee types must be compatible.
if (!Context.typesAreCompatible(
@@ -3275,6 +3298,14 @@
return QualType();
}
+ if (ComplainAboutVoid)
+ Diag(Loc, diag::ext_gnu_void_ptr)
+ << lex->getSourceRange() << rex->getSourceRange();
+ if (ComplainAboutFunc)
+ Diag(Loc, diag::ext_gnu_ptr_func_arith)
+ << ComplainAboutFunc->getType()
+ << ComplainAboutFunc->getSourceRange();
+
return Context.getPointerDiffType();
}
}
diff --git a/lib/Sema/SemaExprCXX.cpp b/lib/Sema/SemaExprCXX.cpp
index 2abf87b..e2cda9d 100644
--- a/lib/Sema/SemaExprCXX.cpp
+++ b/lib/Sema/SemaExprCXX.cpp
@@ -242,10 +242,6 @@
if (CheckAllocatedType(AllocType, D))
return ExprError();
- if (RequireNonAbstractType(D.getSourceRange().getBegin(), AllocType,
- diag::err_allocation_of_abstract_type))
- return ExprError();
-
QualType ResultType = AllocType->isDependentType()
? Context.DependentTy
: Context.getPointerType(AllocType);
@@ -364,23 +360,20 @@
{
// C++ 5.3.4p1: "[The] type shall be a complete object type, but not an
// abstract class type or array thereof.
- // FIXME: We don't have abstract types yet.
- // FIXME: Under C++ semantics, an incomplete object type is still an object
- // type. This code assumes the C semantics, where it's not.
- if (!AllocType->isObjectType()) {
- unsigned type; // For the select in the message.
- if (AllocType->isFunctionType()) {
- type = 0;
- } else if(AllocType->isIncompleteType()) {
- type = 1;
- } else {
- assert(AllocType->isReferenceType() && "Unhandled non-object type.");
- type = 2;
- }
- Diag(D.getSourceRange().getBegin(), diag::err_bad_new_type)
- << AllocType << type << D.getSourceRange();
+ if (AllocType->isFunctionType())
+ return Diag(D.getSourceRange().getBegin(), diag::err_bad_new_type)
+ << AllocType << 0 << D.getSourceRange();
+ else if (AllocType->isReferenceType())
+ return Diag(D.getSourceRange().getBegin(), diag::err_bad_new_type)
+ << AllocType << 1 << D.getSourceRange();
+ else if (!AllocType->isDependentType() &&
+ RequireCompleteType(D.getSourceRange().getBegin(), AllocType,
+ diag::err_new_incomplete_type,
+ D.getSourceRange()))
return true;
- }
+ else if (RequireNonAbstractType(D.getSourceRange().getBegin(), AllocType,
+ diag::err_allocation_of_abstract_type))
+ return true;
// Every dimension shall be of constant size.
unsigned i = 1;
@@ -943,11 +936,15 @@
// class type) [...]
QualType RType = rex->getType();
const MemberPointerType *MemPtr = RType->getAsMemberPointerType();
- if (!MemPtr || MemPtr->getClass()->isIncompleteType()) {
+ if (!MemPtr) {
Diag(Loc, diag::err_bad_memptr_rhs)
<< OpSpelling << RType << rex->getSourceRange();
return QualType();
- }
+ } else if (RequireCompleteType(Loc, QualType(MemPtr->getClass(), 0),
+ diag::err_memptr_rhs_incomplete,
+ rex->getSourceRange()))
+ return QualType();
+
QualType Class(MemPtr->getClass(), 0);
// C++ 5.5p2