[Sema] Add __is_aggregate type-trait

[EricWF]

Summary

LWG 2911 adds std::is_aggregate to the library, which requires a new builtin trait. This patch implements __is_aggregate.

[EricWF]

• Move test to correct file.

[EricWF]

• 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.

[EricWF]

• Correctly report array types as aggregates. (Woops!)

• Also report vector types as aggregates. This behavior mirrors GCC.

• report _Complex int and _Complex float as aggregates as well. Currently GCC does not have this behavior, but since they support aggregate initialization I think it makes sense to support them as aggregates.

[aaron.ballman]

docs/LanguageExtensions.rst

996

Has Microsoft already implemented this? If not, do we want to wait for them before claiming they implement it as well?

lib/Sema/SemaExprCXX.cpp

4234

Is there benefit to diverging from GCC's behavior here for _Complex types?

[EricWF]

docs/LanguageExtensions.rst

996

I asked @STL_MSFT to ping the frontend team to confirm they were planning on implementing it with this name. I was concerned this doc would never get updated otherwise.

lib/Sema/SemaExprCXX.cpp

4234

_Complex types act as if they are an array of 2 elements, and hence support aggregate initialization.

Ironically the GCC maintainer who implemented is_aggregate pointed this case out to me. I've pinged him to ask why he chose not to support it, or if the change is in the works.

[aaron.ballman]

docs/LanguageExtensions.rst

996

Seems reasonable. My concern is that we claim Microsoft implements this when they don't (yet) and someone uses this documentation to try to force Microsoft's hand. However, it seems that this documentation not being updated is the far more likely scenario. ;-)

lib/Sema/SemaExprCXX.cpp

4089

If I understand properly, this change is required by LWG 2015 for existing type traits *and* is needed for is_aggregate()? If so, it probably should be a separate patch doing just LWG 2015 (and tests) and a second one for is_aggregate().

4234

Thanks! I think supporting it makes sense.

[STL_MSFT]

docs/LanguageExtensions.rst

996

MS intends to implement this hook under this name. No ETA yet.

[EricWF]

lib/Sema/SemaExprCXX.cpp

4089

Ack.

[aaron.ballman]

docs/LanguageExtensions.rst

996

Lovely, then I'm happy with the documentation as-is.

[EricWF]

• Remove LWG 2015 implementation.

[aaron.ballman]

LGTM!

docs/LanguageExtensions.rst

 * ``__has_nothrow_copy`` (GNU, Microsoft)
 * ``__has_nothrow_constructor`` (GNU, Microsoft)
 * ``__has_trivial_assign`` (GNU, Microsoft)
 * ``__has_trivial_copy`` (GNU, Microsoft)
 * ``__has_trivial_constructor`` (GNU, Microsoft)
 * ``__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)
 * ``__is_empty`` (GNU, Microsoft)
 * ``__is_enum`` (GNU, Microsoft)
 * ``__is_interface_class`` (Microsoft)
 * ``__is_pod`` (GNU, Microsoft)
 * ``__is_polymorphic`` (GNU, Microsoft)

include/clang/Basic/TokenKinds.def

 TYPE_TRAIT_1(__has_trivial_assign, HasTrivialAssign, KEYCXX)
 TYPE_TRAIT_1(__has_trivial_move_assign, HasTrivialMoveAssign, KEYCXX)
 TYPE_TRAIT_1(__has_trivial_copy, HasTrivialCopy, KEYCXX)
 TYPE_TRAIT_1(__has_trivial_constructor, HasTrivialDefaultConstructor, KEYCXX)
 TYPE_TRAIT_1(__has_trivial_move_constructor, HasTrivialMoveConstructor, KEYCXX)
 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)
 TYPE_TRAIT_1(__is_empty, IsEmpty, KEYCXX)
 TYPE_TRAIT_1(__is_enum, IsEnum, KEYCXX)
 TYPE_TRAIT_1(__is_final, IsFinal, KEYCXX)
 // Tentative name - there's no implementation of std::is_literal_type yet.
 TYPE_TRAIT_1(__is_literal, IsLiteral, KEYCXX)

include/clang/Basic/TypeTraits.h

enum TypeTrait {
     UTT_HasTrivialAssign,
     UTT_HasTrivialMoveAssign,
     UTT_HasTrivialCopy,
     UTT_HasTrivialDefaultConstructor,
     UTT_HasTrivialMoveConstructor,
     UTT_HasTrivialDestructor,
     UTT_HasVirtualDestructor,
     UTT_IsAbstract,
+    UTT_IsAggregate,
     UTT_IsArithmetic,
     UTT_IsArray,
     UTT_IsClass,
     UTT_IsCompleteType,
     UTT_IsCompound,
     UTT_IsConst,
     UTT_IsDestructible,
     UTT_IsEmpty,

lib/Parse/ParseDeclCXX.cpp

   // C++11 attributes
   SourceLocation AttrFixitLoc = Tok.getLocation();
 
   if (TagType == DeclSpec::TST_struct &&
       Tok.isNot(tok::identifier) &&
       !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,
                   tok::kw___is_base_of,
                   tok::kw___is_class,
                   tok::kw___is_complete_type,
                   tok::kw___is_compound,
                   tok::kw___is_const,

lib/Parse/ParseExpr.cpp

 ///                   '__is_final'
 ///                   '__is_pod'
 ///                   '__is_polymorphic'
 ///                   '__is_sealed'                           [MS]
 ///                   '__is_trivial'
 ///                   '__is_union'
 ///
 /// [Clang] unary-type-trait:
+///                   '__is_aggregate'
 ///                   '__trivially_copyable'
 ///
 ///       binary-type-trait:
 /// [GNU]             '__is_base_of'       
 /// [MS]              '__is_convertible_to'
 ///                   '__is_convertible'
 ///                   '__is_same'
 ///
if (getLangOpts().CPlusPlus) {
         // Build up the mapping of revertible type traits, for future use.
         if (RevertibleTypeTraits.empty()) {
 #define RTT_JOIN(X,Y) X##Y
 #define REVERTIBLE_TYPE_TRAIT(Name)                         \
           RevertibleTypeTraits[PP.getIdentifierInfo(#Name)] \
             = 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);
           REVERTIBLE_TYPE_TRAIT(__is_base_of);
           REVERTIBLE_TYPE_TRAIT(__is_class);
           REVERTIBLE_TYPE_TRAIT(__is_complete_type);
           REVERTIBLE_TYPE_TRAIT(__is_compound);
           REVERTIBLE_TYPE_TRAIT(__is_const);

lib/Sema/SemaExprCXX.cpp

   case UTT_IsSealed:
     if (ArgTy->getAsCXXRecordDecl())
       return !S.RequireCompleteType(
           Loc, ArgTy, diag::err_incomplete_type_used_in_type_trait_expr);
     return true;
 
   // 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:
   case UTT_IsPOD:
   case UTT_IsLiteral:
 
   case UTT_IsDestructible:
   case UTT_IsNothrowDestructible:

   case UTT_HasTrivialMoveConstructor:
   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.
     if (ElTy->isVoidType())
       return true;
 
     return !S.RequireCompleteType(
       Loc, ElTy, diag::err_incomplete_type_used_in_type_trait_expr);
   }
 }

   case UTT_IsPolymorphic:
     if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl())
       return !RD->isUnion() && RD->isPolymorphic();
     return false;
   case UTT_IsAbstract:
     if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl())
       return !RD->isUnion() && RD->isAbstract();
     return false;
+  case UTT_IsAggregate:
+    // Report vector extensions and complex types as aggregates because they
+    // support aggregate initialization. GCC mirrors this behavior for vectors
+    // but not _Complex.
+    return T->isAggregateType() || T->isVectorType() || T->isExtVectorType() ||
+           T->isAnyComplexType();
   // __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.
   case UTT_IsInterfaceClass:
     return false;
   case UTT_IsFinal:
   case UTT_IsSealed:
     if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl())

test/PCH/cxx-traits.h

 };
 
 template<typename T, typename ...Args>
 struct is_trivially_constructible {
   static const bool value = __is_trivially_constructible(T, Args...);
 };
 
 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}}
 struct __is_base_of {};  // expected-warning {{made available}}
 struct __is_class {};  // expected-warning {{made available}}
 struct __is_complete_type {};  // expected-warning {{made available}}
 struct __is_compound {};  // expected-warning {{made available}}
 struct __is_const {};  // expected-warning {{made available}}

test/PCH/cxx-traits.cpp

 bool _Is_pod_comparator = n::__is_pod<int>::__value;
 bool _Is_empty_check = n::__is_empty<int>::__value;
 
 bool default_construct_int = n::is_trivially_constructible<int>::value;
 bool copy_construct_int = n::is_trivially_constructible<int, const int&>::value;
 
 // 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);
 bool _is_base_of_result = __is_base_of(int, int);
 bool _is_class_result = __is_class(int);
 bool _is_complete_type_result = __is_complete_type(int);
 bool _is_compound_result = __is_compound(int);
 bool _is_const_result = __is_const(int);

test/SemaCXX/type-traits.cpp

 // 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
 
 struct NonPOD { NonPOD(int); };
+typedef NonPOD NonPODAr[10];
+typedef NonPOD NonPODArNB[];
+typedef NonPOD NonPODArMB[10][2];
 
 // PODs
 enum Enum { EV };
 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 *(); };
 struct HasConv { operator int(); };
 struct HasAssign { void operator =(int); };
 
 struct HasAnonymousUnion {
   union {
     int i;
     float f;
   };
 };
 
 typedef int Vector __attribute__((vector_size(16)));
 typedef int VectorExt __attribute__((ext_vector_type(4)));
 
+using ComplexFloat = _Complex float;
+using ComplexInt = _Complex int;
+
 // Not PODs
 typedef const void cvoid;
 struct Derives : POD {};
 typedef Derives DerivesAr[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 { 
   HasNoThrowMoveAssign& operator=(
     const HasNoThrowMoveAssign&&) throw(); };
 struct HasNoExceptNoThrowMoveAssign { 
   HasNoExceptNoThrowMoveAssign& operator=(
     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); };
 struct HasMoveCtor { HasMoveCtor(const HasMoveCtor&&); };
 struct HasMemberMoveCtor { HasMoveCtor member; };
 struct HasMemberMoveAssign { HasMoveAssign member; };
 struct HasStaticMemberMoveCtor { static HasMoveCtor member; };
 struct HasStaticMemberMoveAssign { static HasMoveAssign member; };

 struct NonTrivialDefault {
   NonTrivialDefault();
 };
 
 struct HasDest { ~HasDest(); };
 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];
 typedef HasVirt VirtAr[10];
 typedef NonPOD NonPODArNB[];
 union NonPODUnion { int i; Derives n; };
 struct DerivesHasCons : HasCons {};
 struct DerivesHasCopyAssign : HasCopyAssign {};
struct ThreeArgCtor {
   ThreeArgCtor(int*, char*, int);
 };
 
 struct VariadicCtor {
   template<typename...T> VariadicCtor(T...);
 };
 
 struct ThrowingDtor {
-  ~ThrowingDtor() throw(int);
+  ~ThrowingDtor()
+#if __cplusplus <= 201402L
+  throw(int);
+#else
+  noexcept(false);
+#endif
 };
 
 struct NoExceptDtor {
   ~NoExceptDtor() noexcept(true);
 };
 
 struct NoThrowDtor {
   ~NoThrowDtor() throw();
 };
 
+struct ACompleteType {};
+struct AnIncompleteType; // expected-note 1+ {{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))]; }
   { int arr[T(__is_pod(Enum))]; }
   { int arr[T(__is_pod(POD))]; }
   { int arr[T(__is_pod(Int))]; }
   { int arr[T(__is_pod(IntAr))]; }
   { int arr[T(__is_pod(Statics))]; }
void is_floating_point()
   int t26[F(__is_floating_point(Derives))];
   int t27[F(__is_floating_point(ClassType))];
   int t28[F(__is_floating_point(Enum))];
   int t29[F(__is_floating_point(void))];
   int t30[F(__is_floating_point(cvoid))];
   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;
+
+  __is_aggregate(AnIncompleteType); // expected-error {{incomplete type}}
+  __is_aggregate(AnIncompleteTypeAr); // expected-error {{incomplete type}}
+  __is_aggregate(AnIncompleteTypeArNB); // expected-error {{incomplete type}}
+  __is_aggregate(AnIncompleteTypeArMB); // expected-error {{incomplete type}}
+  __is_aggregate(IncompleteUnion); // expected-error {{incomplete type}}
+
+  static_assert(!__is_aggregate(NonPOD), "");
+  static_assert(__is_aggregate(NonPODAr), "");
+  static_assert(__is_aggregate(NonPODArNB), "");
+  static_assert(__is_aggregate(NonPODArMB), "");
+
+  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(void), "");
+  static_assert(!__is_aggregate(const volatile void), "");
+  static_assert(!__is_aggregate(int), "");
+  static_assert(__is_aggregate(IntAr), "");
+  static_assert(__is_aggregate(IntArNB), "");
+  static_assert(__is_aggregate(EmptyUnion), "");
+  static_assert(__is_aggregate(Union), "");
+  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), "");
+  static_assert(__is_aggregate(DerivesArNB), "");
+  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>), "");
+
+  static_assert(__is_aggregate(Vector), ""); // Extension supported by GCC and Clang
+  static_assert(__is_aggregate(VectorExt), "");
+  static_assert(__is_aggregate(ComplexInt), "");
+  static_assert(__is_aggregate(ComplexFloat), "");
+}
+
 void is_arithmetic()
 {
   int t01[T(__is_arithmetic(float))];
   int t02[T(__is_arithmetic(double))];
   int t03[T(__is_arithmetic(long double))];
   int t11[T(__is_arithmetic(bool))];
   int t12[T(__is_arithmetic(char))];
   int t13[T(__is_arithmetic(signed char))];
void is_arithmetic()
   int t26[F(__is_arithmetic(Derives))];
   int t27[F(__is_arithmetic(ClassType))];
   int t28[F(__is_arithmetic(Enum))];
   int t29[F(__is_arithmetic(void))];
   int t30[F(__is_arithmetic(cvoid))];
   int t31[F(__is_arithmetic(IntArNB))];
 }
 
-struct ACompleteType {};
-struct AnIncompleteType;
-
 void is_complete_type()
 {
   int t01[T(__is_complete_type(float))];
   int t02[T(__is_complete_type(double))];
   int t03[T(__is_complete_type(long double))];
   int t11[T(__is_complete_type(bool))];
   int t12[T(__is_complete_type(char))];
   int t13[T(__is_complete_type(signed char))];