[libc++] [LWG3656] Update the return type of std::bit_width

[• Quuxplusone]

Summary

Fixes LWG3656, "Inconsistent bit operations returning a count".
https://cplusplus.github.io/LWG/issue3656

The fix has been approved for C++23 and left to vendors' discretion in C++20 (but it sounds like everyone's on the same page that of course it should be DR'ed back to C++20 too).

As usual, this PR is kinda premature because the LWG issue's resolution hasn't been formally adopted yet, so there's nothing in Cxx2bIssues.csv for it yet, but I figured I might as well prepare this PR to go in absolutely as soon as @ldionne's comfortable with it processwise. :)

[Mordante]

From a code point of view LGTM! But since the issue hasn't been adopted yet I leave the libc++ approval to @ldionne. @ldionne do we want to change our policy regarding implementing LWG issues that haven't been approved?

@Quuxplusone can you update the status page https://libcxx.llvm.org/Status/Cxx2b.html, like we did for LWG 3645 at the bottom of the page?

[ldionne]

LGTM, but please update the LWG issues list as suggested by @Mordante . Also, I think you can disregard the CI failure, it looks like a fluke.

libcxx/docs/Status/Cxx2bIssues.csv

 "`3632 <https://wg21.link/LWG3632>`__","``unique_ptr`` ""Mandates: This constructor is not selected by class template argument deduction""","February 2022","|Nothing to do|",""
 "`3643 <https://wg21.link/LWG3643>`__","Missing ``constexpr`` in ``std::counted_iterator`` ","February 2022","",""
 "`3648 <https://wg21.link/LWG3648>`__","``format`` should not print ``bool`` with ``'c'`` ","February 2022","|Complete|","15.0","|format|"
 "`3649 <https://wg21.link/LWG3649>`__","[fund.ts.v2] Reinstate and bump ``__cpp_lib_experimental_memory_resource`` feature test macro","February 2022","",""
 "`3650 <https://wg21.link/LWG3650>`__","Are ``std::basic_string`` 's ``iterator`` and ``const_iterator`` constexpr iterators?","February 2022","|Nothing to do|",""
 "`3654 <https://wg21.link/LWG3654>`__","``basic_format_context::arg(size_t)`` should be ``noexcept`` ","February 2022","|Complete|","15.0","|format|"
 "`3657 <https://wg21.link/LWG3657>`__","``std::hash<std::filesystem::path>`` is not enabled","February 2022","",""
 "`3660 <https://wg21.link/LWG3660>`__","``iterator_traits<common_iterator>::pointer`` should conform to §[iterator.traits]","February 2022","|Complete|","14.0"
-"`3661 <https://wg21.link/LWG3661>`__","``constinit atomic<shared_ptr<T>> a (nullptr);`` should work","February 2022","",""
+"`3661 <https://wg21.link/LWG3661>`__","``constinit atomic<shared_ptr<T>> a(nullptr);`` should work","February 2022","",""
 "","","","",""
-`3645 <https://wg21.link/LWG3645>`__,"``resize_and_overwrite`` is overspecified to call its callback with lvalues", "Not voted in","|Complete|","14.0",""
+"`3645 <https://wg21.link/LWG3645>`__","``resize_and_overwrite`` is overspecified to call its callback with lvalues","Not voted in","|Complete|","14.0",""
+"`3656 <https://wg21.link/LWG3656>`__","Inconsistent bit operations returning a count","Not voted in","|Complete|","15.0",""
 "","","","",""

libcxx/include/bit

namespace std {
   // [bit.pow.two], integral powers of 2
   template <class T>
     constexpr bool has_single_bit(T x) noexcept; // C++20
   template <class T>
     constexpr T bit_ceil(T x);                   // C++20
   template <class T>
     constexpr T bit_floor(T x) noexcept;         // C++20
   template <class T>
-    constexpr T bit_width(T x) noexcept;         // C++20
+    constexpr int bit_width(T x) noexcept;       // C++20
 
   // [bit.rotate], rotating
   template<class T>
     constexpr T rotl(T x, unsigned int s) noexcept; // C++20
   template<class T>
     constexpr T rotr(T x, unsigned int s) noexcept; // C++20
 
   // [bit.count], counting
else
         const unsigned __extra = numeric_limits<unsigned>::digits  - numeric_limits<_Tp>::digits;
         const unsigned __retVal = 1u << (__n + __extra);
         return (_Tp) (__retVal >> __extra);
     }
 }
 
 template <class _Tp>
 _LIBCPP_INLINE_VISIBILITY constexpr
-enable_if_t<__libcpp_is_unsigned_integer<_Tp>::value, _Tp>
+enable_if_t<__libcpp_is_unsigned_integer<_Tp>::value, int>
 bit_width(_Tp __t) noexcept
 {
     return __t == 0 ? 0 : __bit_log2(__t) + 1;
 }
 
 enum class endian
 {
     little = 0xDEAD,

libcxx/test/std/numerics/bit/bit.pow.two/bit_width.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 // template <class T>
-//   constexpr T bit_width(T x) noexcept;
+//   constexpr int bit_width(T x) noexcept;
 
 // Constraints: T is an unsigned integer type
 // Returns: If x == 0, 0; otherwise one plus the base-2 logarithm of x, with any fractional part discarded.
 
 
 #include <bit>
 #include <cassert>
 #include <cstdint>
 #include <type_traits>
 
 #include "test_macros.h"
 
 struct A {};
 enum       E1 : unsigned char { rEd };
 enum class E2 : unsigned char { red };
 
 template <class T>
 constexpr bool test()
 {
-    ASSERT_SAME_TYPE(decltype(std::bit_width(T())), T);
+    ASSERT_SAME_TYPE(decltype(std::bit_width(T())), int);
     ASSERT_NOEXCEPT(std::bit_width(T()));
     T max = std::numeric_limits<T>::max();
 
-    assert(std::bit_width(T(0)) == T(0));
-    assert(std::bit_width(T(1)) == T(1));
-    assert(std::bit_width(T(2)) == T(2));
-    assert(std::bit_width(T(3)) == T(2));
-    assert(std::bit_width(T(4)) == T(3));
-    assert(std::bit_width(T(5)) == T(3));
-    assert(std::bit_width(T(6)) == T(3));
-    assert(std::bit_width(T(7)) == T(3));
-    assert(std::bit_width(T(8)) == T(4));
-    assert(std::bit_width(T(9)) == T(4));
-    assert(std::bit_width(T(125)) == T(7));
-    assert(std::bit_width(T(126)) == T(7));
-    assert(std::bit_width(T(127)) == T(7));
-    assert(std::bit_width(T(128)) == T(8));
-    assert(std::bit_width(T(129)) == T(8));
-    assert(std::bit_width(T(130)) == T(8));
-    assert(std::bit_width(T(max - 1)) == T(std::numeric_limits<T>::digits));
-    assert(std::bit_width(max) == T(std::numeric_limits<T>::digits));
+    assert(std::bit_width(T(0)) == 0);
+    assert(std::bit_width(T(1)) == 1);
+    assert(std::bit_width(T(2)) == 2);
+    assert(std::bit_width(T(3)) == 2);
+    assert(std::bit_width(T(4)) == 3);
+    assert(std::bit_width(T(5)) == 3);
+    assert(std::bit_width(T(6)) == 3);
+    assert(std::bit_width(T(7)) == 3);
+    assert(std::bit_width(T(8)) == 4);
+    assert(std::bit_width(T(9)) == 4);
+    assert(std::bit_width(T(125)) == 7);
+    assert(std::bit_width(T(126)) == 7);
+    assert(std::bit_width(T(127)) == 7);
+    assert(std::bit_width(T(128)) == 8);
+    assert(std::bit_width(T(129)) == 8);
+    assert(std::bit_width(T(130)) == 8);
+    assert(std::bit_width(T(max - 1)) == std::numeric_limits<T>::digits);
+    assert(std::bit_width(max) == std::numeric_limits<T>::digits);
 
 #ifndef TEST_HAS_NO_INT128
     if constexpr (std::is_same_v<T, __uint128_t>) {
         T val = 128;
         val <<= 32;
         assert(std::bit_width(val-1) == 39);
         assert(std::bit_width(val)   == 40);
         assert(std::bit_width(val+1) == 40);