[libc++] [C++2b] [P1048] Add is_scoped_enum and is_scoped_enum_v.

[curdeius]

Summary

• https://wg21.link/p1048

[ldionne]

I think we should update libcxx/docs/Cxx2bStatusPaperStatus.csv.

libcxx/include/type_traits

4186

Pleas remove this newline, or add one before the #endif.

libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_scoped_enum.pass.cpp

68

Can you add a test for a function type (not a function pointer)? Also, for pointer to member function, pointer to data members and other fun things like that?

[Mordante]

libcxx/include/type_traits

289

is_scoped_enumer -> is_scoped_enum.

[curdeius]

libcxx/include/type_traits

289

Gosh, thanks for catching that.
It means that I haven't added tests for _v.

[curdeius]

libcxx/include/type_traits

289

Oh, that's the synopsis.

[Mordante]

libcxx/include/type_traits

289

Yes only the synopsis, the implementation doesn't have the typo.

[curdeius]

Address review comments.

[curdeius]

libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_scoped_enum.pass.cpp

68

Is that what you meant? Any other ideas?

[ldionne]

We're very very close, but there's still a few nits IMO.

libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_scoped_enum.pass.cpp

68

Hmm, almost. I would have used using FunctionType = void() and then test_negative<FunctionType>() instead -- decltype(func1) is resolved as a reference to a function unless I'm mistaken.

89

I don't think this one is necessary, it's the same as testing a scoped enum outside of a class. In my mind, it's akin to testing that a scoped enumeration defined in a namespace behaves correctly -- it's testing the compiler, which isn't necessary IMO.

92

Same, not necessary IMO.

118

Unnecessary IMO, this is just testing long&.

122

Unnecessary IMO, this is just testing long&.

124

Not necessary, this is just testing for int.

[curdeius]

Address comments.

libcxx/docs/Cxx2bStatusPaperStatus.csv

 "Paper #","Group","Paper Name","Meeting","Status","First released version"
 "`P0881R7 <https://wg21.link/P0881R7>`__","LWG","A Proposal to add stacktrace library","Autumn 2020","",""
 "`P0943R6 <https://wg21.link/P0943R6>`__","LWG","Support C atomics in C++","Autumn 2020","",""
-"`P1048R1 <https://wg21.link/P1048R1>`__","LWG","A proposal for a type trait to detect scoped enumerations","Autumn 2020","",""
+"`P1048R1 <https://wg21.link/P1048R1>`__","LWG","A proposal for a type trait to detect scoped enumerations","Autumn 2020","|Complete|","12.0"
 "`P1679R3 <https://wg21.link/P1679R3>`__","LWG","string contains function","Autumn 2020","",""
 "","","","","",""

libcxx/docs/FeatureTestMacroTable.rst

.. table:: Current Status
     ``__cpp_lib_to_address``                          ``201711L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_to_array``                            ``201907L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_unwrap_ref``                          ``201811L``
     ------------------------------------------------- -----------------
     **C++ 2b**
     -------------------------------------------------------------------
-    ``__cpp_lib_is_scoped_enum``                      *unimplemented*
+    ``__cpp_lib_is_scoped_enum``                      ``202011L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_stacktrace``                          *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_stdatomic_h``                         *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_string_contains``                     *unimplemented*
     ================================================= =================
 

libcxx/include/type_traits

namespace std
     template <class T> struct is_class;
     template <class T> struct is_function;
 
     // Secondary classification traits:
     template <class T> struct is_reference;
     template <class T> struct is_arithmetic;
     template <class T> struct is_fundamental;
     template <class T> struct is_member_pointer;
+    template <class T> struct is_scoped_enum; // C++2b
     template <class T> struct is_scalar;
     template <class T> struct is_object;
     template <class T> struct is_compound;
 
     // Const-volatile properties and transformations:
     template <class T> struct is_const;
     template <class T> struct is_volatile;
     template <class T> struct remove_const;
template <class...>
       template <class T> inline constexpr bool is_object_v
         = is_object<T>::value;                                           // C++17
       template <class T> inline constexpr bool is_scalar_v
         = is_scalar<T>::value;                                           // C++17
       template <class T> inline constexpr bool is_compound_v
         = is_compound<T>::value;                                         // C++17
       template <class T> inline constexpr bool is_member_pointer_v
         = is_member_pointer<T>::value;                                   // C++17
+      template <class T> inline constexpr bool is_scoped_enum_v
+        = is_scoped_enum<T>::value;                                      // C++2b
 
       // See C++14 20.10.4.3, type properties
       template <class T> inline constexpr bool is_const_v
         = is_const<T>::value;                                            // C++17
       template <class T> inline constexpr bool is_volatile_v
         = is_volatile<T>::value;                                         // C++17
       template <class T> inline constexpr bool is_trivial_v
         = is_trivial<T>::value;                                          // C++17

 template <class _Tp>
 struct __has_operator_addressof
     : public integral_constant<bool, __has_operator_addressof_member_imp<_Tp>::value
                                   || __has_operator_addressof_free_imp<_Tp>::value>
 {};
 
 #endif  // _LIBCPP_CXX03_LANG
 
+// is_scoped_enum [meta.unary.prop]
+
+#if _LIBCPP_STD_VER > 20
+template <class _Tp, bool = is_enum_v<_Tp> >
+struct __is_scoped_enum_helper : false_type {};
+
+template <class _Tp>
+struct __is_scoped_enum_helper<_Tp, true>
+    : public bool_constant<!is_convertible_v<_Tp, underlying_type_t<_Tp> > > {};
+
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_scoped_enum
+    : public __is_scoped_enum_helper<_Tp> {};
+
+template <class _Tp>
+_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_scoped_enum_v =
+    is_scoped_enum<_Tp>::value;
+#endif
+
 #if _LIBCPP_STD_VER > 14
 
 template <class... _Args>
 struct conjunction : _And<_Args...> {};
 template<class... _Args>
 _LIBCPP_INLINE_VAR constexpr bool conjunction_v
     = conjunction<_Args...>::value;
 

libcxx/include/version

 // # define __cpp_lib_syncbuf                              201803L
 // # define __cpp_lib_three_way_comparison                 201907L
 # define __cpp_lib_to_address                           201711L
 # define __cpp_lib_to_array                             201907L
 # define __cpp_lib_unwrap_ref                           201811L
 #endif
 
 #if _LIBCPP_STD_VER > 20
-// # define __cpp_lib_is_scoped_enum                       202011L
+# define __cpp_lib_is_scoped_enum                       202011L
 // # define __cpp_lib_stacktrace                           202011L
 // # define __cpp_lib_stdatomic_h                          202011L
 // # define __cpp_lib_string_contains                      202011L
 #endif
 
 #endif // _LIBCPP_VERSIONH

libcxx/test/std/language.support/support.limits/support.limits.general/type_traits.version.pass.cpp

 #     error "__cpp_lib_is_pointer_interconvertible should have the value 201907L in c++2b"
 #   endif
 # else // _LIBCPP_VERSION
 #   ifdef __cpp_lib_is_pointer_interconvertible
 #     error "__cpp_lib_is_pointer_interconvertible should not be defined because it is unimplemented in libc++!"
 #   endif
 # endif
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_is_scoped_enum
-#     error "__cpp_lib_is_scoped_enum should be defined in c++2b"
-#   endif
-#   if __cpp_lib_is_scoped_enum != 202011L
-#     error "__cpp_lib_is_scoped_enum should have the value 202011L in c++2b"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_is_scoped_enum
-#     error "__cpp_lib_is_scoped_enum should not be defined because it is unimplemented in libc++!"
-#   endif
-# endif
+#ifndef __cpp_lib_is_scoped_enum
+#error "__cpp_lib_is_scoped_enum should be defined in c++2b"
+#endif
+#if __cpp_lib_is_scoped_enum != 202011L
+#error "__cpp_lib_is_scoped_enum should have the value 202011L in c++2b"
+# endif
 
 # ifndef __cpp_lib_is_swappable
 #   error "__cpp_lib_is_swappable should be defined in c++2b"
 # endif
 # if __cpp_lib_is_swappable != 201603L
 #   error "__cpp_lib_is_swappable should have the value 201603L in c++2b"
 # endif
 

libcxx/test/std/language.support/support.limits/support.limits.general/version.version.pass.cpp

 #     error "__cpp_lib_is_pointer_interconvertible should have the value 201907L in c++2b"
 #   endif
 # else // _LIBCPP_VERSION
 #   ifdef __cpp_lib_is_pointer_interconvertible
 #     error "__cpp_lib_is_pointer_interconvertible should not be defined because it is unimplemented in libc++!"
 #   endif
 # endif
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_is_scoped_enum
-#     error "__cpp_lib_is_scoped_enum should be defined in c++2b"
-#   endif
-#   if __cpp_lib_is_scoped_enum != 202011L
-#     error "__cpp_lib_is_scoped_enum should have the value 202011L in c++2b"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_is_scoped_enum
-#     error "__cpp_lib_is_scoped_enum should not be defined because it is unimplemented in libc++!"
-#   endif
-# endif
+#ifndef __cpp_lib_is_scoped_enum
+#error "__cpp_lib_is_scoped_enum should be defined in c++2b"
+#endif
+#if __cpp_lib_is_scoped_enum != 202011L
+#error "__cpp_lib_is_scoped_enum should have the value 202011L in c++2b"
+# endif
 
 # ifndef __cpp_lib_is_swappable
 #   error "__cpp_lib_is_swappable should be defined in c++2b"
 # endif
 # if __cpp_lib_is_swappable != 201603L
 #   error "__cpp_lib_is_swappable should have the value 201603L in c++2b"
 # endif
 

libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_scoped_enum.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++2a
+
+// type_traits
+
+// is_scoped_enum // C++2b
+
+#include <type_traits>
+#include <cstddef> // for std::nullptr_t
+#include "test_macros.h"
+
+template <class T>
+void test_positive() {
+  static_assert(std::is_scoped_enum<T>::value);
+  static_assert(std::is_scoped_enum<const T>::value);
+  static_assert(std::is_scoped_enum<volatile T>::value);
+  static_assert(std::is_scoped_enum<const volatile T>::value);
+
+  static_assert(std::is_scoped_enum_v<T>);
+  static_assert(std::is_scoped_enum_v<const T>);
+  static_assert(std::is_scoped_enum_v<volatile T>);
+  static_assert(std::is_scoped_enum_v<const volatile T>);
+}
+
+template <class T>
+void test_negative() {
+  static_assert(!std::is_scoped_enum<T>::value);
+  static_assert(!std::is_scoped_enum<const T>::value);
+  static_assert(!std::is_scoped_enum<volatile T>::value);
+  static_assert(!std::is_scoped_enum<const volatile T>::value);
+
+  static_assert(!std::is_scoped_enum_v<T>);
+  static_assert(!std::is_scoped_enum_v<const T>);
+  static_assert(!std::is_scoped_enum_v<volatile T>);
+  static_assert(!std::is_scoped_enum_v<const volatile T>);
+}
+
+class Empty {};
+
+class NotEmpty {
+  virtual ~NotEmpty();
+};
+
+union Union {};
+
+struct bit_zero {
+  int : 0;
+};
+
+class Abstract {
+  virtual ~Abstract() = 0;
+};
+
+enum Enum { zero, one };
+enum class CEnum1 { zero, one };
+enum class CEnum2;
+enum class CEnum3 : short;
+struct incomplete_type;
+
+using FunctionPtr = void (*)();
+using FunctionType = void();
+
+struct TestMembers {
+  static int static_method(int) { return 0; }
+  int method() { return 0; }
+
+  enum E1 { m_zero, m_one };
+  enum class CE1;
+};
+
+void func1();
+int func2(int);
+
+int main(int, char**) {
+  test_positive<CEnum1>();
+  test_positive<CEnum2>();
+  test_positive<CEnum3>();
+  test_positive<TestMembers::CE1>();
+
+  test_negative<Enum>();
+  test_negative<TestMembers::E1>();
+
+  test_negative<std::nullptr_t>();
+  test_negative<void>();
+  test_negative<int>();
+  test_negative<int&>();
+  test_negative<int&&>();
+  test_negative<int*>();
+  test_negative<double>();
+  test_negative<const int*>();
+  test_negative<char[3]>();
+  test_negative<char[]>();
+  test_negative<Union>();
+  test_negative<Empty>();
+  test_negative<bit_zero>();
+  test_negative<NotEmpty>();
+  test_negative<Abstract>();
+  test_negative<FunctionPtr>();
+  test_negative<FunctionType>();
+  test_negative<incomplete_type>();
+  test_negative<int TestMembers::*>();
+  test_negative<void (TestMembers::*)()>();
+
+  test_negative<decltype(func1)>();
+  test_negative<decltype(&func1)>();
+  test_negative<decltype(func2)>();
+  test_negative<decltype(&func2)>();
+  test_negative<decltype(TestMembers::static_method)>();
+  test_negative<decltype(&TestMembers::static_method)>();
+  test_negative<decltype(&TestMembers::method)>();
+
+  return 0;
+}

libcxx/utils/generate_feature_test_macro_components.py

feature_test_macros = [ add_version_header(x) for x in [
     "name": "__cpp_lib_is_pointer_interconvertible",
     "values": { "c++20": 201907 },
     "headers": ["type_traits"],
     "unimplemented": True,
   }, {
     "name": "__cpp_lib_is_scoped_enum",
     "values": { "c++2b": 202011 },
     "headers": ["type_traits"],
-    "unimplemented": True,
   }, {
     "name": "__cpp_lib_is_swappable",
     "values": { "c++17": 201603 },
     "headers": ["type_traits"],
   }, {
     "name": "__cpp_lib_jthread",
     "values": { "c++20": 201911 },
     "headers": ["stop_token", "thread"],