[libc++] Remove _LIBCPP_HAS_NO_STRONG_ENUMS.

[Mordante]

Summary

All supported compilers have implemented this feature.
Therefore use the language version instead of the feature macro.

[ldionne]

I think those should be guarded by a standard version check instead, no?

[• Quuxplusone]

+1 what Louis said; I was gonna say the same thing but he beat me to it. :) I doubt we support any compilers without cxx_strong_enums anymore, right?

[Mordante]

Good point. It also seems Clang only supports it in C++11 and not in C++03.
In that case I prefer to remove _LIBCPP_HAS_NO_STRONG_ENUMS from the codebase and test for C++03 instead.
That the _LIBCPP_DECLARE_STRONG_ENUM macros will be gated by the language version.
Agreed on this approach?

[• Quuxplusone]

In D119865#3326789, @Mordante wrote:

Good point. It also seems Clang only supports it in C++11 and not in C++03.
In that case I prefer to remove _LIBCPP_HAS_NO_STRONG_ENUMS from the codebase and test for C++03 instead.
That the _LIBCPP_DECLARE_STRONG_ENUM macros will be gated by the language version.
Agreed on this approach?

SGTM!
(I wondered if the _LIBCPP_DECLARE_STRONG_ENUM macro could be completely eliminated, but no, I see that we do have at least one use, in <ios>, that needs to keep working in C++03 mode. And also in <future> for some reason; and maybe all its uses.)

[• Quuxplusone]

To clarify in case it's needed: The guard around define _LIBCPP_DECLARE_STRONG_ENUM(x) should now use #if defined(_LIBCPP_CXX03_LANG). The macro _LIBCPP_HAS_NO_STRONG_ENUMS should vanish.

libcxx/test/std/utilities/meta/meta.trans/meta.trans.sign/make_unsigned.pass.cpp

29

To clarify in case it's needed: This should now use TEST_STD_VER >= 11.

[Mordante]

In D119865#3327222, @Quuxplusone wrote:

To clarify in case it's needed: The guard around define _LIBCPP_DECLARE_STRONG_ENUM(x) should now use #if defined(_LIBCPP_CXX03_LANG). The macro _LIBCPP_HAS_NO_STRONG_ENUMS should vanish.

Correct that is the plan. So I revert this patch locally and grep for _LIBCPP_HAS_NO_STRONG_ENUMS, replace it with the proper version macro and reuse this review for the new approach.

[Mordante]

Use the language version instead of the feature test.

[• Quuxplusone]

Feel free to poke @ldionne and wait for his approval, but IMNSHO this patch now conforms to everything Louis was asking for. :) Thanks for doing this!

[Mordante]

Rebased to see test whether CI passes.

[ldionne]

Thanks!

libcxx/include/__config

 typedef __char16_t char16_t;
 typedef __char32_t char32_t;
 #endif
 
 #if !__has_feature(cxx_exceptions)
 #  define _LIBCPP_NO_EXCEPTIONS
 #endif
 
-#if !(__has_feature(cxx_strong_enums))
-#define _LIBCPP_HAS_NO_STRONG_ENUMS
-#endif
-
 #if __has_feature(cxx_attributes)
 #  define _LIBCPP_NORETURN [[noreturn]]
 #else
 #  define _LIBCPP_NORETURN __attribute__ ((noreturn))
 #endif
 
 #ifdef _LIBCPP_CXX03_LANG
 # define nullptr __nullptr

 #endif
 
 #if __has_attribute(using_if_exists)
 # define _LIBCPP_USING_IF_EXISTS __attribute__((using_if_exists))
 #else
 # define _LIBCPP_USING_IF_EXISTS
 #endif
 
-#ifdef _LIBCPP_HAS_NO_STRONG_ENUMS
+#ifdef _LIBCPP_CXX03_LANG
 #  define _LIBCPP_DECLARE_STRONG_ENUM(x) struct _LIBCPP_TYPE_VIS x { enum __lx
 #  define _LIBCPP_DECLARE_STRONG_ENUM_EPILOG(x) \
      __lx __v_; \
      _LIBCPP_INLINE_VISIBILITY x(__lx __v) : __v_(__v) {} \
      _LIBCPP_INLINE_VISIBILITY explicit x(int __v) : __v_(static_cast<__lx>(__v)) {} \
      _LIBCPP_INLINE_VISIBILITY operator int() const {return __v_;} \
      };
-#else  // _LIBCPP_HAS_NO_STRONG_ENUMS
+#else  // _LIBCPP_CXX03_LANG
 #  define _LIBCPP_DECLARE_STRONG_ENUM(x) enum class _LIBCPP_ENUM_VIS x
 #  define _LIBCPP_DECLARE_STRONG_ENUM_EPILOG(x)
-#endif // _LIBCPP_HAS_NO_STRONG_ENUMS
+#endif // _LIBCPP_CXX03_LANG
 
 // _LIBCPP_DEBUG potential values:
 //  - undefined: No assertions. This is the default.
 //  - 0:         Basic assertions
 //  - 1:         Basic assertions + iterator validity checks + unspecified behavior randomization.
 #  if !defined(_LIBCPP_DEBUG)
 #    define _LIBCPP_DEBUG_LEVEL 0
 #  elif _LIBCPP_DEBUG == 0

libcxx/include/future

_LIBCPP_DECLARE_STRONG_ENUM(future_errc)
     no_state,
     broken_promise
 };
 _LIBCPP_DECLARE_STRONG_ENUM_EPILOG(future_errc)
 
 template <>
 struct _LIBCPP_TEMPLATE_VIS is_error_code_enum<future_errc> : public true_type {};
 
-#ifdef _LIBCPP_HAS_NO_STRONG_ENUMS
+#ifdef _LIBCPP_CXX03_LANG
 template <>
 struct _LIBCPP_TEMPLATE_VIS is_error_code_enum<future_errc::__lx> : public true_type { };
 #endif
 
 //enum class launch
 _LIBCPP_DECLARE_STRONG_ENUM(launch)
 {
     async = 1,
     deferred = 2,
     any = async | deferred
 };
 _LIBCPP_DECLARE_STRONG_ENUM_EPILOG(launch)
 
-#ifndef _LIBCPP_HAS_NO_STRONG_ENUMS
+#ifndef _LIBCPP_CXX03_LANG
 
 typedef underlying_type<launch>::type __launch_underlying_type;
 
 inline _LIBCPP_INLINE_VISIBILITY
 _LIBCPP_CONSTEXPR
 launch
 operator&(launch __x, launch __y)
 {

 
 inline _LIBCPP_INLINE_VISIBILITY
 launch&
 operator^=(launch& __x, launch __y)
 {
     __x = __x ^ __y; return __x;
 }
 
-#endif // !_LIBCPP_HAS_NO_STRONG_ENUMS
+#endif // !_LIBCPP_CXX03_LANG
 
 //enum class future_status
 _LIBCPP_DECLARE_STRONG_ENUM(future_status)
 {
     ready,
     timeout,
     deferred
 };

libcxx/include/ios

 {
     stream = 1
 };
 _LIBCPP_DECLARE_STRONG_ENUM_EPILOG(io_errc)
 
 template <>
 struct _LIBCPP_TEMPLATE_VIS is_error_code_enum<io_errc> : public true_type { };
 
-#ifdef _LIBCPP_HAS_NO_STRONG_ENUMS
+#ifdef _LIBCPP_CXX03_LANG
 template <>
 struct _LIBCPP_TEMPLATE_VIS is_error_code_enum<io_errc::__lx> : public true_type { };
 #endif
 
 _LIBCPP_FUNC_VIS
 const error_category& iostream_category() _NOEXCEPT;
 
 inline _LIBCPP_INLINE_VISIBILITY

libcxx/include/system_error

 template <class _Tp>
 inline constexpr bool is_error_condition_enum_v = is_error_condition_enum<_Tp>::value;
 #endif
 
 template <>
 struct _LIBCPP_TEMPLATE_VIS is_error_condition_enum<errc>
     : true_type { };
 
-#ifdef _LIBCPP_HAS_NO_STRONG_ENUMS
+#ifdef _LIBCPP_CXX03_LANG
 template <>
 struct _LIBCPP_TEMPLATE_VIS is_error_condition_enum<errc::__lx>
     : true_type { };
 #endif
 
 class _LIBCPP_TYPE_VIS error_condition;
 class _LIBCPP_TYPE_VIS error_code;
 

libcxx/test/std/thread/futures/futures.overview/launch.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: libcpp-has-no-threads

 
 #include <future>
 #include <cassert>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
-#ifdef _LIBCPP_HAS_NO_STRONG_ENUMS
+#if TEST_STD_VER < 11
    LIBCPP_STATIC_ASSERT(static_cast<int>(std::launch::any) ==
                  (static_cast<int>(std::launch::async) | static_cast<int>(std::launch::deferred)), "");
 #else
     LIBCPP_STATIC_ASSERT(std::launch::any == (std::launch::async | std::launch::deferred), "");
     static_assert(std::launch(0) == (std::launch::async & std::launch::deferred), "");
     LIBCPP_STATIC_ASSERT(std::launch::any == (std::launch::async ^ std::launch::deferred), "");
     LIBCPP_STATIC_ASSERT(std::launch::deferred == ~std::launch::async, "");
     std::launch x = std::launch::async;

libcxx/test/std/utilities/meta/meta.trans/meta.trans.sign/make_signed.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
 //
 //===----------------------------------------------------------------------===//
 
 // type_traits

 #else
 enum BigEnum
 #endif
 {
     bigzero,
     big = 0xFFFFFFFFFFFFFFFFULL
 };
 
-#if !defined(TEST_HAS_NO_INT128) && !defined(_LIBCPP_HAS_NO_STRONG_ENUMS)
+#if !defined(TEST_HAS_NO_INT128) && TEST_STD_VER >= 11
 enum HugeEnum : __uint128_t
 {
     hugezero
 };
 #endif
 
 template <class T, class U>
 void test_make_signed()
int main(int, char**)
     test_make_signed< unsigned long long, signed long long >();
     test_make_signed< wchar_t, std::conditional<sizeof(wchar_t) == 4, int, short>::type >();
     test_make_signed< const wchar_t, std::conditional<sizeof(wchar_t) == 4, const int, const short>::type >();
     test_make_signed< const Enum, std::conditional<sizeof(Enum) == sizeof(int), const int, const signed char>::type >();
     test_make_signed< BigEnum, std::conditional<sizeof(long) == 4, long long, long>::type >();
 #ifndef TEST_HAS_NO_INT128
     test_make_signed< __int128_t, __int128_t >();
     test_make_signed< __uint128_t, __int128_t >();
-# ifndef _LIBCPP_HAS_NO_STRONG_ENUMS
+# if TEST_STD_VER >= 11
     test_make_signed< HugeEnum, __int128_t >();
 # endif
 #endif
 
   return 0;
 }

libcxx/test/std/utilities/meta/meta.trans/meta.trans.sign/make_unsigned.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
 //
 //===----------------------------------------------------------------------===//
 
 // type_traits

 #else
 enum BigEnum
 #endif
 {
     bigzero,
     big = 0xFFFFFFFFFFFFFFFFULL
 };
 
-#if !defined(TEST_HAS_NO_INT128) && !defined(_LIBCPP_HAS_NO_STRONG_ENUMS)
+#if !defined(TEST_HAS_NO_INT128) && TEST_STD_VER >= 11
 enum HugeEnum : __int128_t
 {
     hugezero
 };
 #endif
 
 template <class T, class U>
 void test_make_unsigned()
int main(int, char**)
     test_make_unsigned<wchar_t, std::conditional<sizeof(wchar_t) == 4, unsigned int, unsigned short>::type> ();
     test_make_unsigned<const wchar_t, std::conditional<sizeof(wchar_t) == 4, const unsigned int, const unsigned short>::type> ();
     test_make_unsigned<const Enum, std::conditional<sizeof(Enum) == sizeof(int), const unsigned int, const unsigned char>::type >();
     test_make_unsigned<BigEnum,
                    std::conditional<sizeof(long) == 4, unsigned long long, unsigned long>::type> ();
 #ifndef TEST_HAS_NO_INT128
     test_make_unsigned<__int128_t, __uint128_t>();
     test_make_unsigned<__uint128_t, __uint128_t>();
-# ifndef _LIBCPP_HAS_NO_STRONG_ENUMS
+# if TEST_STD_VER >= 11
     test_make_unsigned<HugeEnum, __uint128_t>();
 # endif
 #endif
 
   return 0;
 }