[libc++][nfc] remove duplicated __to_unsigned.

[Mordante]

Summary

Both <type_traits> and <charconv> implemented this function with
different names and a slightly different behavior. This removes the
version in <charconv> and improves the version in <typetraits>.

• The code can be used again in C++11.
• The original claimed C++14 support, but [[nodiscard]] is not available in C++14.
• Adds _LIBCPP_INLINE_VISIBILITY.

[cjdb]

to-unsigned-like is named thusly because it works with make-unsigned-like-t, which is exposition-only transformation that could be make_unsigned_t or some unspecified thing if the type parameter isn't an integral. Even though we don't have any such types today, I'm not confident we won't in the future, and think both names should be kept.

[• Quuxplusone]

LGTM % comments and buildkite failures. (Do you need to use _LIBCPP_CONSTEXPR and _NOEXCEPT on the definition? is that what buildkite is complaining about? I haven't looked)

libcxx/include/__ranges/size.h

92

IMO, please _VSTD:: this. (Yeah, its function parameter is a primitive type; but the fact that it has a function parameter is sufficient cause for me.)

libcxx/include/type_traits

2314–2320

Re naming: I approve of __to_unsigned. It simply converts to the make_unsigned version of the type, no more and no less.
@cjdb, if libc++ ever adds support for user-defined "unsigned-like but not unsigned" types, we can revisit the naming bikeshed (since we'll have to re-audit all the call-sites anyway, it'll actually be good to force the pull-requester to touch them all).

[cjdb]

libcxx/include/type_traits

2314–2320

If this were the case, then @ldionne wouldn't have asked for the concept __integer_like. At the very least, I think we should wait for Louis to chime in on this discussion.

[Mordante]

Thanks for the reviews! It turns out our <type_traits> header is available in C++98. So I'll guard against this version.

libcxx/include/__ranges/size.h

92

I think it's indeed a bit pedantic, but we don't know the exact type of _Tp. In <charconv> I feel it's constrained so there it seems overkill.

libcxx/include/type_traits

2314–2320

I dislike the _like suffix. But it seems ranges uses this suffix a lot. So for that reason I think adding the _like suffix is a better idea.

[Mordante]

Addresses the review comments:

• Use the _like suffix since that's used in the Standard for ranges.
• Adds an extra ADL protectsion.

The builds failed since <type_traits> is available in C++98.
Added guards against C++98 for the new function.

[zoecarver]

LGTM! Thanks! Feel free to approve this as libc++ yourself and land it. Or maybe wait to see if Arthur has any more comments.

libcxx/include/type_traits

2314–2318

I don't quite understand this change? Maybe it comes from your comment:

The builds failed since <type_traits> is available in C++98.
Added guards against C++98 for the new function.

I thought we didn't support C++98 anymore. In any case, I strongly feel that we shouldn't. Do we have bots that run C++98? If so, I'm shocked they pass.

[• Quuxplusone]

libcxx/include/type_traits

2314–2318

Well, by "C++98" we mean "C++03" (they're basically synonymous), but sure, libc++ supports -std=c++03.

2314–2320

I also dislike the _like suffix. "Ranges does it" is a great reason not to do it. :P So I'd like to see the shorter and less confusing (and less wishy-washy) name. But, I won't block this over it.

[zoecarver]

libcxx/include/type_traits

2314–2318

That's not what I'm talking about. At one point we had -std=c++98, but I don't think we support that anymore.

Anyway, ignore my original comment, I just misread the condition and thought you were enabling this starting in C++03 mode, which we wouldn't need a condition for. But we're not, so it's all good :)

[zoecarver]

libcxx/include/type_traits

2314–2320

FWIW +1 to naming this __to_unsigned (no _like). But that can also be done after the fact.

[curdeius]

libcxx/include/type_traits

2314–2318

@zoecarver, c++98 was a synonym for c++03 in libc++ tests and it was removed fairly recently (6 months ago or so).

[Mordante]

libcxx/include/type_traits

2314–2318

I think we still support C++98/03. Some people still use it. It seems that the test libcxx/modules/stds_include.sh.cpp still runs in C++98 even on C++2b builds, see https://buildkite.com/llvm-project/libcxx-ci/builds/3205. And obviously C++98 doesn't support constexpr so the test failed.

2314–2320

I'll ask @ldionne which name he prefers and then use that name.

libcxx/include/__ranges/size.h

struct __fn {
     [[nodiscard]] constexpr __integer_like auto operator()(_Tp&& __t) const
         noexcept(noexcept(size(_VSTD::forward<_Tp>(__t)))) {
       return size(_VSTD::forward<_Tp>(__t));
     }
 
     template<__difference _Tp>
     [[nodiscard]] constexpr __integer_like auto operator()(_Tp&& __t) const
         noexcept(noexcept(ranges::end(__t) - ranges::begin(__t))) {
-      return __to_unsigned_like<range_difference_t<remove_cvref_t<_Tp>>>(
+      return _VSTD::__to_unsigned_like<range_difference_t<remove_cvref_t<_Tp>>>(
           ranges::end(__t) - ranges::begin(__t));
     }
   };
 } // end namespace __size
 
 inline namespace __cpo {
   inline constexpr auto size = __size::__fn{};
 } // namespace __cpo

libcxx/include/charconv

 inline _LIBCPP_INLINE_VISIBILITY _Tp
 __complement(_Tp __x)
 {
     static_assert(is_unsigned<_Tp>::value, "cast to unsigned first");
     return _Tp(~__x + 1);
 }
 
 template <typename _Tp>
-inline _LIBCPP_INLINE_VISIBILITY typename make_unsigned<_Tp>::type
-__to_unsigned(_Tp __x)
-{
-    return static_cast<typename make_unsigned<_Tp>::type>(__x);
-}
-
-template <typename _Tp>
 _LIBCPP_AVAILABILITY_TO_CHARS
 inline _LIBCPP_INLINE_VISIBILITY to_chars_result
 __to_chars_itoa(char* __first, char* __last, _Tp __value, true_type)
 {
-    auto __x = __to_unsigned(__value);
+    auto __x = __to_unsigned_like(__value);
     if (__value < 0 && __first != __last)
     {
         *__first++ = '-';
         __x = __complement(__x);
     }
 
     return __to_chars_itoa(__first, __last, __x, false_type());
 }

 }
 
 template <typename _Tp>
 _LIBCPP_AVAILABILITY_TO_CHARS
 inline _LIBCPP_INLINE_VISIBILITY to_chars_result
 __to_chars_integral(char* __first, char* __last, _Tp __value, int __base,
                     true_type)
 {
-    auto __x = __to_unsigned(__value);
+    auto __x = __to_unsigned_like(__value);
     if (__value < 0 && __first != __last)
     {
         *__first++ = '-';
         __x = __complement(__x);
     }
 
     return __to_chars_integral(__first, __last, __x, __base, false_type());
 }
return __to_chars_integral(__first, __last, __value, __base,
                                is_signed<_Tp>());
 }
 
 template <typename _It, typename _Tp, typename _Fn, typename... _Ts>
 inline _LIBCPP_INLINE_VISIBILITY from_chars_result
 __sign_combinator(_It __first, _It __last, _Tp& __value, _Fn __f, _Ts... __args)
 {
     using __tl = numeric_limits<_Tp>;
-    decltype(__to_unsigned(__value)) __x;
+    decltype(__to_unsigned_like(__value)) __x;
 
     bool __neg = (__first != __last && *__first == '-');
     auto __r = __f(__neg ? __first + 1 : __first, __last, __x, __args...);
     switch (__r.ec)
     {
     case errc::invalid_argument:
         return {__first, __r.ec};
     case errc::result_out_of_range:
         return __r;
     default:
         break;
     }
 
     if (__neg)
     {
-        if (__x <= __complement(__to_unsigned(__tl::min())))
+        if (__x <= __complement(__to_unsigned_like(__tl::min())))
         {
             __x = __complement(__x);
             _VSTD::memcpy(&__value, &__x, sizeof(__x));
             return __r;
         }
     }
     else
     {
return __subject_seq_combinator(
             return {__p, errc::result_out_of_range};
         });
 }
 
 template <typename _Tp, typename enable_if<is_signed<_Tp>::value, int>::type = 0>
 inline _LIBCPP_INLINE_VISIBILITY from_chars_result
 __from_chars_atoi(const char* __first, const char* __last, _Tp& __value)
 {
-    using __t = decltype(__to_unsigned(__value));
+    using __t = decltype(__to_unsigned_like(__value));
     return __sign_combinator(__first, __last, __value, __from_chars_atoi<__t>);
 }
 
 template <typename _Tp, typename enable_if<is_unsigned<_Tp>::value, int>::type = 0>
 inline _LIBCPP_INLINE_VISIBILITY from_chars_result
 __from_chars_integral(const char* __first, const char* __last, _Tp& __value,
                       int __base)
 {
return __subject_seq_combinator(
         __base);
 }
 
 template <typename _Tp, typename enable_if<is_signed<_Tp>::value, int>::type = 0>
 inline _LIBCPP_INLINE_VISIBILITY from_chars_result
 __from_chars_integral(const char* __first, const char* __last, _Tp& __value,
                       int __base)
 {
-    using __t = decltype(__to_unsigned(__value));
+    using __t = decltype(__to_unsigned_like(__value));
     return __sign_combinator(__first, __last, __value,
                              __from_chars_integral<__t>, __base);
 }
 
 template <typename _Tp, typename enable_if<is_integral<_Tp>::value, int>::type = 0>
 inline _LIBCPP_INLINE_VISIBILITY from_chars_result
 from_chars(const char* __first, const char* __last, _Tp& __value)
 {

libcxx/include/type_traits

 template <class _Tp>
 struct _LIBCPP_TEMPLATE_VIS make_unsigned
 {
     typedef typename __apply_cv<_Tp, typename __make_unsigned<typename remove_cv<_Tp>::type>::type>::type type;
 };
 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp> using make_unsigned_t = typename make_unsigned<_Tp>::type;
+#endif
 
-template<class _From>
-[[nodiscard]] constexpr auto __to_unsigned_like(_From __x) noexcept {
-  return static_cast<make_unsigned_t<_From>>(__x);
+#ifndef _LIBCPP_CXX03_LANG
+template <class _Tp>
+_LIBCPP_NODISCARD_ATTRIBUTE _LIBCPP_INLINE_VISIBILITY constexpr
+typename make_unsigned<_Tp>::type __to_unsigned_like(_Tp __x) noexcept {
+    return static_cast<typename make_unsigned<_Tp>::type>(__x);
 }
 #endif
 
 #if _LIBCPP_STD_VER > 14
 template <class...> using void_t = void;
 #endif
 
 #if _LIBCPP_STD_VER > 17
 // Let COND_RES(X, Y) be:
 template <class _Tp, class _Up>