EricWF updated this revision to Diff 93709.
EricWF added a comment.
- Update the doc to reflect that GCC has implemented this trait (and to assume
MS will as well).
- Rewrite the tests using static_assert over god-awful old style array asserts.
https://reviews.llvm.org/D31513
Files:
docs/LanguageExtensions.rst
include/clang/Basic/TokenKinds.def
include/clang/Basic/TypeTraits.h
lib/Parse/ParseDeclCXX.cpp
lib/Parse/ParseExpr.cpp
lib/Sema/SemaExprCXX.cpp
test/PCH/cxx-traits.cpp
test/PCH/cxx-traits.h
test/SemaCXX/type-traits.cpp
Index: test/SemaCXX/type-traits.cpp
===================================================================
--- test/SemaCXX/type-traits.cpp
+++ test/SemaCXX/type-traits.cpp
@@ -1,4 +1,7 @@
// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++11 -fms-extensions -Wno-microsoft %s
+// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++14 -fms-extensions -Wno-microsoft %s
+// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++1z -fms-extensions -Wno-microsoft %s
+
#define T(b) (b) ? 1 : -1
#define F(b) (b) ? -1 : 1
@@ -9,12 +12,14 @@
struct POD { Enum e; int i; float f; NonPOD* p; };
struct Empty {};
typedef Empty EmptyAr[10];
+typedef Empty EmptyArNB[];
+typedef Empty EmptyArMB[1][2];
typedef int Int;
typedef Int IntAr[10];
typedef Int IntArNB[];
class Statics { static int priv; static NonPOD np; };
union EmptyUnion {};
-union IncompleteUnion;
+union IncompleteUnion; // expected-note {{forward declaration of 'IncompleteUnion'}}
union Union { int i; float f; };
struct HasFunc { void f (); };
struct HasOp { void operator *(); };
@@ -38,6 +43,10 @@
typedef Derives DerivesArNB[];
struct DerivesEmpty : Empty {};
struct HasCons { HasCons(int); };
+struct HasDefaultCons { HasDefaultCons() = default; };
+struct HasExplicitDefaultCons { explicit HasExplicitDefaultCons() = default; };
+struct HasInheritedCons : HasDefaultCons { using HasDefaultCons::HasDefaultCons; };
+struct HasNoInheritedCons : HasCons {};
struct HasCopyAssign { HasCopyAssign operator =(const HasCopyAssign&); };
struct HasMoveAssign { HasMoveAssign operator =(const HasMoveAssign&&); };
struct HasNoThrowMoveAssign {
@@ -48,8 +57,15 @@
const HasNoExceptNoThrowMoveAssign&&) noexcept;
};
struct HasThrowMoveAssign {
- HasThrowMoveAssign& operator=(
- const HasThrowMoveAssign&&) throw(POD); };
+ HasThrowMoveAssign& operator=(const HasThrowMoveAssign&&)
+#if __cplusplus <= 201402L
+ throw(POD);
+#else
+ noexcept(false);
+#endif
+};
+
+
struct HasNoExceptFalseMoveAssign {
HasNoExceptFalseMoveAssign& operator=(
const HasNoExceptFalseMoveAssign&&) noexcept(false); };
@@ -81,6 +97,7 @@
class HasPriv { int priv; };
class HasProt { protected: int prot; };
struct HasRef { int i; int& ref; HasRef() : i(0), ref(i) {} };
+struct HasRefAggregate { int i; int& ref; };
struct HasNonPOD { NonPOD np; };
struct HasVirt { virtual void Virt() {}; };
typedef NonPOD NonPODAr[10];
@@ -152,7 +169,12 @@
};
struct ThrowingDtor {
- ~ThrowingDtor() throw(int);
+ ~ThrowingDtor()
+#if __cplusplus <= 201402L
+ throw(int);
+#else
+ noexcept(false);
+#endif
};
struct NoExceptDtor {
@@ -163,6 +185,20 @@
~NoThrowDtor() throw();
};
+struct ACompleteType {};
+struct AnIncompleteType; // expected-note 4 {{forward declaration of 'AnIncompleteType'}}
+typedef AnIncompleteType AnIncompleteTypeAr[42];
+typedef AnIncompleteType AnIncompleteTypeArNB[];
+typedef AnIncompleteType AnIncompleteTypeArMB[1][10];
+
+struct HasInClassInit {
+ int x = 42;
+};
+
+struct HasPrivateBase : private ACompleteType {};
+struct HasProtectedBase : protected ACompleteType {};
+struct HasVirtBase : virtual ACompleteType {};
+
void is_pod()
{
{ int arr[T(__is_pod(int))]; }
@@ -452,6 +488,71 @@
int t31[F(__is_floating_point(IntArNB))];
}
+template <class T>
+struct AggregateTemplate {
+ T value;
+};
+
+template <class T>
+struct NonAggregateTemplate {
+ T value;
+ NonAggregateTemplate();
+};
+
+void is_aggregate()
+{
+ constexpr bool TrueAfterCpp11 = __cplusplus > 201103L;
+ constexpr bool TrueAfterCpp14 = __cplusplus > 201402L;
+
+ static_assert(!__is_aggregate(NonPOD), "");
+ static_assert(!__is_aggregate(Enum), "");
+ static_assert(__is_aggregate(POD), "");
+ static_assert(__is_aggregate(Empty), "");
+ static_assert(__is_aggregate(EmptyAr), "");
+ static_assert(__is_aggregate(EmptyArNB), "");
+ static_assert(__is_aggregate(EmptyArMB), "");
+ static_assert(!__is_aggregate(AnIncompleteType), ""); // expected-error {{incomplete type 'AnIncompleteType' used in type trait expression}}
+ static_assert(!__is_aggregate(AnIncompleteTypeAr), ""); // expected-error {{incomplete type 'AnIncompleteType' used in type trait expression}}
+ static_assert(!__is_aggregate(AnIncompleteTypeArNB), ""); // expected-error {{incomplete type 'AnIncompleteType' used in type trait expression}}
+ static_assert(!__is_aggregate(AnIncompleteTypeArMB), ""); // expected-error {{incomplete type 'AnIncompleteType' used in type trait expression}}
+ static_assert(!__is_aggregate(void), "");
+ static_assert(!__is_aggregate(const volatile void), "");
+ static_assert(!__is_aggregate(int), "");
+ static_assert(__is_aggregate(EmptyUnion), "");
+ static_assert(__is_aggregate(Union), "");
+ static_assert(!__is_aggregate(IncompleteUnion), ""); // expected-error {{incomplete type 'IncompleteUnion' used in type trait expression}}
+ static_assert(__is_aggregate(Statics), "");
+ static_assert(__is_aggregate(HasFunc), "");
+ static_assert(__is_aggregate(HasOp), "");
+ static_assert(__is_aggregate(HasAssign), "");
+ static_assert(__is_aggregate(HasAnonymousUnion), "");
+
+ static_assert(__is_aggregate(Derives) == TrueAfterCpp14, "");
+ static_assert(__is_aggregate(DerivesAr) == TrueAfterCpp14, "");
+ static_assert(__is_aggregate(DerivesArNB) == TrueAfterCpp14, "");
+ static_assert(!__is_aggregate(HasCons), "");
+ static_assert(__is_aggregate(HasDefaultCons), "");
+ static_assert(!__is_aggregate(HasExplicitDefaultCons), "");
+ static_assert(!__is_aggregate(HasInheritedCons), "");
+ static_assert(__is_aggregate(HasNoInheritedCons) == TrueAfterCpp14, "");
+ static_assert(__is_aggregate(HasCopyAssign), "");
+ static_assert(!__is_aggregate(NonTrivialDefault), "");
+ static_assert(__is_aggregate(HasDest), "");
+ static_assert(!__is_aggregate(HasPriv), "");
+ static_assert(!__is_aggregate(HasProt), "");
+ static_assert(__is_aggregate(HasRefAggregate), "");
+ static_assert(__is_aggregate(HasNonPOD), "");
+ static_assert(!__is_aggregate(HasVirt), "");
+ static_assert(!__is_aggregate(VirtAr), "");
+ static_assert(__is_aggregate(HasInClassInit) == TrueAfterCpp11, "");
+ static_assert(!__is_aggregate(HasPrivateBase), "");
+ static_assert(!__is_aggregate(HasProtectedBase), "");
+ static_assert(!__is_aggregate(HasVirtBase), "");
+
+ static_assert(__is_aggregate(AggregateTemplate<int>), "");
+ static_assert(!__is_aggregate(NonAggregateTemplate<int>), "");
+}
+
void is_arithmetic()
{
int t01[T(__is_arithmetic(float))];
@@ -481,9 +582,6 @@
int t31[F(__is_arithmetic(IntArNB))];
}
-struct ACompleteType {};
-struct AnIncompleteType;
-
void is_complete_type()
{
int t01[T(__is_complete_type(float))];
Index: test/PCH/cxx-traits.h
===================================================================
--- test/PCH/cxx-traits.h
+++ test/PCH/cxx-traits.h
@@ -18,6 +18,7 @@
};
struct __is_abstract {}; // expected-warning {{made available}}
+struct __is_aggregate {}; // expected-warning {{made available}}
struct __is_arithmetic {}; // expected-warning {{made available}}
struct __is_array {}; // expected-warning {{made available}}
struct __is_assignable {}; // expected-warning {{made available}}
Index: test/PCH/cxx-traits.cpp
===================================================================
--- test/PCH/cxx-traits.cpp
+++ test/PCH/cxx-traits.cpp
@@ -16,6 +16,7 @@
// The built-ins should still work too:
bool _is_abstract_result = __is_abstract(int);
+bool _is_aggregate_result = __is_aggregate(int);
bool _is_arithmetic_result = __is_arithmetic(int);
bool _is_array_result = __is_array(int);
bool _is_assignable_result = __is_assignable(int, int);
Index: lib/Sema/SemaExprCXX.cpp
===================================================================
--- lib/Sema/SemaExprCXX.cpp
+++ lib/Sema/SemaExprCXX.cpp
@@ -4055,6 +4055,7 @@
// C++0x [meta.unary.prop] Table 49 requires the following traits to be
// applied to a complete type.
+ case UTT_IsAggregate:
case UTT_IsTrivial:
case UTT_IsTriviallyCopyable:
case UTT_IsStandardLayout:
@@ -4081,15 +4082,13 @@
case UTT_HasTrivialCopy:
case UTT_HasTrivialDestructor:
case UTT_HasVirtualDestructor:
- // Arrays of unknown bound are expressly allowed.
- QualType ElTy = ArgTy;
- if (ArgTy->isIncompleteArrayType())
- ElTy = S.Context.getAsArrayType(ArgTy)->getElementType();
-
- // The void type is expressly allowed.
+ // C++14 [meta.unary.prop]
+ // remove_all_extents_t<T> shall be a complete type or
+ // (possibly cv-qualified) void.
+ // See LWG 2015
+ QualType ElTy = S.Context.getBaseElementType(ArgTy);
if (ElTy->isVoidType())
return true;
-
return !S.RequireCompleteType(
Loc, ElTy, diag::err_incomplete_type_used_in_type_trait_expr);
}
@@ -4229,6 +4228,10 @@
if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl())
return !RD->isUnion() && RD->isAbstract();
return false;
+ case UTT_IsAggregate:
+ if (const CXXRecordDecl *RD = C.getBaseElementType(T)->getAsCXXRecordDecl())
+ return RD->isAggregate();
+ return false;
// __is_interface_class only returns true when CL is invoked in /CLR mode and
// even then only when it is used with the 'interface struct ...' syntax
// Clang doesn't support /CLR which makes this type trait moot.
Index: lib/Parse/ParseExpr.cpp
===================================================================
--- lib/Parse/ParseExpr.cpp
+++ lib/Parse/ParseExpr.cpp
@@ -676,6 +676,7 @@
/// '__is_union'
///
/// [Clang] unary-type-trait:
+/// '__is_aggregate'
/// '__trivially_copyable'
///
/// binary-type-trait:
@@ -804,6 +805,7 @@
= RTT_JOIN(tok::kw_,Name)
REVERTIBLE_TYPE_TRAIT(__is_abstract);
+ REVERTIBLE_TYPE_TRAIT(__is_aggregate);
REVERTIBLE_TYPE_TRAIT(__is_arithmetic);
REVERTIBLE_TYPE_TRAIT(__is_array);
REVERTIBLE_TYPE_TRAIT(__is_assignable);
Index: lib/Parse/ParseDeclCXX.cpp
===================================================================
--- lib/Parse/ParseDeclCXX.cpp
+++ lib/Parse/ParseDeclCXX.cpp
@@ -1405,6 +1405,7 @@
!Tok.isAnnotation() &&
Tok.getIdentifierInfo() &&
Tok.isOneOf(tok::kw___is_abstract,
+ tok::kw___is_aggregate,
tok::kw___is_arithmetic,
tok::kw___is_array,
tok::kw___is_assignable,
Index: include/clang/Basic/TypeTraits.h
===================================================================
--- include/clang/Basic/TypeTraits.h
+++ include/clang/Basic/TypeTraits.h
@@ -31,6 +31,7 @@
UTT_HasTrivialDestructor,
UTT_HasVirtualDestructor,
UTT_IsAbstract,
+ UTT_IsAggregate,
UTT_IsArithmetic,
UTT_IsArray,
UTT_IsClass,
Index: include/clang/Basic/TokenKinds.def
===================================================================
--- include/clang/Basic/TokenKinds.def
+++ include/clang/Basic/TokenKinds.def
@@ -432,6 +432,7 @@
TYPE_TRAIT_1(__has_trivial_destructor, HasTrivialDestructor, KEYCXX)
TYPE_TRAIT_1(__has_virtual_destructor, HasVirtualDestructor, KEYCXX)
TYPE_TRAIT_1(__is_abstract, IsAbstract, KEYCXX)
+TYPE_TRAIT_1(__is_aggregate, IsAggregate, KEYCXX)
TYPE_TRAIT_2(__is_base_of, IsBaseOf, KEYCXX)
TYPE_TRAIT_1(__is_class, IsClass, KEYCXX)
TYPE_TRAIT_2(__is_convertible_to, IsConvertibleTo, KEYCXX)
Index: docs/LanguageExtensions.rst
===================================================================
--- docs/LanguageExtensions.rst
+++ docs/LanguageExtensions.rst
@@ -993,6 +993,7 @@
* ``__has_trivial_destructor`` (GNU, Microsoft)
* ``__has_virtual_destructor`` (GNU, Microsoft)
* ``__is_abstract`` (GNU, Microsoft)
+* ``__is_aggregate`` (GNU, Microsoft)
* ``__is_base_of`` (GNU, Microsoft)
* ``__is_class`` (GNU, Microsoft)
* ``__is_convertible_to`` (Microsoft)
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
