caio/clang-p2996
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[libc++] Refactor signed/unsigned integer traits (#142750)

Browse Source 
This patch does a few things:
- `__libcpp_is_signed_integer` and `__libcpp_is_unsigned_integer` are
refactored to be variable templates instead of class templates.
- the two traits are merged into a single header
`<__type_traits/integer_traits.h>`.
- `__libcpp_signed_integer`, `__libcpp_unsigned_integer` and
`__libcpp_integer` are moved into the same header.
- The above mentioned concepts are renamed to `__signed_integer`,
`__unsigned_integer` and `__signed_or_unsigned_integer` respectively.
This commit is contained in:
Nikolas Klauser
2025-06-11 14:31:13 +02:00
committed by GitHub
parent b49c7896c0
commit 3c56437eaf
22 changed files with 223 additions and 245 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
libcxx/include/CMakeLists.txt
View File

@@ -800,6 +800,7 @@ set(files
__type_traits/extent.h
__type_traits/has_unique_object_representation.h
__type_traits/has_virtual_destructor.h
__type_traits/integer_traits.h
__type_traits/integral_constant.h
__type_traits/invoke.h
__type_traits/is_abstract.h
@@ -850,7 +851,6 @@ set(files
__type_traits/is_same.h
__type_traits/is_scalar.h
__type_traits/is_signed.h
__type_traits/is_signed_integer.h
__type_traits/is_specialization.h
__type_traits/is_standard_layout.h
__type_traits/is_swappable.h
@@ -864,7 +864,6 @@ set(files
__type_traits/is_unbounded_array.h
__type_traits/is_union.h
__type_traits/is_unsigned.h
__type_traits/is_unsigned_integer.h
__type_traits/is_valid_expansion.h
__type_traits/is_void.h
__type_traits/is_volatile.h

4
libcxx/include/__bit/bit_ceil.h
View File

@@ -11,8 +11,8 @@
#include <__assert>
#include <__bit/countl.h>
#include <__concepts/arithmetic.h>
#include <__config>
#include <__type_traits/integer_traits.h>
#include <limits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
@@ -41,7 +41,7 @@ template <class _Tp>
# if _LIBCPP_STD_VER >= 20
template <__libcpp_unsigned_integer _Tp>
template <__unsigned_integer _Tp>
[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp bit_ceil(_Tp __t) noexcept {
return std::__bit_ceil(__t);
}

4
libcxx/include/__bit/bit_floor.h
View File

@@ -10,8 +10,8 @@
#define _LIBCPP___BIT_BIT_FLOOR_H
#include <__bit/bit_log2.h>
#include <__concepts/arithmetic.h>
#include <__config>
#include <__type_traits/integer_traits.h>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header
@@ -21,7 +21,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER >= 20
template <__libcpp_unsigned_integer _Tp>
template <__unsigned_integer _Tp>
[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp bit_floor(_Tp __t) noexcept {
return __t == 0 ? 0 : _Tp{1} << std::__bit_log2(__t);
}

4
libcxx/include/__bit/bit_log2.h
View File

@@ -11,7 +11,7 @@
#include <__bit/countl.h>
#include <__config>
#include <__type_traits/is_unsigned_integer.h>
#include <__type_traits/integer_traits.h>
#include <limits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
@@ -22,7 +22,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _Tp __bit_log2(_Tp __t) _NOEXCEPT {
static_assert(__libcpp_is_unsigned_integer<_Tp>::value, "__bit_log2 requires an unsigned integer type");
static_assert(__is_unsigned_integer_v<_Tp>, "__bit_log2 requires an unsigned integer type");
return numeric_limits<_Tp>::digits - 1 - std::__countl_zero(__t);
}

4
libcxx/include/__bit/bit_width.h
View File

@@ -10,8 +10,8 @@
#define _LIBCPP___BIT_BIT_WIDTH_H
#include <__bit/bit_log2.h>
#include <__concepts/arithmetic.h>
#include <__config>
#include <__type_traits/integer_traits.h>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header
@@ -21,7 +21,7 @@
_LIBCPP_BEGIN_NAMESPACE_STD
template <__libcpp_unsigned_integer _Tp>
template <__unsigned_integer _Tp>
[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr int bit_width(_Tp __t) noexcept {
return __t == 0 ? 0 : std::__bit_log2(__t) + 1;
}

9
libcxx/include/__bit/countl.h
View File

@@ -9,9 +9,8 @@
#ifndef _LIBCPP___BIT_COUNTL_H
#define _LIBCPP___BIT_COUNTL_H
#include <__concepts/arithmetic.h>
#include <__config>
#include <__type_traits/is_unsigned_integer.h>
#include <__type_traits/integer_traits.h>
#include <limits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
@@ -25,18 +24,18 @@ _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 int __countl_zero(_Tp __t) _NOEXCEPT {
static_assert(__libcpp_is_unsigned_integer<_Tp>::value, "__countl_zero requires an unsigned integer type");
static_assert(__is_unsigned_integer_v<_Tp>, "__countl_zero requires an unsigned integer type");
return __builtin_clzg(__t, numeric_limits<_Tp>::digits);
}
#if _LIBCPP_STD_VER >= 20
template <__libcpp_unsigned_integer _Tp>
template <__unsigned_integer _Tp>
[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr int countl_zero(_Tp __t) noexcept {
return std::__countl_zero(__t);
}
template <__libcpp_unsigned_integer _Tp>
template <__unsigned_integer _Tp>
[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr int countl_one(_Tp __t) noexcept {
return __t != numeric_limits<_Tp>::max() ? std::countl_zero(static_cast<_Tp>(~__t)) : numeric_limits<_Tp>::digits;
}

9
libcxx/include/__bit/countr.h
View File

@@ -9,9 +9,8 @@
#ifndef _LIBCPP___BIT_COUNTR_H
#define _LIBCPP___BIT_COUNTR_H
#include <__concepts/arithmetic.h>
#include <__config>
#include <__type_traits/is_unsigned_integer.h>
#include <__type_traits/integer_traits.h>
#include <limits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
@@ -25,18 +24,18 @@ _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp>
[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR int __countr_zero(_Tp __t) _NOEXCEPT {
static_assert(__libcpp_is_unsigned_integer<_Tp>::value, "__countr_zero only works with unsigned types");
static_assert(__is_unsigned_integer_v<_Tp>, "__countr_zero only works with unsigned types");
return __builtin_ctzg(__t, numeric_limits<_Tp>::digits);
}
#if _LIBCPP_STD_VER >= 20
template <__libcpp_unsigned_integer _Tp>
template <__unsigned_integer _Tp>
[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr int countr_zero(_Tp __t) noexcept {
return std::__countr_zero(__t);
}
template <__libcpp_unsigned_integer _Tp>
template <__unsigned_integer _Tp>
[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr int countr_one(_Tp __t) noexcept {
return __t != numeric_limits<_Tp>::max() ? std::countr_zero(static_cast<_Tp>(~__t)) : numeric_limits<_Tp>::digits;
}

4
libcxx/include/__bit/has_single_bit.h
View File

@@ -9,8 +9,8 @@
#ifndef _LIBCPP___BIT_HAS_SINGLE_BIT_H
#define _LIBCPP___BIT_HAS_SINGLE_BIT_H
#include <__concepts/arithmetic.h>
#include <__config>
#include <__type_traits/integer_traits.h>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header
@@ -23,7 +23,7 @@ _LIBCPP_PUSH_MACROS
_LIBCPP_BEGIN_NAMESPACE_STD
template <__libcpp_unsigned_integer _Tp>
template <__unsigned_integer _Tp>
[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool has_single_bit(_Tp __t) noexcept {
return __t != 0 && (((__t & (__t - 1)) == 0));
}

7
libcxx/include/__bit/popcount.h
View File

@@ -9,9 +9,8 @@
#ifndef _LIBCPP___BIT_POPCOUNT_H
#define _LIBCPP___BIT_POPCOUNT_H
#include <__concepts/arithmetic.h>
#include <__config>
#include <__type_traits/is_unsigned_integer.h>
#include <__type_traits/integer_traits.h>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header
@@ -24,13 +23,13 @@ _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp>
[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR int __popcount(_Tp __t) _NOEXCEPT {
static_assert(__libcpp_is_unsigned_integer<_Tp>::value, "__popcount only works with unsigned types");
static_assert(__is_unsigned_integer_v<_Tp>, "__popcount only works with unsigned types");
return __builtin_popcountg(__t);
}
#if _LIBCPP_STD_VER >= 20
template <__libcpp_unsigned_integer _Tp>
template <__unsigned_integer _Tp>
[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr int popcount(_Tp __t) noexcept {
return std::__popcount(__t);
}

11
libcxx/include/__bit/rotate.h
View File

@@ -9,9 +9,8 @@
#ifndef _LIBCPP___BIT_ROTATE_H
#define _LIBCPP___BIT_ROTATE_H
#include <__concepts/arithmetic.h>
#include <__config>
#include <__type_traits/is_unsigned_integer.h>
#include <__type_traits/integer_traits.h>
#include <limits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
@@ -25,7 +24,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
// the rotr function becomes the ROR instruction.
template <class _Tp>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _Tp __rotl(_Tp __x, int __s) _NOEXCEPT {
static_assert(__libcpp_is_unsigned_integer<_Tp>::value, "__rotl requires an unsigned integer type");
static_assert(__is_unsigned_integer_v<_Tp>, "__rotl requires an unsigned integer type");
const int __n = numeric_limits<_Tp>::digits;
int __r = __s % __n;
@@ -40,7 +39,7 @@ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _Tp __rotl(_Tp __x, int __s)
template <class _Tp>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _Tp __rotr(_Tp __x, int __s) _NOEXCEPT {
static_assert(__libcpp_is_unsigned_integer<_Tp>::value, "__rotr requires an unsigned integer type");
static_assert(__is_unsigned_integer_v<_Tp>, "__rotr requires an unsigned integer type");
const int __n = numeric_limits<_Tp>::digits;
int __r = __s % __n;
@@ -55,12 +54,12 @@ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _Tp __rotr(_Tp __x, int __s)
#if _LIBCPP_STD_VER >= 20
template <__libcpp_unsigned_integer _Tp>
template <__unsigned_integer _Tp>
[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp rotl(_Tp __t, int __cnt) noexcept {
return std::__rotl(__t, __cnt);
}
template <__libcpp_unsigned_integer _Tp>
template <__unsigned_integer _Tp>
[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp rotr(_Tp __t, int __cnt) noexcept {
return std::__rotr(__t, __cnt);
}

13
libcxx/include/__concepts/arithmetic.h
View File

@@ -13,8 +13,6 @@
#include <__type_traits/is_floating_point.h>
#include <__type_traits/is_integral.h>
#include <__type_traits/is_signed.h>
#include <__type_traits/is_signed_integer.h>
#include <__type_traits/is_unsigned_integer.h>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header
@@ -38,17 +36,6 @@ concept unsigned_integral = integral<_Tp> && !signed_integral<_Tp>;
template <class _Tp>
concept floating_point = is_floating_point_v<_Tp>;
// Concept helpers for the internal type traits for the fundamental types.
template <class _Tp>
concept __libcpp_unsigned_integer = __libcpp_is_unsigned_integer<_Tp>::value;
template <class _Tp>
concept __libcpp_signed_integer = __libcpp_is_signed_integer<_Tp>::value;
template <class _Tp>
concept __libcpp_integer = __libcpp_unsigned_integer<_Tp> || __libcpp_signed_integer<_Tp>;
#endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD

6
libcxx/include/__format/format_arg_store.h
View File

@@ -14,7 +14,6 @@
# pragma GCC system_header
#endif
#include <__concepts/arithmetic.h>
#include <__concepts/same_as.h>
#include <__config>
#include <__cstddef/size_t.h>
@@ -22,6 +21,7 @@
#include <__format/format_arg.h>
#include <__type_traits/conditional.h>
#include <__type_traits/extent.h>
#include <__type_traits/integer_traits.h>
#include <__type_traits/remove_const.h>
#include <cstdint>
#include <string>
@@ -65,7 +65,7 @@ consteval __arg_t __determine_arg_t() {
# endif
// Signed integers
template <class, __libcpp_signed_integer _Tp>
template <class, __signed_integer _Tp>
consteval __arg_t __determine_arg_t() {
if constexpr (sizeof(_Tp) <= sizeof(int))
return __arg_t::__int;
@@ -80,7 +80,7 @@ consteval __arg_t __determine_arg_t() {
}
// Unsigned integers
template <class, __libcpp_unsigned_integer _Tp>
template <class, __unsigned_integer _Tp>
consteval __arg_t __determine_arg_t() {
if constexpr (sizeof(_Tp) <= sizeof(unsigned))
return __arg_t::__unsigned;

6
libcxx/include/__mdspan/extents.h
View File

@@ -21,11 +21,10 @@
#include <__config>
#include <__concepts/arithmetic.h>
#include <__cstddef/byte.h>
#include <__type_traits/common_type.h>
#include <__type_traits/integer_traits.h>
#include <__type_traits/is_convertible.h>
#include <__type_traits/is_nothrow_constructible.h>
#include <__type_traits/is_same.h>
#include <__type_traits/make_unsigned.h>
#include <__utility/integer_sequence.h>
#include <__utility/unreachable.h>
@@ -283,7 +282,8 @@ public:
using size_type = make_unsigned_t<index_type>;
using rank_type = size_t;
static_assert(__libcpp_integer<index_type>, "extents::index_type must be a signed or unsigned integer type");
static_assert(__signed_or_unsigned_integer<index_type>,
"extents::index_type must be a signed or unsigned integer type");
static_assert(((__mdspan_detail::__is_representable_as<index_type>(_Extents) || (_Extents == dynamic_extent)) && ...),
"extents ctor: arguments must be representable as index_type and nonnegative");

30
libcxx/include/__numeric/saturation_arithmetic.h
View File

@@ -11,9 +11,9 @@
#define _LIBCPP___NUMERIC_SATURATION_ARITHMETIC_H
#include <__assert>
#include <__concepts/arithmetic.h>
#include <__config>
#include <__memory/addressof.h>
#include <__type_traits/integer_traits.h>
#include <__utility/cmp.h>
#include <limits>
@@ -28,12 +28,12 @@ _LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER >= 20
template <__libcpp_integer _Tp>
template <__signed_or_unsigned_integer _Tp>
_LIBCPP_HIDE_FROM_ABI constexpr _Tp __add_sat(_Tp __x, _Tp __y) noexcept {
if (_Tp __sum; !__builtin_add_overflow(__x, __y, std::addressof(__sum)))
return __sum;
// Handle overflow
if constexpr (__libcpp_unsigned_integer<_Tp>) {
if constexpr (__unsigned_integer<_Tp>) {
return std::numeric_limits<_Tp>::max();
} else {
// Signed addition overflow
@@ -46,12 +46,12 @@ _LIBCPP_HIDE_FROM_ABI constexpr _Tp __add_sat(_Tp __x, _Tp __y) noexcept {
}
}
template <__libcpp_integer _Tp>
template <__signed_or_unsigned_integer _Tp>
_LIBCPP_HIDE_FROM_ABI constexpr _Tp __sub_sat(_Tp __x, _Tp __y) noexcept {
if (_Tp __sub; !__builtin_sub_overflow(__x, __y, std::addressof(__sub)))
return __sub;
// Handle overflow
if constexpr (__libcpp_unsigned_integer<_Tp>) {
if constexpr (__unsigned_integer<_Tp>) {
// Overflows if (x < y)
return std::numeric_limits<_Tp>::min();
} else {
@@ -65,12 +65,12 @@ _LIBCPP_HIDE_FROM_ABI constexpr _Tp __sub_sat(_Tp __x, _Tp __y) noexcept {
}
}
template <__libcpp_integer _Tp>
template <__signed_or_unsigned_integer _Tp>
_LIBCPP_HIDE_FROM_ABI constexpr _Tp __mul_sat(_Tp __x, _Tp __y) noexcept {
if (_Tp __mul; !__builtin_mul_overflow(__x, __y, std::addressof(__mul)))
return __mul;
// Handle overflow
if constexpr (__libcpp_unsigned_integer<_Tp>) {
if constexpr (__unsigned_integer<_Tp>) {
return std::numeric_limits<_Tp>::max();
} else {
// Signed multiplication overflow
@@ -81,10 +81,10 @@ _LIBCPP_HIDE_FROM_ABI constexpr _Tp __mul_sat(_Tp __x, _Tp __y) noexcept {
}
}
template <__libcpp_integer _Tp>
template <__signed_or_unsigned_integer _Tp>
_LIBCPP_HIDE_FROM_ABI constexpr _Tp __div_sat(_Tp __x, _Tp __y) noexcept {
_LIBCPP_ASSERT_UNCATEGORIZED(__y != 0, "Division by 0 is undefined");
if constexpr (__libcpp_unsigned_integer<_Tp>) {
if constexpr (__unsigned_integer<_Tp>) {
return __x / __y;
} else {
// Handle signed division overflow
@@ -94,7 +94,7 @@ _LIBCPP_HIDE_FROM_ABI constexpr _Tp __div_sat(_Tp __x, _Tp __y) noexcept {
}
}
template <__libcpp_integer _Rp, __libcpp_integer _Tp>
template <__signed_or_unsigned_integer _Rp, __signed_or_unsigned_integer _Tp>
_LIBCPP_HIDE_FROM_ABI constexpr _Rp __saturate_cast(_Tp __x) noexcept {
// Saturation is impossible edge case when ((min _Rp) < (min _Tp) && (max _Rp) > (max _Tp)) and it is expected to be
// optimized out by the compiler.
@@ -112,27 +112,27 @@ _LIBCPP_HIDE_FROM_ABI constexpr _Rp __saturate_cast(_Tp __x) noexcept {
#if _LIBCPP_STD_VER >= 26
template <__libcpp_integer _Tp>
template <__signed_or_unsigned_integer _Tp>
_LIBCPP_HIDE_FROM_ABI constexpr _Tp add_sat(_Tp __x, _Tp __y) noexcept {
return std::__add_sat(__x, __y);
}
template <__libcpp_integer _Tp>
template <__signed_or_unsigned_integer _Tp>
_LIBCPP_HIDE_FROM_ABI constexpr _Tp sub_sat(_Tp __x, _Tp __y) noexcept {
return std::__sub_sat(__x, __y);
}
template <__libcpp_integer _Tp>
template <__signed_or_unsigned_integer _Tp>
_LIBCPP_HIDE_FROM_ABI constexpr _Tp mul_sat(_Tp __x, _Tp __y) noexcept {
return std::__mul_sat(__x, __y);
}
template <__libcpp_integer _Tp>
template <__signed_or_unsigned_integer _Tp>
_LIBCPP_HIDE_FROM_ABI constexpr _Tp div_sat(_Tp __x, _Tp __y) noexcept {
return std::__div_sat(__x, __y);
}
template <__libcpp_integer _Rp, __libcpp_integer _Tp>
template <__signed_or_unsigned_integer _Rp, __signed_or_unsigned_integer _Tp>
_LIBCPP_HIDE_FROM_ABI constexpr _Rp saturate_cast(_Tp __x) noexcept {
return std::__saturate_cast<_Rp>(__x);
}

73
libcxx/include/__type_traits/integer_traits.h Normal file
View File

@@ -0,0 +1,73 @@
//===----------------------------------------------------------------------===//
//
// 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
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP___TYPE_TRAITS_INTEGER_TRAITS_H
#define _LIBCPP___TYPE_TRAITS_INTEGER_TRAITS_H
#include <__config>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header
#endif
_LIBCPP_BEGIN_NAMESPACE_STD
// This trait is to determine whether a type is a /signed integer type/
// See [basic.fundamental]/p1
template <class _Tp>
inline const bool __is_signed_integer_v = false;
template <>
inline const bool __is_signed_integer_v<signed char> = true;
template <>
inline const bool __is_signed_integer_v<signed short> = true;
template <>
inline const bool __is_signed_integer_v<signed int> = true;
template <>
inline const bool __is_signed_integer_v<signed long> = true;
template <>
inline const bool __is_signed_integer_v<signed long long> = true;
#if _LIBCPP_HAS_INT128
template <>
inline const bool __is_signed_integer_v<__int128_t> = true;
#endif
// This trait is to determine whether a type is an /unsigned integer type/
// See [basic.fundamental]/p2
template <class _Tp>
inline const bool __is_unsigned_integer_v = false;
template <>
inline const bool __is_unsigned_integer_v<unsigned char> = true;
template <>
inline const bool __is_unsigned_integer_v<unsigned short> = true;
template <>
inline const bool __is_unsigned_integer_v<unsigned int> = true;
template <>
inline const bool __is_unsigned_integer_v<unsigned long> = true;
template <>
inline const bool __is_unsigned_integer_v<unsigned long long> = true;
#if _LIBCPP_HAS_INT128
template <>
inline const bool __is_unsigned_integer_v<__uint128_t> = true;
#endif
#if _LIBCPP_STD_VER >= 20
template <class _Tp>
concept __signed_integer = __is_signed_integer_v<_Tp>;
template <class _Tp>
concept __unsigned_integer = __is_unsigned_integer_v<_Tp>;
// This isn't called __integer, because an integer type according to [basic.fundamental]/p11 is the same as an integral
// type. An integral type is _not_ the same set of types as signed and unsigned integer types combined.
template <class _Tp>
concept __signed_or_unsigned_integer = __signed_integer<_Tp> || __unsigned_integer<_Tp>;
#endif
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_INTEGER_TRAITS_H

35
libcxx/include/__type_traits/is_signed_integer.h
View File

@@ -1,35 +0,0 @@
//===----------------------------------------------------------------------===//
//
// 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
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP___TYPE_TRAITS_IS_SIGNED_INTEGER_H
#define _LIBCPP___TYPE_TRAITS_IS_SIGNED_INTEGER_H
#include <__config>
#include <__type_traits/integral_constant.h>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header
#endif
_LIBCPP_BEGIN_NAMESPACE_STD
// clang-format off
template <class _Tp> struct __libcpp_is_signed_integer : false_type {};
template <> struct __libcpp_is_signed_integer<signed char> : true_type {};
template <> struct __libcpp_is_signed_integer<signed short> : true_type {};
template <> struct __libcpp_is_signed_integer<signed int> : true_type {};
template <> struct __libcpp_is_signed_integer<signed long> : true_type {};
template <> struct __libcpp_is_signed_integer<signed long long> : true_type {};
#if _LIBCPP_HAS_INT128
template <> struct __libcpp_is_signed_integer<__int128_t> : true_type {};
#endif
// clang-format on
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_SIGNED_INTEGER_H

35
libcxx/include/__type_traits/is_unsigned_integer.h
View File

@@ -1,35 +0,0 @@
//===----------------------------------------------------------------------===//
//
// 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
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP___TYPE_TRAITS_IS_UNSIGNED_INTEGER_H
#define _LIBCPP___TYPE_TRAITS_IS_UNSIGNED_INTEGER_H
#include <__config>
#include <__type_traits/integral_constant.h>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header
#endif
_LIBCPP_BEGIN_NAMESPACE_STD
// clang-format off
template <class _Tp> struct __libcpp_is_unsigned_integer : false_type {};
template <> struct __libcpp_is_unsigned_integer<unsigned char> : true_type {};
template <> struct __libcpp_is_unsigned_integer<unsigned short> : true_type {};
template <> struct __libcpp_is_unsigned_integer<unsigned int> : true_type {};
template <> struct __libcpp_is_unsigned_integer<unsigned long> : true_type {};
template <> struct __libcpp_is_unsigned_integer<unsigned long long> : true_type {};
#if _LIBCPP_HAS_INT128
template <> struct __libcpp_is_unsigned_integer<__uint128_t> : true_type {};
#endif
// clang-format on
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_UNSIGNED_INTEGER_H

16
libcxx/include/__utility/cmp.h
View File

@@ -9,8 +9,8 @@
#ifndef _LIBCPP___UTILITY_CMP_H
#define _LIBCPP___UTILITY_CMP_H
#include <__concepts/arithmetic.h>
#include <__config>
#include <__type_traits/integer_traits.h>
#include <__type_traits/is_signed.h>
#include <__type_traits/make_unsigned.h>
#include <limits>
@@ -26,7 +26,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER >= 20
template <__libcpp_integer _Tp, __libcpp_integer _Up>
template <__signed_or_unsigned_integer _Tp, __signed_or_unsigned_integer _Up>
_LIBCPP_HIDE_FROM_ABI constexpr bool cmp_equal(_Tp __t, _Up __u) noexcept {
if constexpr (is_signed_v<_Tp> == is_signed_v<_Up>)
return __t == __u;
@@ -36,12 +36,12 @@ _LIBCPP_HIDE_FROM_ABI constexpr bool cmp_equal(_Tp __t, _Up __u) noexcept {
return __u < 0 ? false : __t == make_unsigned_t<_Up>(__u);
}
template <__libcpp_integer _Tp, __libcpp_integer _Up>
template <__signed_or_unsigned_integer _Tp, __signed_or_unsigned_integer _Up>
_LIBCPP_HIDE_FROM_ABI constexpr bool cmp_not_equal(_Tp __t, _Up __u) noexcept {
return !std::cmp_equal(__t, __u);
}
template <__libcpp_integer _Tp, __libcpp_integer _Up>
template <__signed_or_unsigned_integer _Tp, __signed_or_unsigned_integer _Up>
_LIBCPP_HIDE_FROM_ABI constexpr bool cmp_less(_Tp __t, _Up __u) noexcept {
if constexpr (is_signed_v<_Tp> == is_signed_v<_Up>)
return __t < __u;
@@ -51,22 +51,22 @@ _LIBCPP_HIDE_FROM_ABI constexpr bool cmp_less(_Tp __t, _Up __u) noexcept {
return __u < 0 ? false : __t < make_unsigned_t<_Up>(__u);
}
template <__libcpp_integer _Tp, __libcpp_integer _Up>
template <__signed_or_unsigned_integer _Tp, __signed_or_unsigned_integer _Up>
_LIBCPP_HIDE_FROM_ABI constexpr bool cmp_greater(_Tp __t, _Up __u) noexcept {
return std::cmp_less(__u, __t);
}
template <__libcpp_integer _Tp, __libcpp_integer _Up>
template <__signed_or_unsigned_integer _Tp, __signed_or_unsigned_integer _Up>
_LIBCPP_HIDE_FROM_ABI constexpr bool cmp_less_equal(_Tp __t, _Up __u) noexcept {
return !std::cmp_greater(__t, __u);
}
template <__libcpp_integer _Tp, __libcpp_integer _Up>
template <__signed_or_unsigned_integer _Tp, __signed_or_unsigned_integer _Up>
_LIBCPP_HIDE_FROM_ABI constexpr bool cmp_greater_equal(_Tp __t, _Up __u) noexcept {
return !std::cmp_less(__t, __u);
}
template <__libcpp_integer _Tp, __libcpp_integer _Up>
template <__signed_or_unsigned_integer _Tp, __signed_or_unsigned_integer _Up>
_LIBCPP_HIDE_FROM_ABI constexpr bool in_range(_Up __u) noexcept {
return std::cmp_less_equal(__u, numeric_limits<_Tp>::max()) &&
std::cmp_greater_equal(__u, numeric_limits<_Tp>::min());

9
libcxx/include/module.modulemap.in
View File

@@ -94,6 +94,7 @@ module std_core [system] {
module extent { header "__type_traits/extent.h" }
module has_unique_object_representation { header "__type_traits/has_unique_object_representation.h" }
module has_virtual_destructor { header "__type_traits/has_virtual_destructor.h" }
module integer_traits { header "__type_traits/integer_traits.h" }
module integral_constant { header "__type_traits/integral_constant.h" }
module invoke { header "__type_traits/invoke.h" }
module is_abstract {
@@ -284,10 +285,6 @@ module std_core [system] {
header "__type_traits/is_scalar.h"
export std_core.type_traits.integral_constant
}
module is_signed_integer {
header "__type_traits/is_signed_integer.h"
export std_core.type_traits.integral_constant
}
module is_signed {
header "__type_traits/is_signed.h"
export std_core.type_traits.integral_constant
@@ -340,10 +337,6 @@ module std_core [system] {
header "__type_traits/is_union.h"
export std_core.type_traits.integral_constant
}
module is_unsigned_integer {
header "__type_traits/is_unsigned_integer.h"
export std_core.type_traits.integral_constant
}
module is_unsigned {
header "__type_traits/is_unsigned.h"
export std_core.type_traits.integral_constant

62
libcxx/test/libcxx/concepts/concepts.arithmetic/__libcpp_integer.compile.pass.cpp
View File

@@ -11,9 +11,9 @@
// Concept helpers for the internal type traits for the fundamental types.
// template <class _Tp>
// concept __libcpp_integer;
// concept __signed_or_unsigned_integer;
#include <concepts>
#include <__type_traits/integer_traits.h>
#include "test_macros.h"
@@ -24,40 +24,40 @@ enum SomeEnum {};
enum class SomeScopedEnum {};
// Unsigned
static_assert(std::__libcpp_integer<unsigned char>);
static_assert(std::__libcpp_integer<unsigned short int>);
static_assert(std::__libcpp_integer<unsigned int>);
static_assert(std::__libcpp_integer<unsigned long int>);
static_assert(std::__libcpp_integer<unsigned long long int>);
static_assert(std::__libcpp_integer<unsigned short int>);
static_assert(std::__signed_or_unsigned_integer<unsigned char>);
static_assert(std::__signed_or_unsigned_integer<unsigned short int>);
static_assert(std::__signed_or_unsigned_integer<unsigned int>);
static_assert(std::__signed_or_unsigned_integer<unsigned long int>);
static_assert(std::__signed_or_unsigned_integer<unsigned long long int>);
static_assert(std::__signed_or_unsigned_integer<unsigned short int>);
#if _LIBCPP_HAS_INT128
static_assert(std::__libcpp_integer<__uint128_t>);
static_assert(std::__signed_or_unsigned_integer<__uint128_t>);
#endif
// Signed
static_assert(std::__libcpp_integer<signed char>);
static_assert(std::__libcpp_integer<short int>);
static_assert(std::__libcpp_integer<int>);
static_assert(std::__libcpp_integer<long int>);
static_assert(std::__libcpp_integer<long long int>);
static_assert(std::__libcpp_integer<short int>);
static_assert(std::__signed_or_unsigned_integer<signed char>);
static_assert(std::__signed_or_unsigned_integer<short int>);
static_assert(std::__signed_or_unsigned_integer<int>);
static_assert(std::__signed_or_unsigned_integer<long int>);
static_assert(std::__signed_or_unsigned_integer<long long int>);
static_assert(std::__signed_or_unsigned_integer<short int>);
#if _LIBCPP_HAS_INT128
static_assert(std::__libcpp_integer<__int128_t>);
static_assert(std::__signed_or_unsigned_integer<__int128_t>);
#endif
// Non-integer
static_assert(!std::__libcpp_integer<bool>);
static_assert(!std::__libcpp_integer<char>);
static_assert(!std::__signed_or_unsigned_integer<bool>);
static_assert(!std::__signed_or_unsigned_integer<char>);
#ifndef TEST_HAS_NO_WIDE_CHARACTERS
static_assert(!std::__libcpp_integer<wchar_t>);
static_assert(!std::__signed_or_unsigned_integer<wchar_t>);
#endif
static_assert(!std::__libcpp_integer<char8_t>);
static_assert(!std::__libcpp_integer<char16_t>);
static_assert(!std::__libcpp_integer<char32_t>);
static_assert(!std::__libcpp_integer<float>);
static_assert(!std::__libcpp_integer<double>);
static_assert(!std::__libcpp_integer<long double>);
static_assert(!std::__libcpp_integer<void>);
static_assert(!std::__libcpp_integer<int*>);
static_assert(!std::__libcpp_integer<unsigned int*>);
static_assert(!std::__libcpp_integer<SomeObject>);
static_assert(!std::__libcpp_integer<SomeEnum>);
static_assert(!std::__libcpp_integer<SomeScopedEnum>);
static_assert(!std::__signed_or_unsigned_integer<char8_t>);
static_assert(!std::__signed_or_unsigned_integer<char16_t>);
static_assert(!std::__signed_or_unsigned_integer<char32_t>);
static_assert(!std::__signed_or_unsigned_integer<float>);
static_assert(!std::__signed_or_unsigned_integer<double>);
static_assert(!std::__signed_or_unsigned_integer<long double>);
static_assert(!std::__signed_or_unsigned_integer<void>);
static_assert(!std::__signed_or_unsigned_integer<int*>);
static_assert(!std::__signed_or_unsigned_integer<unsigned int*>);
static_assert(!std::__signed_or_unsigned_integer<SomeObject>);
static_assert(!std::__signed_or_unsigned_integer<SomeEnum>);
static_assert(!std::__signed_or_unsigned_integer<SomeScopedEnum>);

62
libcxx/test/libcxx/concepts/concepts.arithmetic/__libcpp_signed_integer.compile.pass.cpp
View File

@@ -11,9 +11,9 @@
// Concept helpers for the internal type traits for the fundamental types.
// template <class _Tp>
// concept __libcpp_signed_integer;
// concept __signed_integer;
#include <concepts>
#include <__type_traits/integer_traits.h>
#include "test_macros.h"
@@ -24,40 +24,40 @@ enum SomeEnum {};
enum class SomeScopedEnum {};
// Unsigned
static_assert(!std::__libcpp_signed_integer<unsigned char>);
static_assert(!std::__libcpp_signed_integer<unsigned short int>);
static_assert(!std::__libcpp_signed_integer<unsigned int>);
static_assert(!std::__libcpp_signed_integer<unsigned long int>);
static_assert(!std::__libcpp_signed_integer<unsigned long long int>);
static_assert(!std::__libcpp_signed_integer<unsigned short int>);
static_assert(!std::__signed_integer<unsigned char>);
static_assert(!std::__signed_integer<unsigned short int>);
static_assert(!std::__signed_integer<unsigned int>);
static_assert(!std::__signed_integer<unsigned long int>);
static_assert(!std::__signed_integer<unsigned long long int>);
static_assert(!std::__signed_integer<unsigned short int>);
#if _LIBCPP_HAS_INT128
static_assert(!std::__libcpp_signed_integer<__uint128_t>);
static_assert(!std::__signed_integer<__uint128_t>);
#endif
// Signed
static_assert(std::__libcpp_signed_integer<signed char>);
static_assert(std::__libcpp_signed_integer<short int>);
static_assert(std::__libcpp_signed_integer<int>);
static_assert(std::__libcpp_signed_integer<long int>);
static_assert(std::__libcpp_signed_integer<long long int>);
static_assert(std::__libcpp_signed_integer<short int>);
static_assert(std::__signed_integer<signed char>);
static_assert(std::__signed_integer<short int>);
static_assert(std::__signed_integer<int>);
static_assert(std::__signed_integer<long int>);
static_assert(std::__signed_integer<long long int>);
static_assert(std::__signed_integer<short int>);
#if _LIBCPP_HAS_INT128
static_assert(std::__libcpp_signed_integer<__int128_t>);
static_assert(std::__signed_integer<__int128_t>);
#endif
// Non-integer
static_assert(!std::__libcpp_signed_integer<bool>);
static_assert(!std::__libcpp_signed_integer<char>);
static_assert(!std::__signed_integer<bool>);
static_assert(!std::__signed_integer<char>);
#ifndef TEST_HAS_NO_WIDE_CHARACTERS
static_assert(!std::__libcpp_signed_integer<wchar_t>);
static_assert(!std::__signed_integer<wchar_t>);
#endif
static_assert(!std::__libcpp_signed_integer<char8_t>);
static_assert(!std::__libcpp_signed_integer<char16_t>);
static_assert(!std::__libcpp_signed_integer<char32_t>);
static_assert(!std::__libcpp_signed_integer<float>);
static_assert(!std::__libcpp_signed_integer<double>);
static_assert(!std::__libcpp_signed_integer<long double>);
static_assert(!std::__libcpp_signed_integer<void>);
static_assert(!std::__libcpp_signed_integer<int*>);
static_assert(!std::__libcpp_signed_integer<unsigned int*>);
static_assert(!std::__libcpp_signed_integer<SomeObject>);
static_assert(!std::__libcpp_signed_integer<SomeEnum>);
static_assert(!std::__libcpp_signed_integer<SomeScopedEnum>);
static_assert(!std::__signed_integer<char8_t>);
static_assert(!std::__signed_integer<char16_t>);
static_assert(!std::__signed_integer<char32_t>);
static_assert(!std::__signed_integer<float>);
static_assert(!std::__signed_integer<double>);
static_assert(!std::__signed_integer<long double>);
static_assert(!std::__signed_integer<void>);
static_assert(!std::__signed_integer<int*>);
static_assert(!std::__signed_integer<unsigned int*>);
static_assert(!std::__signed_integer<SomeObject>);
static_assert(!std::__signed_integer<SomeEnum>);
static_assert(!std::__signed_integer<SomeScopedEnum>);

62
libcxx/test/libcxx/concepts/concepts.arithmetic/__libcpp_unsigned_integer.compile.pass.cpp
View File

@@ -11,9 +11,9 @@
// Concept helpers for the internal type traits for the fundamental types.
// template <class _Tp>
// concept __libcpp_unsigned_integer;
// concept __unsigned_integer;
#include <concepts>
#include <__type_traits/integer_traits.h>
#include "test_macros.h"
@@ -24,40 +24,40 @@ enum SomeEnum {};
enum class SomeScopedEnum {};
// Unsigned
static_assert(std::__libcpp_unsigned_integer<unsigned char>);
static_assert(std::__libcpp_unsigned_integer<unsigned short int>);
static_assert(std::__libcpp_unsigned_integer<unsigned int>);
static_assert(std::__libcpp_unsigned_integer<unsigned long int>);
static_assert(std::__libcpp_unsigned_integer<unsigned long long int>);
static_assert(std::__libcpp_unsigned_integer<unsigned short int>);
static_assert(std::__unsigned_integer<unsigned char>);
static_assert(std::__unsigned_integer<unsigned short int>);
static_assert(std::__unsigned_integer<unsigned int>);
static_assert(std::__unsigned_integer<unsigned long int>);
static_assert(std::__unsigned_integer<unsigned long long int>);
static_assert(std::__unsigned_integer<unsigned short int>);
#if _LIBCPP_HAS_INT128
static_assert(std::__libcpp_unsigned_integer<__uint128_t>);
static_assert(std::__unsigned_integer<__uint128_t>);
#endif
// Signed
static_assert(!std::__libcpp_unsigned_integer<signed char>);
static_assert(!std::__libcpp_unsigned_integer<short int>);
static_assert(!std::__libcpp_unsigned_integer<int>);
static_assert(!std::__libcpp_unsigned_integer<long int>);
static_assert(!std::__libcpp_unsigned_integer<long long int>);
static_assert(!std::__libcpp_unsigned_integer<short int>);
static_assert(!std::__unsigned_integer<signed char>);
static_assert(!std::__unsigned_integer<short int>);
static_assert(!std::__unsigned_integer<int>);
static_assert(!std::__unsigned_integer<long int>);
static_assert(!std::__unsigned_integer<long long int>);
static_assert(!std::__unsigned_integer<short int>);
#if _LIBCPP_HAS_INT128
static_assert(!std::__libcpp_unsigned_integer<__int128_t>);
static_assert(!std::__unsigned_integer<__int128_t>);
#endif
// Non-integer
static_assert(!std::__libcpp_unsigned_integer<bool>);
static_assert(!std::__libcpp_unsigned_integer<char>);
static_assert(!std::__unsigned_integer<bool>);
static_assert(!std::__unsigned_integer<char>);
#ifndef TEST_HAS_NO_WIDE_CHARACTERS
static_assert(!std::__libcpp_unsigned_integer<wchar_t>);
static_assert(!std::__unsigned_integer<wchar_t>);
#endif
static_assert(!std::__libcpp_unsigned_integer<char8_t>);
static_assert(!std::__libcpp_unsigned_integer<char16_t>);
static_assert(!std::__libcpp_unsigned_integer<char32_t>);
static_assert(!std::__libcpp_unsigned_integer<float>);
static_assert(!std::__libcpp_unsigned_integer<double>);
static_assert(!std::__libcpp_unsigned_integer<long double>);
static_assert(!std::__libcpp_unsigned_integer<void>);
static_assert(!std::__libcpp_unsigned_integer<int*>);
static_assert(!std::__libcpp_unsigned_integer<unsigned int*>);
static_assert(!std::__libcpp_unsigned_integer<SomeObject>);
static_assert(!std::__libcpp_unsigned_integer<SomeEnum>);
static_assert(!std::__libcpp_unsigned_integer<SomeScopedEnum>);
static_assert(!std::__unsigned_integer<char8_t>);
static_assert(!std::__unsigned_integer<char16_t>);
static_assert(!std::__unsigned_integer<char32_t>);
static_assert(!std::__unsigned_integer<float>);
static_assert(!std::__unsigned_integer<double>);
static_assert(!std::__unsigned_integer<long double>);
static_assert(!std::__unsigned_integer<void>);
static_assert(!std::__unsigned_integer<int*>);
static_assert(!std::__unsigned_integer<unsigned int*>);
static_assert(!std::__unsigned_integer<SomeObject>);
static_assert(!std::__unsigned_integer<SomeEnum>);
static_assert(!std::__unsigned_integer<SomeScopedEnum>);