r304376 - PR33232: implement support for MSVC's __is_trivially_destructible trait.
Richard Smith via cfe-commits
cfe-commits at lists.llvm.org
Thu Jun 1 17:46:28 PDT 2017
On 31 May 2017 at 17:41, Eric Fiselier <eric at efcs.ca> wrote:
> I'm assuming libc++ should move to this trait instead?
>
Yes, that'd be a good idea. Though now that you mention it, I'm not sure we
have a good feature detection story for these builtins. Looks like a bunch
of the existing ones are (oddly) covered by __has_feature, and they can all
be discovered through !__is_identifier, but __has_extension or
__has_builtin seem like the right detection mechanism and neither of them
works here. ;-(
Thoughts?
> /Eric
>
> On Wed, May 31, 2017 at 6:28 PM, Richard Smith via cfe-commits <
> cfe-commits at lists.llvm.org> wrote:
>
>> Author: rsmith
>> Date: Wed May 31 19:28:16 2017
>> New Revision: 304376
>>
>> URL: http://llvm.org/viewvc/llvm-project?rev=304376&view=rev
>> Log:
>> PR33232: implement support for MSVC's __is_trivially_destructible trait.
>>
>> Unlike the GCC-compatible __has_trivial_destructor trait, this one
>> computes the
>> right answer rather than performing the quirky set of checks described in
>> GCC's
>> documentation (https://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html).
>>
>> MSVC also has a __has_trivial_destructor trait which is the same as its
>> (and
>> now Clang's) __is_trivially_destructible trait; we might want to consider
>> changing the behavior of __has_trivial_destructor if we're targeting an
>> MSVC
>> platform, but I'm not doing so for now.
>>
>> While implementing this I found that we were incorrectly rejecting
>> __is_destructible queries on arrays of unknown bound of incomplete types;
>> that
>> too is fixed, and I've added similar tests for other traits for good
>> measure.
>>
>> Modified:
>> cfe/trunk/include/clang/Basic/TokenKinds.def
>> cfe/trunk/include/clang/Basic/TypeTraits.h
>> cfe/trunk/lib/Sema/SemaExprCXX.cpp
>> cfe/trunk/test/SemaCXX/type-traits.cpp
>>
>> Modified: cfe/trunk/include/clang/Basic/TokenKinds.def
>> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/
>> Basic/TokenKinds.def?rev=304376&r1=304375&r2=304376&view=diff
>> ============================================================
>> ==================
>> --- cfe/trunk/include/clang/Basic/TokenKinds.def (original)
>> +++ cfe/trunk/include/clang/Basic/TokenKinds.def Wed May 31 19:28:16 2017
>> @@ -411,6 +411,7 @@ TYPE_TRAIT_1(__is_sealed, IsSealed, KEYM
>>
>> // MSVC12.0 / VS2013 Type Traits
>> TYPE_TRAIT_1(__is_destructible, IsDestructible, KEYMS)
>> +TYPE_TRAIT_1(__is_trivially_destructible, IsTriviallyDestructible,
>> KEYCXX)
>> TYPE_TRAIT_1(__is_nothrow_destructible, IsNothrowDestructible, KEYMS)
>> TYPE_TRAIT_2(__is_nothrow_assignable, IsNothrowAssignable, KEYCXX)
>> TYPE_TRAIT_N(__is_constructible, IsConstructible, KEYCXX)
>> @@ -439,7 +440,6 @@ TYPE_TRAIT_2(__is_convertible_to, IsConv
>> 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)
>> // Name for GCC 4.6 compatibility - people have already written
>> libraries using
>> // this name unfortunately.
>>
>> Modified: cfe/trunk/include/clang/Basic/TypeTraits.h
>> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/
>> Basic/TypeTraits.h?rev=304376&r1=304375&r2=304376&view=diff
>> ============================================================
>> ==================
>> --- cfe/trunk/include/clang/Basic/TypeTraits.h (original)
>> +++ cfe/trunk/include/clang/Basic/TypeTraits.h Wed May 31 19:28:16 2017
>> @@ -65,6 +65,7 @@ namespace clang {
>> UTT_IsStandardLayout,
>> UTT_IsTrivial,
>> UTT_IsTriviallyCopyable,
>> + UTT_IsTriviallyDestructible,
>> UTT_IsUnion,
>> UTT_IsUnsigned,
>> UTT_IsVoid,
>>
>> Modified: cfe/trunk/lib/Sema/SemaExprCXX.cpp
>> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Sema/SemaE
>> xprCXX.cpp?rev=304376&r1=304375&r2=304376&view=diff
>> ============================================================
>> ==================
>> --- cfe/trunk/lib/Sema/SemaExprCXX.cpp (original)
>> +++ cfe/trunk/lib/Sema/SemaExprCXX.cpp Wed May 31 19:28:16 2017
>> @@ -4080,24 +4080,23 @@ static bool CheckUnaryTypeTraitTypeCompl
>> 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.
>> + // C++1z [meta.unary.prop]:
>> + // remove_all_extents_t<T> shall be a complete type or cv void.
>> case UTT_IsAggregate:
>> case UTT_IsTrivial:
>> case UTT_IsTriviallyCopyable:
>> case UTT_IsStandardLayout:
>> case UTT_IsPOD:
>> case UTT_IsLiteral:
>> + ArgTy = QualType(ArgTy->getBaseElementTypeUnsafe(), 0);
>> + LLVM_FALLTHROUGH;
>>
>> + // C++1z [meta.unary.prop]:
>> + // T shall be a complete type, cv void, or an array of unknown bound.
>> case UTT_IsDestructible:
>> case UTT_IsNothrowDestructible:
>> - // Fall-through
>> -
>> - // These trait expressions are designed to help implement predicates
>> in
>> - // [meta.unary.prop] despite not being named the same. They are
>> specified
>> - // by both GCC and the Embarcadero C++ compiler, and require the
>> complete
>> - // type due to the overarching C++0x type predicates being
>> implemented
>> - // requiring the complete type.
>> + case UTT_IsTriviallyDestructible:
>> + // Per the GCC type traits documentation, the same constraints apply
>> to these.
>> case UTT_HasNothrowAssign:
>> case UTT_HasNothrowMoveAssign:
>> case UTT_HasNothrowConstructor:
>> @@ -4109,17 +4108,11 @@ static bool CheckUnaryTypeTraitTypeCompl
>> 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())
>> + if (ArgTy->isIncompleteArrayType() || ArgTy->isVoidType())
>> return true;
>>
>> return !S.RequireCompleteType(
>> - Loc, ElTy, diag::err_incomplete_type_used_in_type_trait_expr);
>> + Loc, ArgTy, diag::err_incomplete_type_used_in_type_trait_expr);
>> }
>> }
>>
>> @@ -4356,6 +4349,7 @@ static bool EvaluateUnaryTypeTrait(Sema
>> !RD->hasNonTrivialCopyAssignment();
>> return false;
>> case UTT_IsDestructible:
>> + case UTT_IsTriviallyDestructible:
>> case UTT_IsNothrowDestructible:
>> // C++14 [meta.unary.prop]:
>> // For reference types, is_destructible<T>::value is true.
>> @@ -4373,6 +4367,11 @@ static bool EvaluateUnaryTypeTrait(Sema
>> if (T->isIncompleteType() || T->isFunctionType())
>> return false;
>>
>> + // A type that requires destruction (via a non-trivial destructor or
>> ARC
>> + // lifetime semantics) is not trivially-destructible.
>> + if (UTT == UTT_IsTriviallyDestructible && T.isDestructedType())
>> + return false;
>> +
>> // C++14 [meta.unary.prop]:
>> // For object types and given U equal to remove_all_extents_t<T>,
>> if the
>> // expression std::declval<U&>().~U() is well-formed when treated
>> as an
>>
>> Modified: cfe/trunk/test/SemaCXX/type-traits.cpp
>> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/test/SemaCXX/
>> type-traits.cpp?rev=304376&r1=304375&r2=304376&view=diff
>> ============================================================
>> ==================
>> --- cfe/trunk/test/SemaCXX/type-traits.cpp (original)
>> +++ cfe/trunk/test/SemaCXX/type-traits.cpp Wed May 31 19:28:16 2017
>> @@ -252,6 +252,11 @@ void is_pod()
>> { int arr[F(__is_pod(void))]; }
>> { int arr[F(__is_pod(cvoid))]; }
>> // { int arr[F(__is_pod(NonPODUnion))]; }
>> +
>> + { int arr[T(__is_pod(ACompleteType))]; }
>> + { int arr[F(__is_pod(AnIncompleteType))]; } // expected-error
>> {{incomplete type}}
>> + { int arr[F(__is_pod(AnIncompleteType[]))]; } // expected-error
>> {{incomplete type}}
>> + { int arr[F(__is_pod(AnIncompleteType[1]))]; } // expected-error
>> {{incomplete type}}
>> }
>>
>> typedef Empty EmptyAr[10];
>> @@ -287,6 +292,11 @@ void is_empty()
>> { int arr[F(__is_empty(IntArNB))]; }
>> { int arr[F(__is_empty(HasAnonymousUnion))]; }
>> // { int arr[F(__is_empty(DerivesVirt))]; }
>> +
>> + { int arr[T(__is_empty(ACompleteType))]; }
>> + { int arr[F(__is_empty(AnIncompleteType))]; } // expected-error
>> {{incomplete type}}
>> + { int arr[F(__is_empty(AnIncompleteType[]))]; }
>> + { int arr[F(__is_empty(AnIncompleteType[1]))]; }
>> }
>>
>> typedef Derives ClassType;
>> @@ -511,6 +521,8 @@ void is_aggregate()
>> constexpr bool TrueAfterCpp14 = __cplusplus > 201402L;
>>
>> __is_aggregate(AnIncompleteType); // expected-error {{incomplete
>> type}}
>> + __is_aggregate(AnIncompleteType[]); // expected-error {{incomplete
>> type}}
>> + __is_aggregate(AnIncompleteType[1]); // 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}}
>> @@ -1220,6 +1232,13 @@ void is_trivial2()
>> int t32[F(__is_trivial(SuperNonTrivialStruct))];
>> int t33[F(__is_trivial(NonTCStruct))];
>> int t34[F(__is_trivial(ExtDefaulted))];
>> +
>> + int t40[T(__is_trivial(ACompleteType))];
>> + int t41[F(__is_trivial(AnIncompleteType))]; // expected-error
>> {{incomplete type}}
>> + int t42[F(__is_trivial(AnIncompleteType[]))]; // expected-error
>> {{incomplete type}}
>> + int t43[F(__is_trivial(AnIncompleteType[1]))]; // expected-error
>> {{incomplete type}}
>> + int t44[F(__is_trivial(void))];
>> + int t45[F(__is_trivial(const volatile void))];
>> }
>>
>> void is_trivially_copyable2()
>> @@ -1257,6 +1276,13 @@ void is_trivially_copyable2()
>>
>> int t34[T(__is_trivially_copyable(const int))];
>> int t35[T(__is_trivially_copyable(volatile int))];
>> +
>> + int t40[T(__is_trivially_copyable(ACompleteType))];
>> + int t41[F(__is_trivially_copyable(AnIncompleteType))]; //
>> expected-error {{incomplete type}}
>> + int t42[F(__is_trivially_copyable(AnIncompleteType[]))]; //
>> expected-error {{incomplete type}}
>> + int t43[F(__is_trivially_copyable(AnIncompleteType[1]))]; //
>> expected-error {{incomplete type}}
>> + int t44[F(__is_trivially_copyable(void))];
>> + int t45[F(__is_trivially_copyable(const volatile void))];
>> }
>>
>> struct CStruct {
>> @@ -1320,6 +1346,13 @@ void is_standard_layout()
>> int t15[F(__is_standard_layout(CppStructNonStandardByBaseAr))];
>> int t16[F(__is_standard_layout(CppStructNonStandardBySameBase))];
>> int t17[F(__is_standard_layout(CppStructNonStandardBy2ndVirtBase))];
>> +
>> + int t40[T(__is_standard_layout(ACompleteType))];
>> + int t41[F(__is_standard_layout(AnIncompleteType))]; // expected-error
>> {{incomplete type}}
>> + int t42[F(__is_standard_layout(AnIncompleteType[]))]; //
>> expected-error {{incomplete type}}
>> + int t43[F(__is_standard_layout(AnIncompleteType[1]))]; //
>> expected-error {{incomplete type}}
>> + int t44[F(__is_standard_layout(void))];
>> + int t45[F(__is_standard_layout(const volatile void))];
>> }
>>
>> void is_signed()
>> @@ -2133,6 +2166,13 @@ void trivial_checks()
>> TrivialMoveButNotCopy)))]; }
>> { int arr[T((__is_assignable(TrivialMoveButNotCopy &,
>> TrivialMoveButNotCopy &&)))]; }
>> +
>> + { int arr[T(__is_assignable(ACompleteType, ACompleteType))]; }
>> + { int arr[F(__is_assignable(AnIncompleteType, AnIncompleteType))]; }
>> // expected-error {{incomplete type}}
>> + { int arr[F(__is_assignable(AnIncompleteType[],
>> AnIncompleteType[]))]; }
>> + { int arr[F(__is_assignable(AnIncompleteType[1],
>> AnIncompleteType[1]))]; } // expected-error {{incomplete type}}
>> + { int arr[F(__is_assignable(void, void))]; }
>> + { int arr[F(__is_assignable(const volatile void, const volatile
>> void))]; }
>> }
>>
>> void constructible_checks() {
>> @@ -2164,6 +2204,19 @@ void constructible_checks() {
>>
>> // PR25513
>> { int arr[F(__is_constructible(int(int)))]; }
>> +
>> + { int arr[T(__is_constructible(ACompleteType))]; }
>> + { int arr[T(__is_nothrow_constructible(ACompleteType))]; }
>> + { int arr[F(__is_constructible(AnIncompleteType))]; } //
>> expected-error {{incomplete type}}
>> + { int arr[F(__is_nothrow_constructible(AnIncompleteType))]; } //
>> expected-error {{incomplete type}}
>> + { int arr[F(__is_constructible(AnIncompleteType[]))]; }
>> + { int arr[F(__is_nothrow_constructible(AnIncompleteType[]))]; }
>> + { int arr[F(__is_constructible(AnIncompleteType[1]))]; } //
>> expected-error {{incomplete type}}
>> + { int arr[F(__is_nothrow_constructible(AnIncompleteType[1]))]; } //
>> expected-error {{incomplete type}}
>> + { int arr[F(__is_constructible(void))]; }
>> + { int arr[F(__is_nothrow_constructible(void))]; }
>> + { int arr[F(__is_constructible(const volatile void))]; }
>> + { int arr[F(__is_nothrow_constructible(const volatile void))]; }
>> }
>>
>> // Instantiation of __is_trivially_constructible
>> @@ -2192,6 +2245,13 @@ void is_trivially_constructible_test() {
>> { int arr[F((is_trivially_constructible<NonTrivialDefault>::value))];
>> }
>> { int arr[F((is_trivially_constructible<ThreeArgCtor, int*, char*,
>> int&>::value))]; }
>> { int arr[F((is_trivially_constructible<Abstract>::value))]; } //
>> PR19178
>> +
>> + { int arr[T(__is_trivially_constructible(ACompleteType))]; }
>> + { int arr[F(__is_trivially_constructible(AnIncompleteType))]; } //
>> expected-error {{incomplete type}}
>> + { int arr[F(__is_trivially_constructible(AnIncompleteType[]))]; }
>> + { int arr[F(__is_trivially_constructible(AnIncompleteType[1]))]; } //
>> expected-error {{incomplete type}}
>> + { int arr[F(__is_trivially_constructible(void))]; }
>> + { int arr[F(__is_trivially_constructible(const volatile void))]; }
>> }
>>
>> void array_rank() {
>> @@ -2218,6 +2278,13 @@ void is_destructible_test() {
>> { int arr[F(__is_destructible(AllDeleted))]; }
>> { int arr[T(__is_destructible(ThrowingDtor))]; }
>> { int arr[T(__is_destructible(NoThrowDtor))]; }
>> +
>> + { int arr[T(__is_destructible(ACompleteType))]; }
>> + { int arr[F(__is_destructible(AnIncompleteType))]; } //
>> expected-error {{incomplete type}}
>> + { int arr[F(__is_destructible(AnIncompleteType[]))]; }
>> + { int arr[F(__is_destructible(AnIncompleteType[1]))]; } //
>> expected-error {{incomplete type}}
>> + { int arr[F(__is_destructible(void))]; }
>> + { int arr[F(__is_destructible(const volatile void))]; }
>> }
>>
>> void is_nothrow_destructible_test() {
>> @@ -2234,4 +2301,33 @@ void is_nothrow_destructible_test() {
>> { int arr[F(__is_nothrow_destructible(ThrowingDtor))]; }
>> { int arr[T(__is_nothrow_destructible(NoExceptDtor))]; }
>> { int arr[T(__is_nothrow_destructible(NoThrowDtor))]; }
>> +
>> + { int arr[T(__is_nothrow_destructible(ACompleteType))]; }
>> + { int arr[F(__is_nothrow_destructible(AnIncompleteType))]; } //
>> expected-error {{incomplete type}}
>> + { int arr[F(__is_nothrow_destructible(AnIncompleteType[]))]; }
>> + { int arr[F(__is_nothrow_destructible(AnIncompleteType[1]))]; } //
>> expected-error {{incomplete type}}
>> + { int arr[F(__is_nothrow_destructible(void))]; }
>> + { int arr[F(__is_nothrow_destructible(const volatile void))]; }
>> +}
>> +
>> +void is_trivially_destructible_test() {
>> + { int arr[T(__is_trivially_destructible(int))]; }
>> + { int arr[T(__is_trivially_destructible(int[2]))]; }
>> + { int arr[F(__is_trivially_destructible(int[]))]; }
>> + { int arr[F(__is_trivially_destructible(void))]; }
>> + { int arr[T(__is_trivially_destructible(int &))]; }
>> + { int arr[F(__is_trivially_destructible(HasDest))]; }
>> + { int arr[F(__is_trivially_destructible(AllPrivate))]; }
>> + { int arr[F(__is_trivially_destructible(SuperNonTrivialStruct))]; }
>> + { int arr[T(__is_trivially_destructible(AllDefaulted))]; }
>> + { int arr[F(__is_trivially_destructible(AllDeleted))]; }
>> + { int arr[F(__is_trivially_destructible(ThrowingDtor))]; }
>> + { int arr[F(__is_trivially_destructible(NoThrowDtor))]; }
>> +
>> + { int arr[T(__is_trivially_destructible(ACompleteType))]; }
>> + { int arr[F(__is_trivially_destructible(AnIncompleteType))]; } //
>> expected-error {{incomplete type}}
>> + { int arr[F(__is_trivially_destructible(AnIncompleteType[]))]; }
>> + { int arr[F(__is_trivially_destructible(AnIncompleteType[1]))]; } //
>> expected-error {{incomplete type}}
>> + { int arr[F(__is_trivially_destructible(void))]; }
>> + { int arr[F(__is_trivially_destructible(const volatile void))]; }
>> }
>>
>>
>> _______________________________________________
>> cfe-commits mailing list
>> cfe-commits at lists.llvm.org
>> http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
>>
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/cfe-commits/attachments/20170601/b41adc06/attachment-0001.html>
More information about the cfe-commits
mailing list