Expanding Type Traits to make Vector use mem ops more.

Source/wtf/TypeTraits.cpp

  /*
  * Copyright (C) 2006, 2007, 2008 Apple Inc. All rights reserved.
  * Copyright (C) 2009, 2010 Google Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
@@ skipping 34 matching lines @@
 COMPILE_ASSERT(!IsInteger<const char*>::value, WTF_IsInteger_const_char_pointer_false);
 COMPILE_ASSERT(!IsInteger<volatile char*>::value, WTF_IsInteger_volatile_char_pointer_false);
 COMPILE_ASSERT(!IsInteger<double>::value, WTF_IsInteger_double_false);
 COMPILE_ASSERT(!IsInteger<float>::value, WTF_IsInteger_float_false);
 
 COMPILE_ASSERT(IsFloatingPoint<float>::value, WTF_IsFloatingPoint_float_true);
 COMPILE_ASSERT(IsFloatingPoint<double>::value, WTF_IsFloatingPoint_double_true);
 COMPILE_ASSERT(IsFloatingPoint<long double>::value, WTF_IsFloatingPoint_long_double_true);
 COMPILE_ASSERT(!IsFloatingPoint<int>::value, WTF_IsFloatingPoint_int_false);
 
+COMPILE_ASSERT(IsPointer<void*>::value, WTF_IsPointer_void_star_true);
+COMPILE_ASSERT(IsPointer<char*>::value, WTF_IsPointer_char_star_true);
+COMPILE_ASSERT(IsPointer<const char*>::value, WTF_IsPointer_const_char_star_true);
+COMPILE_ASSERT(!IsPointer<char>::value, WTF_IsPointer_char_false);
+COMPILE_ASSERT(!IsPointer<int>::value, WTF_IsPointer_int_false);
+COMPILE_ASSERT(!IsPointer<long>::value, WTF_IsPointer_long_false);
+
+enum TestEnum { TestEnumValue };
+COMPILE_ASSERT(IsEnum<TestEnum>::value, WTF_IsEnum_enum_true);
+COMPILE_ASSERT(!IsEnum<int>::value, WTF_IsEnum_int_false);
+COMPILE_ASSERT(!IsEnum<TestEnum*>::value, WTF_IsEnum_enum_star_false);
+
+COMPILE_ASSERT(IsScalar<TestEnum>::value, WTF_IsScalar_enum_true);
+COMPILE_ASSERT(IsScalar<int>::value, WTF_IsScalar_int_true);
+COMPILE_ASSERT(IsScalar<TestEnum*>::value, WTF_IsScalar_enum_star_true);
+COMPILE_ASSERT(IsScalar<double>::value, WTF_IsScalar_double_true);
+
 COMPILE_ASSERT(IsPod<bool>::value, WTF_IsPod_bool_true);
 COMPILE_ASSERT(IsPod<char>::value, WTF_IsPod_char_true);
 COMPILE_ASSERT(IsPod<signed char>::value, WTF_IsPod_signed_char_true);
 COMPILE_ASSERT(IsPod<unsigned char>::value, WTF_IsPod_unsigned_char_true);
 COMPILE_ASSERT(IsPod<short>::value, WTF_IsPod_short_true);
 COMPILE_ASSERT(IsPod<unsigned short>::value, WTF_IsPod_unsigned_short_true);
 COMPILE_ASSERT(IsPod<int>::value, WTF_IsPod_int_true);
 COMPILE_ASSERT(IsPod<unsigned>::value, WTF_IsPod_unsigned_int_true);
 COMPILE_ASSERT(IsPod<long>::value, WTF_IsPod_long_true);
 COMPILE_ASSERT(IsPod<unsigned long>::value, WTF_IsPod_unsigned_long_true);
 COMPILE_ASSERT(IsPod<long long>::value, WTF_IsPod_long_long_true);
 COMPILE_ASSERT(IsPod<unsigned long long>::value, WTF_IsPod_unsigned_long_long_true);
 #if !COMPILER(MSVC) || defined(_NATIVE_WCHAR_T_DEFINED)
 COMPILE_ASSERT(IsPod<wchar_t>::value, WTF_IsPod_wchar_t_true);
 #endif
 COMPILE_ASSERT(IsPod<char*>::value, WTF_IsPod_char_pointer_true);
 COMPILE_ASSERT(IsPod<const char*>::value, WTF_IsPod_const_char_pointer_true);
 COMPILE_ASSERT(IsPod<volatile char*>::value, WTF_IsPod_volatile_char_pointer_true);
 COMPILE_ASSERT(IsPod<double>::value, WTF_IsPod_double_true);
 COMPILE_ASSERT(IsPod<long double>::value, WTF_IsPod_long_double_true);
 COMPILE_ASSERT(IsPod<float>::value, WTF_IsPod_float_true);
-COMPILE_ASSERT(!IsPod<IsPod<bool> >::value, WTF_IsPod_struct_false);
+struct VirtualClass {
+    virtual void A() { }
+};
+COMPILE_ASSERT(!IsTriviallyMoveAssignable<VirtualClass>::value, WTF_IsTriviallyMoveAssignable_VirtualClass_false);
+COMPILE_ASSERT(!IsScalar<VirtualClass>::value, WTF_IsScalar_class_false);
+COMPILE_ASSERT(IsScalar<VirtualClass*>::value, WTF_IsScalar_class_ptr_true);
+
+struct DestructorClass {
+    ~DestructorClass() { }
+};
+COMPILE_ASSERT(IsTriviallyMoveAssignable<DestructorClass>::value, WTF_IsTriviallyMoveAssignable_DestructorClass_true);
+COMPILE_ASSERT(IsTriviallyCopyAssignable<DestructorClass>::value, WTF_IsTriviallyCopyAssignable_DestructorClass_true);
+COMPILE_ASSERT(IsTriviallyDefaultConstructible<DestructorClass>::value, WTF_IsTriviallyDefaultConstructable_DestructorClass_true);
+
+struct MixedPrivate {
+    int M2() { return m2; }
+    int m1;
+private:
+    int m2;
+};
+COMPILE_ASSERT(IsTriviallyMoveAssignable<MixedPrivate>::value, WTF_IsTriviallyMoveAssignable_MixedPrivate_true);
+COMPILE_ASSERT(IsTriviallyCopyAssignable<MixedPrivate>::value, WTF_IsTriviallyCopyAssignable_MixedPrivate_true);
+COMPILE_ASSERT(IsTriviallyDefaultConstructible<MixedPrivate>::value, WTF_IsTriviallyDefaultConstructable_MixedPrivate_true);
+struct JustPrivate {
+    int M2() { return m2; }
+private:
+    int m2;
+};
+COMPILE_ASSERT(IsTriviallyMoveAssignable<JustPrivate>::value, WTF_IsTriviallyMoveAssignable_JustPrivate_true);
+COMPILE_ASSERT(IsTriviallyCopyAssignable<JustPrivate>::value, WTF_IsTriviallyCopyAssignable_JustPrivate_true);
+COMPILE_ASSERT(IsTriviallyDefaultConstructible<JustPrivate>::value, WTF_IsTriviallyDefaultConstructable_JustPrivate_true);
+struct JustPublic {
+    int m2;
+};
+COMPILE_ASSERT(IsTriviallyMoveAssignable<JustPublic>::value, WTF_IsTriviallyMoveAssignable_JustPublic_true);
+COMPILE_ASSERT(IsTriviallyCopyAssignable<JustPublic>::value, WTF_IsTriviallyCopyAssignable_JustPublic_true);
+COMPILE_ASSERT(IsTriviallyDefaultConstructible<JustPublic>::value, WTF_IsTriviallyDefaultConstructable_JustPublic_true);
+struct NestedInherited : public JustPublic, JustPrivate {
+    float m3;
+};
+COMPILE_ASSERT(IsTriviallyMoveAssignable<NestedInherited>::value, WTF_IsTriviallyMoveAssignable_NestedInherited_true);
+COMPILE_ASSERT(IsTriviallyCopyAssignable<NestedInherited>::value, WTF_IsTriviallyCopyAssignable_NestedInherited_true);
+COMPILE_ASSERT(IsTriviallyDefaultConstructible<NestedInherited>::value, WTF_IsTriviallyDefaultConstructable_NestedInherited_true);
+struct NestedOwned {
+    JustPublic m1;
+    JustPrivate m2;
+    float m3;
+};
+
+COMPILE_ASSERT(IsTriviallyMoveAssignable<NestedOwned>::value, WTF_IsTriviallyMoveAssignable_NestedOwned_true);
+COMPILE_ASSERT(IsTriviallyCopyAssignable<NestedOwned>::value, WTF_IsTriviallyCopyAssignable_NestedOwned_true);
+COMPILE_ASSERT(IsTriviallyDefaultConstructible<NestedOwned>::value, WTF_IsTriviallyDefaultConstructable_NestedOwned_true);
+
+class NonCopyableClass {
+#if COMPILER_SUPPORTS(CXX_DELETED_FUNCTIONS)
+    NonCopyableClass(const NonCopyableClass&) = delete;
+    NonCopyableClass& operator=(const NonCopyableClass&) = delete;
+#else
+    NonCopyableClass(const NonCopyableClass&);
+    NonCopyableClass& operator=(const NonCopyableClass&);
+#endif // COMPILER_SUPPORTS(CXX_DELETED_FUNCTIONS)
+};
+#if 0 // Compilers don't get this "right" yet if using = delete.
+COMPILE_ASSERT(!IsTriviallyMoveAssignable<NonCopyableClass>::value, WTF_IsTriviallyMoveAssignable_NonCopyableClass_false);
+COMPILE_ASSERT(!IsTriviallyCopyAssignable<NonCopyableClass>::value, WTF_IsTriviallyCopyAssignable_NonCopyableClass_false);
+COMPILE_ASSERT(IsTriviallyDefaultConstructible<NonCopyableClass>::value, WTF_IsTriviallyDefaultConstructable_NonCopyableClass_true);
+#endif // 0
 
 enum IsConvertibleToIntegerCheck { };
 COMPILE_ASSERT(IsConvertibleToInteger<IsConvertibleToIntegerCheck>::value, WTF_IsConvertibleToInteger_enum_true);
 COMPILE_ASSERT(IsConvertibleToInteger<bool>::value, WTF_IsConvertibleToInteger_bool_true);
 COMPILE_ASSERT(IsConvertibleToInteger<char>::value, WTF_IsConvertibleToInteger_char_true);
 COMPILE_ASSERT(IsConvertibleToInteger<signed char>::value, WTF_IsConvertibleToInteger_signed_char_true);
 COMPILE_ASSERT(IsConvertibleToInteger<unsigned char>::value, WTF_IsConvertibleToInteger_unsigned_char_true);
 COMPILE_ASSERT(IsConvertibleToInteger<short>::value, WTF_IsConvertibleToInteger_short_true);
 COMPILE_ASSERT(IsConvertibleToInteger<unsigned short>::value, WTF_IsConvertibleToInteger_unsigned_short_true);
 COMPILE_ASSERT(IsConvertibleToInteger<int>::value, WTF_IsConvertibleToInteger_int_true);
@@ skipping 63 matching lines @@
 typedef int IntArray[];
 typedef int IntArraySized[4];
 
 COMPILE_ASSERT((IsArray<IntArray>::value), WTF_Test_IsArray_int_array);
 COMPILE_ASSERT((IsArray<IntArraySized>::value), WTF_Test_IsArray_int_sized_array);
 
 COMPILE_ASSERT((IsSameType<int, RemoveExtent<IntArray>::Type>::value), WTF_Test_RemoveExtent_int_array);
 COMPILE_ASSERT((IsSameType<int, RemoveExtent<IntArraySized>::Type>::value), WTF_Test_RemoveReference_int_sized_array);
 
 } // namespace WTF