On 20/03/21 09:18 -0500, Tim Song wrote:
On Sat, Mar 20, 2021 at 3:58 AM Jonathan Wakely <jwakely....@gmail.com> wrote:
On Sat, 20 Mar 2021, 01:13 Tim Song via Libstdc++, <libstd...@gcc.gnu.org>
wrote:
On Fri, Mar 19, 2021 at 3:13 PM Jonathan Wakely via Libstdc++
<libstd...@gcc.gnu.org> wrote:
>
> Implement this C++23 feature, as proposed by P1048R1.
>
> This implementation assumes that a C++23 compiler supports concepts
> already. I don't see any point in using preprocessor hacks to detect
> compilers which define __cplusplus to a post-C++20 value but don't
> support concepts yet.
>
> libstdc++-v3/ChangeLog:
>
> * include/std/type_traits (is_scoped_enum): Define.
> * include/std/version (__cpp_lib_is_scoped_enum): Define.
> * testsuite/20_util/is_scoped_enum/value.cc: New test.
> * testsuite/20_util/is_scoped_enum/version.cc: New test.
>
> Tested powerpc64le-linux. Committed to trunk.
>
Using __underlying_type breaks for incomplete enumeration types. GCC
doesn't have incomplete scoped enums due to
https://gcc.gnu.org/bugzilla/show_bug.cgi?id=89025 but unscoped ones
exist:
enum E {
x = std::is_scoped_enum_v<E>
};
Thanks, I'll just use int then. Maybe not until Monday though.
Using int avoids the hard error, but it appears to give the wrong
answer (presumably because the is_convertible check fails due to E
being incomplete). This may need to be handled explicitly?
This seems to work, at least until PR 89025 is fixed (because you
can't currently refer to an incomplete scoped enum type).
Tested powerpc64le-linux, pushed to trunk.
commit 43ab1dc24abd6fded8d5bf6547f0de6851beb200
Author: Jonathan Wakely <jwak...@redhat.com>
Date: Thu Apr 8 10:50:57 2021
libstdc++: Make std::is_scoped_enum work with incomplete types
Tim Song pointed out that using __underlying_type is ill-formed for
incomplete enumeration types, and is_scoped_enum doesn't require a
complete type. This changes the trait to check for conversion to int
instead of to the underlying type.
In order to give the correct result when the trait is used in the
enumerator-list of an incomplete type the partial specialization for
enums has an additional check that fails for incomplete types. This
assumes that an incompelte enumeration type must be an unscoped
enumeration, and so the primary template (with a std::false_type base
characteristic) can be used. This isn't necessarily true, but it is not
currently possible to refer to a scoped enumeration type before its type
is complete (PR c++/89025).
It should be possible to use requires(remove_cv_t<_Tp> __t) in the
partial specialization's assignablility check, but that currently gives
an ICE (PR c++/99968) so there is an extra partial specialization of
is_scoped_enum<const _Tp> to handle const types.
libstdc++-v3/ChangeLog:
* include/std/type_traits (is_scoped_enum<T>): Constrain partial
specialization to not match incomplete enum types. Use a
requires-expression instead of instantiating is_convertible.
(is_scoped_enum<const T>): Add as workaround for PR c++/99968.
* testsuite/20_util/is_scoped_enum/value.cc: Check with
incomplete types and opaque-enum-declarations.
diff --git a/libstdc++-v3/include/std/type_traits b/libstdc++-v3/include/std/type_traits
index eeab1ca65fc..1f8b57b04a0 100644
--- a/libstdc++-v3/include/std/type_traits
+++ b/libstdc++-v3/include/std/type_traits
@@ -3287,9 +3287,20 @@ template <typename _From, typename _To>
: false_type
{ };
- template<typename _Tp> requires __is_enum(_Tp)
+ template<typename _Tp>
+ requires __is_enum(_Tp)
+ && requires(_Tp __t) { __t = __t; } // fails if incomplete
struct is_scoped_enum<_Tp>
- : __not_<is_convertible<_Tp, __underlying_type(_Tp)>>::type
+ : bool_constant<!requires(_Tp __t, void(*__f)(int)) { __f(__t); }>
+ { };
+
+ // FIXME remove this partial specialization and use remove_cv_t<_Tp> above
+ // when PR c++/99968 is fixed.
+ template<typename _Tp>
+ requires __is_enum(_Tp)
+ && requires(_Tp __t) { __t = __t; } // fails if incomplete
+ struct is_scoped_enum<const _Tp>
+ : bool_constant<!requires(_Tp __t, void(*__f)(int)) { __f(__t); }>
{ };
template<typename _Tp>
diff --git a/libstdc++-v3/testsuite/20_util/is_scoped_enum/value.cc b/libstdc++-v3/testsuite/20_util/is_scoped_enum/value.cc
index bab7263ae4a..2cef857a042 100644
--- a/libstdc++-v3/testsuite/20_util/is_scoped_enum/value.cc
+++ b/libstdc++-v3/testsuite/20_util/is_scoped_enum/value.cc
@@ -32,6 +32,8 @@ template<typename T>
concept Is_scoped_enum
= __gnu_test::test_category<std::is_scoped_enum, T>(true);
+struct Incomplete_struct;
+
void
test01()
{
@@ -45,6 +47,9 @@ test01()
static_assert( ! Is_scoped_enum<U> );
enum F : int { f1, f2 };
static_assert( ! Is_scoped_enum<F> );
+ static_assert( ! Is_scoped_enum<Incomplete_struct> );
+ struct S;
+ static_assert( ! Is_scoped_enum<S> );
struct S { };
static_assert( ! Is_scoped_enum<S> );
@@ -60,3 +65,36 @@ test01()
static_assert( ! Is_scoped_enum<int(*)()> );
static_assert( ! Is_scoped_enum<int(&)()> );
}
+
+enum opaque_unscoped : short;
+enum class opaque_scoped;
+enum class opaque_scoped_with_base : long;
+
+static_assert( ! Is_scoped_enum<opaque_unscoped> );
+static_assert( Is_scoped_enum<opaque_scoped> );
+static_assert( Is_scoped_enum<opaque_scoped_with_base> );
+
+void
+test02()
+{
+ enum unscoped {
+ u_is_enum = std::is_enum_v<unscoped>,
+ u_is_scoped = std::is_scoped_enum_v<unscoped>,
+ };
+ static_assert( unscoped::u_is_enum );
+ static_assert( ! unscoped::u_is_scoped );
+
+ enum unscoped_fixed : char {
+ uf_is_enum = std::is_enum_v<unscoped_fixed>,
+ uf_is_scoped = std::is_scoped_enum_v<unscoped_fixed>,
+ };
+ static_assert( unscoped_fixed::uf_is_enum);
+ static_assert( ! unscoped_fixed::uf_is_scoped );
+
+ enum class scoped {
+ is_enum = std::is_enum_v<scoped>,
+ is_scoped = std::is_scoped_enum_v<scoped>,
+ };
+ static_assert( (bool) scoped::is_enum );
+ static_assert( (bool) scoped::is_scoped );
+}
