[libc++] [C++2b] [P1682] Add to_underlying.

[curdeius]

Summary

• https://wg21.link/P1682

[Mordante]

libcxx/include/utility

1636

Would it be possible to make it available for earlier versions? I like to use this in D97115? I'm aware we're reluctant to offer features to earlier versions.

1638

The inline isn't needed.

libcxx/test/std/utilities/utility/utility.underlying/to_underlying.pass.cpp

24

Maybe interesting to also test these bounds for an plain enum.

28

This isn't used in the tests below.

libcxx/utils/generate_feature_test_macro_components.py

598

The paper has no number. Is it certain this will be the final value?

[curdeius]

libcxx/test/std/utilities/utility/utility.underlying/to_underlying.pass.cpp

24

Ok, will do.

28

It is in the last 3 assertions.

libcxx/utils/generate_feature_test_macro_components.py

598

I'll wait for the draft to be updated before committing I think to confirm the value.

[Mordante]

libcxx/test/std/utilities/utility/utility.underlying/to_underlying.pass.cpp

28

A yes my bad.

[curdeius]

Address review comments:

• Remove unnecessary inline.
• Add plain enum tests.
• Expose __to_underlying in C++14 onwards.

[curdeius]

libcxx/include/utility

1636

Would this be OK?

libcxx/utils/generate_feature_test_macro_components.py

598

I'm pretty sure it will be the final value, since another feature approved in the same meeting uses this value. Cf. https://github.com/cplusplus/draft/pull/4515/files#diff-f46371f476893d323cfcb1383e9a70f07ff1c1f0c217e22294d0bf937aae6794R696.

[curdeius]

libcxx/include/utility

1647

I wish we had using to_underlying = __to_underlying;.

[Mordante]

One small request otherwise LGTM.

libcxx/include/utility

1640

Since we also use bitmask types in C++11, would it be possible to make this available in C++11? std::underlying_type is available in C++11.

libcxx/utils/generate_feature_test_macro_components.py

598

Sounds good enough to me. If it's wrong it's also trivial to fix.

[Mordante]

libcxx/utils/generate_feature_test_macro_components.py

598

I see there's a PR for this paper using 202102L so this looks good. https://github.com/cplusplus/draft/pull/4526/commits/47fd349eef8e4bdf5cdaed9513505f903d5e8f38

[curdeius]

• Expose __to_underlying in C++11 onwards.

[Mordante]

In D97365#2589584, @curdeius wrote:

• Expose __to_underlying in C++11 onwards.

Thanks!

[zoecarver]

libcxx/include/utility

1632

Nit: you could use underlying_type_t here.

libcxx/test/std/utilities/utility/utility.underlying/to_underlying.fail.cpp

9 ↗

(On Diff #326613)

Are we going to retire the c++2a alias at some point? Maybe this should be c++20 instead.

[curdeius]

libcxx/include/utility

1632

I can't, it's C++14 onwards.

#if _LIBCPP_STD_VER > 11
template <class _Tp> using underlying_type_t = typename underlying_type<_Tp>::type;
#endif

libcxx/test/std/utilities/utility/utility.underlying/to_underlying.fail.cpp

9 ↗

(On Diff #326613)

Hmm, when all compilers we support will accept -std=c++20?
IIUC, that's because lit std param is verified by injecting into -std=..., so we can't just use c++20 on a compiler that only accepts -std=c++2a.
Maybe there's some clever hack on lit params to translate c++20 into c++2a if the former isn't supported.
But I haven't looked into it.

[• Quuxplusone]

libcxx/include/utility

1640

Your friendly neighborhood ADL-hater says: _VSTD::__to_underlying

libcxx/test/std/utilities/utility/utility.underlying/to_underlying.fail.cpp

9 ↗

(On Diff #326613)

My (untested) impression is that

• we cannot change only this c++2a to c++20, because this needs to exactly match llvm-lit's name --param std=c++2a
• we SHOULD change llvm-lit to use --param std=c++20, AND to add --param std=c++2b at the same time; but this change is above my pay grade
• one reason that change is difficult is because llvm-lit's --param std=c++XX relates, in some (non-obvious-to-me) way, to whether the actual compiler supports a -std=c++XX option. That entanglement SHOULD NOT exist, but it does. (We SHOULD just teach llvm-lit to map std=c++20 onto -std=c++{20,2a} depending on compiler support.)
• and maybe the above change would require re-configuring or re-deploying buildkite and/or other infrastructure in ways that a simple "git push" wouldn't accomplish. I don't know and am scared to assume.

libcxx/test/std/utilities/utility/utility.underlying/to_underlying.pass.cpp

62

I would be interested to see how std::to_underlying(s.bf) works on an enum bit-field. I know that's more of a core-language-trivia issue than a library-trivia issue, but it'd still be nice to have a test case.

And if you can construct a test case for the ADL issue (maybe involving enum X<Holder<Incomplete>>::E? I'd have to look up the rules again), that'd be cool (but not a blocker).

[curdeius]

• Qualify.
• Test bit-field enums.

[curdeius]

• Add ADL test.

[curdeius]

libcxx/test/std/utilities/utility/utility.underlying/to_underlying.pass.cpp

62

Done.
I've already started answering that I cannot find a test case for that and then I found it :).

[Mordante]

libcxx/include/utility

1632

Nit: you could use underlying_type_t here.

I asked for C++11 support so I can use it in D97115.

libcxx/test/std/utilities/utility/utility.underlying/to_underlying.fail.cpp

9 ↗

(On Diff #326613)

There's already support for c++2b. Personally I don't mind 2a in our tests and once all supported platforms support -std=c++20 we can change it in one go. Or would you also prefer to use 23 already? I get the impression the Standard committee feels more comfortable about their 3 year schedule and are already using C++23 instead of C++2b. (Note I'm not a member of the committee.)

[• Quuxplusone]

libcxx/test/std/utilities/utility/utility.underlying/to_underlying.fail.cpp

9 ↗

(On Diff #326613)

I think that llvm-lit should add support for --param std=c++20 on the same day that Clang adds support for -std=c++20. (This will require llvm-lit to understand that on certain kinds of buildbots, --param std=c++20 translates into -std=c++2a; but I think this must be a small change, because it already needs to understand that on certain kinds of buildbots, --param std=c++20 simply doesn't work at all.)

Severably, I think that Clang should add support for -std=c++2b on the same day that Clang adds support for -std=c++20.

Severably, I think that llvm-lit should add support for -std=c++2b on the same day that llvm-lit adds support for -std=c++20.

Of course the horse has already left the barn on all of these bullet points. But translate them all up by 3 (2a->2b, 20->23, 2b->2c) and they describe what I think should happen in the future. I think there should be a "deploy plan" for going from 17/2a, to 17/20/2b, to 17/20/23/2c, and each time it's executed it should be executed relatively atomically, without months or years of dangling loose ends. The situation described in https://stackoverflow.com/a/56483887/1424877 is pretty embarrassing for all three compiler vendors, IMO.

[• Quuxplusone]

Code LGTM (modulo please remove the ADL test).
I'm not sure I understand the state of the world re: has this landed in C++2b yet? do we run C++2b tests yet? and is it March 8 yet? ;) so I don't want to be the one to say "accept". But I'm unlikely to have any further review comments, and certainly have no desire to block this if someone else wants to accept it.

libcxx/test/std/utilities/utility/utility.underlying/robust_against_adl.pass.cpp

42 ↗

(On Diff #328225)

I don't think this is a reasonable thing to test; the user can't do this. (At least, if they do, we should laugh in their face.)

I believe I've convinced myself that there is no way to write a test for this VSTD-qualification. The only associated type of an enum is the-class-of-which-it-is-a-member, and that class must already be complete, by definition, so we can't use the Holder<Incomplete> trick to hard-error on completing it.
https://quuxplusone.github.io/blog/2019/04/26/what-is-adl/#for-example

Of course you should still do the VSTD-qualification, for consistent libc++ style if nothing else. But I strongly vote for removing this robust_against_adl test, because it does things (reopening namespace std) that the user really isn't allowed to do.

[curdeius]

In D97365#2604684, @Quuxplusone wrote:

Code LGTM (modulo please remove the ADL test).
I'm not sure I understand the state of the world re: has this landed in C++2b yet? do we run C++2b tests yet? and is it March 8 yet? ;) so I don't want to be the one to say "accept". But I'm unlikely to have any further review comments, and certainly have no desire to block this if someone else wants to accept it.

So, yes we do test in C++2b mode, for a few weeks at least already.
And yes, it has been approved for C++2b. The draft is not yet updated, but there is a PR for that (https://github.com/cplusplus/draft/pull/4526).
And, I'll remove the ADL test.

libcxx/test/std/utilities/utility/utility.underlying/robust_against_adl.pass.cpp

42 ↗

(On Diff #328225)

Agreed.

[ldionne]

If the paper has been voted into the Standard, then I think it's fine for us to implement it. It seems to be the case, so let's ship it.

Apart from that and the other minor comments by reviewers, I think this is good to go.

libcxx/include/utility

1640

Just to be clear, we don't provide new features in older standard modes. It's fine to expose __to_underlying pre C++2b so you can use it to implement other stuff, but it has to come at no significant additional cost (OK here). But we *do not* expose std::to_underlying pre C++2b -- not sure which one you were asking about.

libcxx/test/std/utilities/utility/utility.underlying/to_underlying.fail.cpp

9 ↗

(On Diff #326613)

The Lit issue will *soon* become moot once we stop supporting older compilers anyway. I suggest we don't do anything about this and just pinch our nose for a couple more months.

1 ↗

(On Diff #328225)

This should be a .verify.cpp test instead!

[curdeius]

• Remove ADL test.
• Rename fail -> verify.

libcxx/include/utility

1640

Yes, the idea was to expose __to_underlying (but not std::to_underlying) in pre C++2b, so that it can be used for bitmask types.

[zoecarver]

libcxx/include/utility

1632

Ah, thanks. Sorry, missed that.

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","|Complete|","12.0"
 "`P1679R3 <https://wg21.link/P1679R3>`__","LWG","string contains function","Autumn 2020","|Complete|","12.0"
 "","","","","",""
-"`P1682R3 <https://wg21.link/P1682R3>`__","LWG","std::to_underlying for enumerations","February 2021","",""
+"`P1682R3 <https://wg21.link/P1682R3>`__","LWG","std::to_underlying for enumerations","February 2021","|Complete|","13.0"
 "`P2017R1 <https://wg21.link/P2017R1>`__","LWG","Conditionally borrowed ranges","February 2021","",""
 "`P2160R1 <https://wg21.link/P2160R1>`__","LWG","Locks lock lockables","February 2021","",""
 "`P2162R2 <https://wg21.link/P2162R2>`__","LWG","Inheriting from std::variant","February 2021","",""
 "`P2212R2 <https://wg21.link/P2212R2>`__","LWG","Relax Requirements for time_point::clock","February 2021","",""
 "`P2259R1 <https://wg21.link/P2259R1>`__","LWG","Repairing input range adaptors and counted_iterator","February 2021","",""
 "","","","","",""

libcxx/docs/FeatureTestMacroTable.rst

.. table:: Current Status
     -------------------------------------------------------------------
     ``__cpp_lib_is_scoped_enum``                      ``202011L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_stacktrace``                          *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_stdatomic_h``                         *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_string_contains``                     ``202011L``
+    ------------------------------------------------- -----------------
+    ``__cpp_lib_to_underlying``                       ``202102L``
     ================================================= =================
 

libcxx/include/utility

template <class T>
   inline constexpr in_place_type_t<T> in_place_type{};
 template <size_t I>
   struct in_place_index_t {
     explicit in_place_index_t() = default;
   };
 template <size_t I>
   inline constexpr in_place_index_t<I> in_place_index{};
 
+// [utility.underlying], to_underlying
+template <class T>
+    constexpr underlying_type_t<T> to_underlying( T value ) noexcept; // C++2b
+
 }  // std
 
 */
 
 #include <__config>
 #include <__tuple>
 #include <type_traits>
 #include <initializer_list>

 using __enable_hash_helper _LIBCPP_NODEBUG_TYPE  = __enable_hash_helper_imp<_Type,
   typename enable_if<__all<__has_enabled_hash<_Keys>::value...>::value>::type
 >;
 #else
 template <class _Type, class ...>
 using __enable_hash_helper _LIBCPP_NODEBUG_TYPE = _Type;
 #endif
 
+template <class _Tp>
+_LIBCPP_INLINE_VISIBILITY constexpr typename underlying_type<_Tp>::type
+__to_underlying(_Tp __val) noexcept {
+  return static_cast<typename underlying_type<_Tp>::type>(__val);
+}
 #endif // !_LIBCPP_CXX03_LANG
 
+#if _LIBCPP_STD_VER > 20
+template <class _Tp>
+_LIBCPP_INLINE_VISIBILITY constexpr underlying_type_t<_Tp>
+to_underlying(_Tp __val) noexcept {
+  return _VSTD::__to_underlying(__val);
+}
+#endif
+
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP_UTILITY

libcxx/include/version

 __cpp_lib_string_udls                                   201304L <string>
 __cpp_lib_string_view                                   201803L <string> <string_view>
                                                         201606L // C++17
 __cpp_lib_syncbuf                                       201803L <syncstream>
 __cpp_lib_three_way_comparison                          201907L <compare>
 __cpp_lib_to_address                                    201711L <memory>
 __cpp_lib_to_array                                      201907L <array>
 __cpp_lib_to_chars                                      201611L <utility>
+__cpp_lib_to_underlying                                 202102L <utility>
 __cpp_lib_transformation_trait_aliases                  201304L <type_traits>
 __cpp_lib_transparent_operators                         201510L <functional> <memory>
                                                         201210L // C++14
 __cpp_lib_tuple_element_t                               201402L <tuple>
 __cpp_lib_tuples_by_type                                201304L <tuple> <utility>
 __cpp_lib_type_trait_variable_templates                 201510L <type_traits>
 __cpp_lib_uncaught_exceptions                           201411L <exception>
 __cpp_lib_unordered_map_try_emplace                     201411L <unordered_map>

 # define __cpp_lib_unwrap_ref                           201811L
 #endif
 
 #if _LIBCPP_STD_VER > 20
 # define __cpp_lib_is_scoped_enum                       202011L
 // # define __cpp_lib_stacktrace                           202011L
 // # define __cpp_lib_stdatomic_h                          202011L
 # define __cpp_lib_string_contains                      202011L
+# define __cpp_lib_to_underlying                        202102L
 #endif
 
 // clang-format on
 
 #endif // _LIBCPP_VERSIONH

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

 
 /*  Constant                                  Value
     __cpp_lib_as_const                        201510L [C++17]
     __cpp_lib_constexpr_utility               201811L [C++20]
     __cpp_lib_exchange_function               201304L [C++14]
     __cpp_lib_integer_comparison_functions    202002L [C++20]
     __cpp_lib_integer_sequence                201304L [C++14]
     __cpp_lib_to_chars                        201611L [C++17]
+    __cpp_lib_to_underlying                   202102L [C++2b]
     __cpp_lib_tuples_by_type                  201304L [C++14]
 */
 
 #include <utility>
 #include "test_macros.h"
 
 #if TEST_STD_VER < 14
 

 # ifdef __cpp_lib_integer_sequence
 #   error "__cpp_lib_integer_sequence should not be defined before c++14"
 # endif
 
 # ifdef __cpp_lib_to_chars
 #   error "__cpp_lib_to_chars should not be defined before c++17"
 # endif
 
+# ifdef __cpp_lib_to_underlying
+#   error "__cpp_lib_to_underlying should not be defined before c++2b"
+# endif
+
 # ifdef __cpp_lib_tuples_by_type
 #   error "__cpp_lib_tuples_by_type should not be defined before c++14"
 # endif
 
 #elif TEST_STD_VER == 14
 
 # ifdef __cpp_lib_as_const
 #   error "__cpp_lib_as_const should not be defined before c++17"

 # if __cpp_lib_integer_sequence != 201304L
 #   error "__cpp_lib_integer_sequence should have the value 201304L in c++14"
 # endif
 
 # ifdef __cpp_lib_to_chars
 #   error "__cpp_lib_to_chars should not be defined before c++17"
 # endif
 
+# ifdef __cpp_lib_to_underlying
+#   error "__cpp_lib_to_underlying should not be defined before c++2b"
+# endif
+
 # ifndef __cpp_lib_tuples_by_type
 #   error "__cpp_lib_tuples_by_type should be defined in c++14"
 # endif
 # if __cpp_lib_tuples_by_type != 201304L
 #   error "__cpp_lib_tuples_by_type should have the value 201304L in c++14"
 # endif
 
 #elif TEST_STD_VER == 17

 #     error "__cpp_lib_to_chars should have the value 201611L in c++17"
 #   endif
 # else // _LIBCPP_VERSION
 #   ifdef __cpp_lib_to_chars
 #     error "__cpp_lib_to_chars should not be defined because it is unimplemented in libc++!"
 #   endif
 # endif
 
+# ifdef __cpp_lib_to_underlying
+#   error "__cpp_lib_to_underlying should not be defined before c++2b"
+# endif
+
 # ifndef __cpp_lib_tuples_by_type
 #   error "__cpp_lib_tuples_by_type should be defined in c++17"
 # endif
 # if __cpp_lib_tuples_by_type != 201304L
 #   error "__cpp_lib_tuples_by_type should have the value 201304L in c++17"
 # endif
 
 #elif TEST_STD_VER == 20

 #     error "__cpp_lib_to_chars should have the value 201611L in c++20"
 #   endif
 # else // _LIBCPP_VERSION
 #   ifdef __cpp_lib_to_chars
 #     error "__cpp_lib_to_chars should not be defined because it is unimplemented in libc++!"
 #   endif
 # endif
 
+# ifdef __cpp_lib_to_underlying
+#   error "__cpp_lib_to_underlying should not be defined before c++2b"
+# endif
+
 # ifndef __cpp_lib_tuples_by_type
 #   error "__cpp_lib_tuples_by_type should be defined in c++20"
 # endif
 # if __cpp_lib_tuples_by_type != 201304L
 #   error "__cpp_lib_tuples_by_type should have the value 201304L in c++20"
 # endif
 
 #elif TEST_STD_VER > 20

 #     error "__cpp_lib_to_chars should have the value 201611L in c++2b"
 #   endif
 # else // _LIBCPP_VERSION
 #   ifdef __cpp_lib_to_chars
 #     error "__cpp_lib_to_chars should not be defined because it is unimplemented in libc++!"
 #   endif
 # endif
 
+# ifndef __cpp_lib_to_underlying
+#   error "__cpp_lib_to_underlying should be defined in c++2b"
+# endif
+# if __cpp_lib_to_underlying != 202102L
+#   error "__cpp_lib_to_underlying should have the value 202102L in c++2b"
+# endif
+
 # ifndef __cpp_lib_tuples_by_type
 #   error "__cpp_lib_tuples_by_type should be defined in c++2b"
 # endif
 # if __cpp_lib_tuples_by_type != 201304L
 #   error "__cpp_lib_tuples_by_type should have the value 201304L in c++2b"
 # endif
 
 #endif // TEST_STD_VER > 20
 
 int main(int, char**) { return 0; }

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

/*  Constant                                       Value
     __cpp_lib_string_udls                          201304L [C++14]
     __cpp_lib_string_view                          201606L [C++17]
                                                    201803L [C++20]
     __cpp_lib_syncbuf                              201803L [C++20]
     __cpp_lib_three_way_comparison                 201907L [C++20]
     __cpp_lib_to_address                           201711L [C++20]
     __cpp_lib_to_array                             201907L [C++20]
     __cpp_lib_to_chars                             201611L [C++17]
+    __cpp_lib_to_underlying                        202102L [C++2b]
     __cpp_lib_transformation_trait_aliases         201304L [C++14]
     __cpp_lib_transparent_operators                201210L [C++14]
                                                    201510L [C++17]
     __cpp_lib_tuple_element_t                      201402L [C++14]
     __cpp_lib_tuples_by_type                       201304L [C++14]
     __cpp_lib_type_trait_variable_templates        201510L [C++17]
     __cpp_lib_uncaught_exceptions                  201411L [C++17]
     __cpp_lib_unordered_map_try_emplace            201411L [C++17]

 # ifdef __cpp_lib_to_array
 #   error "__cpp_lib_to_array should not be defined before c++20"
 # endif
 
 # ifdef __cpp_lib_to_chars
 #   error "__cpp_lib_to_chars should not be defined before c++17"
 # endif
 
+# ifdef __cpp_lib_to_underlying
+#   error "__cpp_lib_to_underlying should not be defined before c++2b"
+# endif
+
 # ifdef __cpp_lib_transformation_trait_aliases
 #   error "__cpp_lib_transformation_trait_aliases should not be defined before c++14"
 # endif
 
 # ifdef __cpp_lib_transparent_operators
 #   error "__cpp_lib_transparent_operators should not be defined before c++14"
 # endif
 

 # ifdef __cpp_lib_to_array
 #   error "__cpp_lib_to_array should not be defined before c++20"
 # endif
 
 # ifdef __cpp_lib_to_chars
 #   error "__cpp_lib_to_chars should not be defined before c++17"
 # endif
 
+# ifdef __cpp_lib_to_underlying
+#   error "__cpp_lib_to_underlying should not be defined before c++2b"
+# endif
+
 # ifndef __cpp_lib_transformation_trait_aliases
 #   error "__cpp_lib_transformation_trait_aliases should be defined in c++14"
 # endif
 # if __cpp_lib_transformation_trait_aliases != 201304L
 #   error "__cpp_lib_transformation_trait_aliases should have the value 201304L in c++14"
 # endif
 
 # ifndef __cpp_lib_transparent_operators

 #     error "__cpp_lib_to_chars should have the value 201611L in c++17"
 #   endif
 # else // _LIBCPP_VERSION
 #   ifdef __cpp_lib_to_chars
 #     error "__cpp_lib_to_chars should not be defined because it is unimplemented in libc++!"
 #   endif
 # endif
 
+# ifdef __cpp_lib_to_underlying
+#   error "__cpp_lib_to_underlying should not be defined before c++2b"
+# endif
+
 # ifndef __cpp_lib_transformation_trait_aliases
 #   error "__cpp_lib_transformation_trait_aliases should be defined in c++17"
 # endif
 # if __cpp_lib_transformation_trait_aliases != 201304L
 #   error "__cpp_lib_transformation_trait_aliases should have the value 201304L in c++17"
 # endif
 
 # ifndef __cpp_lib_transparent_operators

 #     error "__cpp_lib_to_chars should have the value 201611L in c++20"
 #   endif
 # else // _LIBCPP_VERSION
 #   ifdef __cpp_lib_to_chars
 #     error "__cpp_lib_to_chars should not be defined because it is unimplemented in libc++!"
 #   endif
 # endif
 
+# ifdef __cpp_lib_to_underlying
+#   error "__cpp_lib_to_underlying should not be defined before c++2b"
+# endif
+
 # ifndef __cpp_lib_transformation_trait_aliases
 #   error "__cpp_lib_transformation_trait_aliases should be defined in c++20"
 # endif
 # if __cpp_lib_transformation_trait_aliases != 201304L
 #   error "__cpp_lib_transformation_trait_aliases should have the value 201304L in c++20"
 # endif
 
 # ifndef __cpp_lib_transparent_operators

 #     error "__cpp_lib_to_chars should have the value 201611L in c++2b"
 #   endif
 # else // _LIBCPP_VERSION
 #   ifdef __cpp_lib_to_chars
 #     error "__cpp_lib_to_chars should not be defined because it is unimplemented in libc++!"
 #   endif
 # endif
 
+# ifndef __cpp_lib_to_underlying
+#   error "__cpp_lib_to_underlying should be defined in c++2b"
+# endif
+# if __cpp_lib_to_underlying != 202102L
+#   error "__cpp_lib_to_underlying should have the value 202102L in c++2b"
+# endif
+
 # ifndef __cpp_lib_transformation_trait_aliases
 #   error "__cpp_lib_transformation_trait_aliases should be defined in c++2b"
 # endif
 # if __cpp_lib_transformation_trait_aliases != 201304L
 #   error "__cpp_lib_transformation_trait_aliases should have the value 201304L in c++2b"
 # endif
 
 # ifndef __cpp_lib_transparent_operators

libcxx/test/std/utilities/utility/utility.underlying/to_underlying.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
+
+// [utility.underlying], to_underlying
+// template <class T>
+//     constexpr underlying_type_t<T> to_underlying( T value ) noexcept; // C++2b
+
+#include <utility>
+#include <cassert>
+#include <limits>
+
+#include "test_macros.h"
+
+enum class e_default { a = 0, b = 1, c = 2 };
+enum class e_ushort : unsigned short { d = 10, e = 25, f = 50 };
+enum class e_longlong : long long {
+  low = std::numeric_limits<long long>::min(),
+  high = std::numeric_limits<long long>::max()
+};
+enum e_non_class { enum_a = 10, enum_b = 11, enum_c = 12 };
+enum e_int : int {
+  enum_min = std::numeric_limits<int>::min(),
+  enum_max = std::numeric_limits<int>::max()
+};
+enum class e_bool : std::uint8_t { f = 0, t = 1 };
+
+struct WithBitfieldEnums {
+  e_default e1 : 3;
+  e_ushort e2 : 6;
+  e_bool e3 : 1;
+};
+
+constexpr bool test() {
+  ASSERT_NOEXCEPT(std::to_underlying(e_default::a));
+  ASSERT_SAME_TYPE(int, decltype(std::to_underlying(e_default::a)));
+  ASSERT_SAME_TYPE(unsigned short, decltype(std::to_underlying(e_ushort::d)));
+  ASSERT_SAME_TYPE(long long, decltype(std::to_underlying(e_longlong::low)));
+  ASSERT_SAME_TYPE(int, decltype(std::to_underlying(enum_min)));
+  ASSERT_SAME_TYPE(int, decltype(std::to_underlying(enum_max)));
+
+  assert(0 == std::to_underlying(e_default::a));
+  assert(1 == std::to_underlying(e_default::b));
+  assert(2 == std::to_underlying(e_default::c));
+
+  assert(10 == std::to_underlying(e_ushort::d));
+  assert(25 == std::to_underlying(e_ushort::e));
+  assert(50 == std::to_underlying(e_ushort::f));
+
+  // Check no truncating.
+  assert(std::numeric_limits<long long>::min() ==
+         std::to_underlying(e_longlong::low));
+  assert(std::numeric_limits<long long>::max() ==
+         std::to_underlying(e_longlong::high));
+
+  assert(10 == std::to_underlying(enum_a));
+  assert(11 == std::to_underlying(enum_b));
+  assert(12 == std::to_underlying(enum_c));
+  assert(std::numeric_limits<int>::min() == std::to_underlying(enum_min));
+  assert(std::numeric_limits<int>::max() == std::to_underlying(enum_max));
+
+  WithBitfieldEnums bf;
+  bf.e1 = static_cast<e_default>(3);
+  bf.e2 = e_ushort::e;
+  bf.e3 = e_bool::t;
+  assert(3 == std::to_underlying(bf.e1));
+  assert(25 == std::to_underlying(bf.e2));
+  assert(1 == std::to_underlying(bf.e3));
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/utilities/utility/utility.underlying/to_underlying.verify.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
+
+// [utility.underlying], to_underlying
+// template <class T>
+//     constexpr underlying_type_t<T> to_underlying( T value ) noexcept; // C++2b
+
+#include <utility>
+
+struct S {};
+
+int main(int, char**) {
+  std::to_underlying(125); // expected-error {{no matching function for call}}
+  std::to_underlying(S{}); // expected-error {{no matching function for call}}
+
+  return 0;
+}

libcxx/utils/generate_feature_test_macro_components.py

feature_test_macros = [ add_version_header(x) for x in [
     "values": { "c++20": 201907 },
     "headers": ["array"],
   }, {
     "name": "__cpp_lib_to_chars",
     "values": { "c++17": 201611 },
     "headers": ["utility"],
     "unimplemented": True,
   }, {
+    "name": "__cpp_lib_to_underlying",
+    "values": { "c++2b": 202102 },
+    "headers": ["utility"],
+  }, {
     "name": "__cpp_lib_transformation_trait_aliases",
     "values": { "c++14": 201304 },
     "headers": ["type_traits"],
   }, {
     "name": "__cpp_lib_transparent_operators",
     "values": { "c++14": 201210, "c++17": 201510 },
     "headers": ["functional", "memory"],
   }, {