adds [concepts.arithmetic]

[cjdb]

Summary

Adds:

• std::integral
• std::signed_integral
• std::unsigned_integral
• std::floating_point

[cjdb]

libcxx/test/std/concepts/lang/arithmetic.pass.cpp

30

This formatting feels off but it's what git clang-format-12 HEAD~1 gave me. Can someone please confirm this is the correct style?

[miscco]

Some small nits

libcxx/test/std/concepts/lang/arithmetic.pass.cpp

30

I believe that there is no libc++ code style yet, @ldionne what are the chances of defining one?

31

Would it simplify the testing when we had a function like this

cpp
template <typename T, bool Expected>
constexpr void CheckQualifiers() {
     static_assert(std::integral<T> == Expected);
     static_assert(std::integral<const T> == Expected);
     static_assert(std::integral<volatile T> == Expected);
     static_assert(std::integral<const volatile T> == Expected);

     static_assert(!std::integral<T&>);
     static_assert(!std::integral<const T&>);
     static_assert(!std::integral<volatile T&>);
     static_assert(!std::integral<const volatile T&>);

     static_assert(!std::integral<T*>);
     static_assert(!std::integral<const T*>);
     static_assert(!std::integral<volatile T*>);
     static_assert(!std::integral<const volatile T*>);
}

45

I believe this counts as extended integer types?

[CaseyCarter]

libcxx/include/concepts

164

Pre-existing: did GCC start supporting __is_convertible_to while I wasn't looking, or is this clang-only?

libcxx/test/std/concepts/lang/arithmetic.pass.cpp

30

I'd call these "standard signed and unsigned integer types".

31

Having written a few such functions, I suggest a slight modification to:

template <typename T>
constexpr bool CheckQualifiers() {
    constexpr bool result = std::integral<T>;
    static_assert(std::integral<const T> == result);
    static_assert(std::integral<volatile T> == result);
    static_assert(std::integral<const volatile T> == result);

    static_assert(!std::integral<T&>);
    static_assert(!std::integral<const T&>);
    static_assert(!std::integral<volatile T&>);
    static_assert(!std::integral<const volatile T&>);

    static_assert(!std::integral<T*>);
    static_assert(!std::integral<const T*>);
    static_assert(!std::integral<volatile T*>);
    static_assert(!std::integral<const volatile T*>);

    return result;
}

so you can more easily static_assert(CheckQualifiers<int>()); static_assert(!CheckQualifiers<void(*)(int) const>);.

45

"Extended integer types" are implementation-defined types with the same properties as integral types; __int128 is almost an extended integer type, for example. Formally, these are "integer types that are neither signed nor unsigned integer types" - which is far from a fantastic name. The colloquial "character or bool types" is probably clearer to folks who don't list Standardese as their first language.

76–78

None of these Sneaky members are used - they could be elided. Of course it's then odd to have a dozen-ish empty structs with different names; you could as well use EmptyStruct for all of these. (A type T doesn't need to have any members of type U for us to form the pointer-to-member type U T::*.)

[cjdb]

@CaseyCarter @miscco @ldionne @EricWF I think this has addressed all the comments and should be good to merge.
Input from @CaseyCarter on the new CheckSubsumption appreciated, since that check always trips me up.

libcxx/include/concepts

164

I've done something weird here with Git because D74292 is still open.

libcxx/test/std/concepts/lang/arithmetic.pass.cpp

76–78

Thanks, that simplifies things a lot!

[cjdb]

Activates CI

[ldionne]

In D88131#2543070, @cjdb wrote:

Activates CI

Are you using arc diff to upload patches? The Phab -> BuildKite bridge seems to have trouble applying your patches, not sure why.

[cjdb]

Rebased for CI

[cjdb]

In D88131#2545799, @ldionne wrote:

In D88131#2543070, @cjdb wrote:

Activates CI

Are you using arc diff to upload patches? The Phab -> BuildKite bridge seems to have trouble applying your patches, not sure why.

No, I've been using the Phab web interface. Do you recommend I try the CLI tool instead?

[Mordante]

In D88131#2547168, @cjdb wrote:

In D88131#2545799, @ldionne wrote:

Are you using arc diff to upload patches? The Phab -> BuildKite bridge seems to have trouble applying your patches, not sure why.

No, I've been using the Phab web interface. Do you recommend I try the CLI tool instead?

Without the CLI tool the CI will not automatically rebuild the new diff. This is an issue with Phabricator.

libcxx/include/concepts

187

Interesting to it written like this, it compares integral<_Tp> twice. (Just a remark, since this matches the Standard.)

libcxx/test/std/concepts/lang/arithmetic.pass.cpp

73

Can you also test __int128_t and __uint128_t where applicable? This can be guarded with #ifndef _LIBCPP_HAS_NO_INT128.

[cjdb]

addresses CI issues and Mordante's request

[cjdb]

libcxx/include/concepts

187

This is for subsumption, see my tests below :-)

[ldionne]

Mostly nitpicks, except the part about intrinsics which I would really like to de-duplicate.

libcxx/include/concepts

180

Same comment about not duplicating the implementation to use intrinsics, since they are already used by the type traits.

libcxx/test/std/concepts/lang/arithmetic.pass.cpp

31

Really clever.

165

No need for these comments for small #if pairs.

264

Is that the result of clang-format? This seems weirdly aligned, no?

[cjdb]

removes conditional concept definitions as disucssed with Louis offline

libcxx/test/std/concepts/lang/arithmetic.pass.cpp

264

Yeah, I believe there's some new settings in clang-format-13 to handle concepts, requires-expressions, and requires-clauses properly. For the time being, I've just added some much-hated comments :-)

libcxx/include/concepts

 
 template<class _Tp, class _Up>
 concept same_as = __same_as_impl<_Tp, _Up> && __same_as_impl<_Up, _Tp>;
 
 // [concept.destructible]
 
 template<class _Tp>
 concept destructible = _VSTD::is_nothrow_destructible_v<_Tp>;
 
 // [concept.constructible]
 template<class _Tp, class... _Args>
 concept constructible_from =
     destructible<_Tp> && _VSTD::is_constructible_v<_Tp, _Args...>;
 
 // [concept.default.init]
 
 template<class _Tp>
 concept __default_initializable = requires { ::new _Tp; };
 
 template<class _Tp>
 concept default_initializable = constructible_from<_Tp> &&
     requires { _Tp{}; } && __default_initializable<_Tp>;
 
+// [concepts.arithmetic], arithmetic concepts
+#ifdef __clang__
+template<class _Tp>
+concept integral = __is_integral(_Tp);
+
+template<class _Tp>
+concept signed_integral = integral<_Tp> && __is_signed(_Tp);
+
+template<class _Tp>
+concept unsigned_integral = integral<_Tp> && !signed_integral<_Tp>;
+
+template<class _Tp>
+concept floating_point = __is_floating_point(_Tp);
+#else
+template<class _Tp>
+concept integral = _VSTD::is_integral_v<_Tp>;
+
+template<class _Tp>
+concept signed_integral = integral<_Tp> && _VSTD::is_signed_v<_Tp>;
+
+template<class _Tp>
+concept unsigned_integral = integral<_Tp> && !signed_integral<_Tp>;
+
+template<class _Tp>
+concept floating_point = _VSTD::is_floating_point_v<_Tp>;
+#endif // __clang__
 
 #endif //_LIBCPP_STD_VER > 17 && defined(__cpp_concepts) && __cpp_concepts >= 201811L
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP_CONCEPTS

libcxx/test/std/concepts/lang/arithmetic.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++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+
+// template<class T>
+// concept integral = // see below
+
+// template<class T>
+// concept signed_integral = // see below
+
+// template<class T>
+// concept unsigned_integral = // see below
+
+// template<class T>
+// concept floating_point = // see below
+
+#include <concepts>
+#include <type_traits>
+
+namespace {
+template <typename T>
+constexpr bool CheckIntegralQualifiers() {
+  constexpr bool result = std::integral<T>;
+  static_assert(std::integral<const T> == result);
+  static_assert(std::integral<volatile T> == result);
+  static_assert(std::integral<const volatile T> == result);
+
+  static_assert(!std::integral<T&>);
+  static_assert(!std::integral<const T&>);
+  static_assert(!std::integral<volatile T&>);
+  static_assert(!std::integral<const volatile T&>);
+
+  static_assert(!std::integral<T&&>);
+  static_assert(!std::integral<const T&&>);
+  static_assert(!std::integral<volatile T&&>);
+  static_assert(!std::integral<const volatile T&&>);
+
+  static_assert(!std::integral<T*>);
+  static_assert(!std::integral<const T*>);
+  static_assert(!std::integral<volatile T*>);
+  static_assert(!std::integral<const volatile T*>);
+
+  static_assert(!std::integral<T (*)()>);
+  static_assert(!std::integral<T (&)()>);
+  static_assert(!std::integral<T(&&)()>);
+
+  return result;
+}
+
+enum ClassicEnum { a, b, c };
+enum class ScopedEnum { x, y, z };
+struct EmptyStruct {};
+
+constexpr void CheckIntegral() {
+  // standard signed and unsigned integers
+  CheckIntegralQualifiers<signed char>();
+  CheckIntegralQualifiers<unsigned char>();
+  CheckIntegralQualifiers<short>();
+  CheckIntegralQualifiers<unsigned short>();
+  CheckIntegralQualifiers<int>();
+  CheckIntegralQualifiers<unsigned int>();
+  CheckIntegralQualifiers<long>();
+  CheckIntegralQualifiers<unsigned long>();
+  CheckIntegralQualifiers<long long>();
+  CheckIntegralQualifiers<unsigned long long>();
+
+  // extended integers
+#ifndef _LIBCPP_HAS_NO_INT128
+  CheckIntegralQualifiers<__int128_t>();
+  CheckIntegralQualifiers<__uint128_t>();
+#endif // _LIBCPP_HAS_NO_INT128
+
+  // bool and char types are also integral
+  CheckIntegralQualifiers<wchar_t>();
+  CheckIntegralQualifiers<bool>();
+  CheckIntegralQualifiers<char>();
+  CheckIntegralQualifiers<char8_t>();
+  CheckIntegralQualifiers<char16_t>();
+  CheckIntegralQualifiers<char32_t>();
+
+  // types that aren't integral
+  static_assert(!std::integral<void>);
+  static_assert(!CheckIntegralQualifiers<float>());
+  static_assert(!CheckIntegralQualifiers<double>());
+  static_assert(!CheckIntegralQualifiers<long double>());
+
+  static_assert(!CheckIntegralQualifiers<ClassicEnum>());
+
+  static_assert(!CheckIntegralQualifiers<ScopedEnum>());
+
+  static_assert(!CheckIntegralQualifiers<EmptyStruct>());
+  static_assert(!CheckIntegralQualifiers<int EmptyStruct::*>());
+  static_assert(!CheckIntegralQualifiers<int (EmptyStruct::*)()>());
+}
+
+template <typename T>
+constexpr bool CheckSignedIntegralQualifiers() {
+  constexpr bool result = std::signed_integral<T>;
+  static_assert(std::signed_integral<const T> == result);
+  static_assert(std::signed_integral<volatile T> == result);
+  static_assert(std::signed_integral<const volatile T> == result);
+
+  static_assert(!std::signed_integral<T&>);
+  static_assert(!std::signed_integral<const T&>);
+  static_assert(!std::signed_integral<volatile T&>);
+  static_assert(!std::signed_integral<const volatile T&>);
+
+  static_assert(!std::signed_integral<T&&>);
+  static_assert(!std::signed_integral<const T&&>);
+  static_assert(!std::signed_integral<volatile T&&>);
+  static_assert(!std::signed_integral<const volatile T&&>);
+
+  static_assert(!std::signed_integral<T*>);
+  static_assert(!std::signed_integral<const T*>);
+  static_assert(!std::signed_integral<volatile T*>);
+  static_assert(!std::signed_integral<const volatile T*>);
+
+  static_assert(!std::signed_integral<T (*)()>);
+  static_assert(!std::signed_integral<T (&)()>);
+  static_assert(!std::signed_integral<T(&&)()>);
+
+  return result;
+}
+
+constexpr void CheckSignedIntegral() {
+  // standard signed integers
+  CheckSignedIntegralQualifiers<signed char>();
+  CheckSignedIntegralQualifiers<short>();
+  CheckSignedIntegralQualifiers<int>();
+  CheckSignedIntegralQualifiers<long>();
+  CheckSignedIntegralQualifiers<long long>();
+
+  // bool and character *may* be signed
+  static_assert(CheckSignedIntegralQualifiers<wchar_t>() ==
+                std::is_signed_v<wchar_t>);
+  static_assert(CheckSignedIntegralQualifiers<bool>() ==
+                std::is_signed_v<bool>);
+  static_assert(CheckSignedIntegralQualifiers<char>() ==
+                std::is_signed_v<char>);
+  static_assert(CheckSignedIntegralQualifiers<char8_t>() ==
+                std::is_signed_v<char8_t>);
+  static_assert(CheckSignedIntegralQualifiers<char16_t>() ==
+                std::is_signed_v<char16_t>);
+  static_assert(CheckSignedIntegralQualifiers<char32_t>() ==
+                std::is_signed_v<char32_t>);
+
+  // integers that aren't signed integrals
+  static_assert(!CheckSignedIntegralQualifiers<unsigned char>());
+  static_assert(!CheckSignedIntegralQualifiers<unsigned short>());
+  static_assert(!CheckSignedIntegralQualifiers<unsigned int>());
+  static_assert(!CheckSignedIntegralQualifiers<unsigned long>());
+  static_assert(!CheckSignedIntegralQualifiers<unsigned long long>());
+
+  // extended integers
+#ifndef _LIBCPP_HAS_NO_INT128
+  CheckSignedIntegralQualifiers<__int128_t>();
+  static_assert(!CheckSignedIntegralQualifiers<__uint128_t>());
+#endif // _LIBCPP_HAS_NO_INT128
+
+  // types that aren't even integers shouldn't be signed integers!
+  static_assert(!std::signed_integral<void>);
+  static_assert(!CheckSignedIntegralQualifiers<float>());
+  static_assert(!CheckSignedIntegralQualifiers<double>());
+  static_assert(!CheckSignedIntegralQualifiers<long double>());
+
+  static_assert(!CheckSignedIntegralQualifiers<ClassicEnum>());
+  static_assert(!CheckSignedIntegralQualifiers<ScopedEnum>());
+  static_assert(!CheckSignedIntegralQualifiers<EmptyStruct>());
+  static_assert(!CheckSignedIntegralQualifiers<int EmptyStruct::*>());
+  static_assert(!CheckSignedIntegralQualifiers<int (EmptyStruct::*)()>());
+}
+
+template <typename T>
+constexpr bool CheckUnsignedIntegralQualifiers() {
+  constexpr bool result = std::unsigned_integral<T>;
+  static_assert(std::unsigned_integral<const T> == result);
+  static_assert(std::unsigned_integral<volatile T> == result);
+  static_assert(std::unsigned_integral<const volatile T> == result);
+
+  static_assert(!std::unsigned_integral<T&>);
+  static_assert(!std::unsigned_integral<const T&>);
+  static_assert(!std::unsigned_integral<volatile T&>);
+  static_assert(!std::unsigned_integral<const volatile T&>);
+
+  static_assert(!std::unsigned_integral<T&&>);
+  static_assert(!std::unsigned_integral<const T&&>);
+  static_assert(!std::unsigned_integral<volatile T&&>);
+  static_assert(!std::unsigned_integral<const volatile T&&>);
+
+  static_assert(!std::unsigned_integral<T*>);
+  static_assert(!std::unsigned_integral<const T*>);
+  static_assert(!std::unsigned_integral<volatile T*>);
+  static_assert(!std::unsigned_integral<const volatile T*>);
+
+  static_assert(!std::unsigned_integral<T (*)()>);
+  static_assert(!std::unsigned_integral<T (&)()>);
+  static_assert(!std::unsigned_integral<T(&&)()>);
+
+  return result;
+}
+
+constexpr void CheckUnsignedIntegral() {
+  // standard unsigned types
+  static_assert(CheckUnsignedIntegralQualifiers<unsigned char>());
+  static_assert(CheckUnsignedIntegralQualifiers<unsigned short>());
+  static_assert(CheckUnsignedIntegralQualifiers<unsigned int>());
+  static_assert(CheckUnsignedIntegralQualifiers<unsigned long>());
+  static_assert(CheckUnsignedIntegralQualifiers<unsigned long long>());
+
+  // Whether bool and character types are signed or unsigned is impl-defined
+  static_assert(CheckUnsignedIntegralQualifiers<wchar_t>() ==
+                !std::is_signed_v<wchar_t>);
+  static_assert(CheckUnsignedIntegralQualifiers<bool>() ==
+                !std::is_signed_v<bool>);
+  static_assert(CheckUnsignedIntegralQualifiers<char>() ==
+                !std::is_signed_v<char>);
+  static_assert(CheckUnsignedIntegralQualifiers<char8_t>() ==
+                !std::is_signed_v<char8_t>);
+  static_assert(CheckUnsignedIntegralQualifiers<char16_t>() ==
+                !std::is_signed_v<char16_t>);
+  static_assert(CheckUnsignedIntegralQualifiers<char32_t>() ==
+                !std::is_signed_v<char32_t>);
+
+  // extended integers
+#ifndef _LIBCPP_HAS_NO_INT128
+  CheckUnsignedIntegralQualifiers<__uint128_t>();
+  static_assert(!CheckUnsignedIntegralQualifiers<__int128_t>());
+#endif // _LIBCPP_HAS_NO_INT128
+
+  // integer types that aren't unsigned integrals
+  static_assert(!CheckUnsignedIntegralQualifiers<signed char>());
+  static_assert(!CheckUnsignedIntegralQualifiers<short>());
+  static_assert(!CheckUnsignedIntegralQualifiers<int>());
+  static_assert(!CheckUnsignedIntegralQualifiers<long>());
+  static_assert(!CheckUnsignedIntegralQualifiers<long long>());
+
+  static_assert(!std::unsigned_integral<void>);
+  static_assert(!CheckUnsignedIntegralQualifiers<float>());
+  static_assert(!CheckUnsignedIntegralQualifiers<double>());
+  static_assert(!CheckUnsignedIntegralQualifiers<long double>());
+
+  static_assert(!CheckUnsignedIntegralQualifiers<ClassicEnum>());
+  static_assert(!CheckUnsignedIntegralQualifiers<ScopedEnum>());
+  static_assert(!CheckUnsignedIntegralQualifiers<EmptyStruct>());
+  static_assert(!CheckUnsignedIntegralQualifiers<int EmptyStruct::*>());
+  static_assert(!CheckUnsignedIntegralQualifiers<int (EmptyStruct::*)()>());
+}
+
+// This overload should never be called. It exists solely to force subsumption.
+template <std::integral I>
+[[nodiscard]] constexpr bool CheckSubsumption(I) {
+  return false;
+}
+
+template <std::integral I>
+    requires std::signed_integral<I> && (!std::unsigned_integral<I>)
+                                            [[nodiscard]] constexpr
+    bool CheckSubsumption(I) {
+  return std::is_signed_v<I>;
+}
+
+template <std::integral I>
+    requires std::unsigned_integral<I> && (!std::signed_integral<I>)
+                                              [[nodiscard]] constexpr
+    bool CheckSubsumption(I) {
+  return std::is_unsigned_v<I>;
+}
+
+template <typename T>
+constexpr bool CheckFloatingPointQualifiers() {
+  constexpr bool result = std::floating_point<T>;
+  static_assert(std::floating_point<const T> == result);
+  static_assert(std::floating_point<volatile T> == result);
+  static_assert(std::floating_point<const volatile T> == result);
+
+  static_assert(!std::floating_point<T&>);
+  static_assert(!std::floating_point<const T&>);
+  static_assert(!std::floating_point<volatile T&>);
+  static_assert(!std::floating_point<const volatile T&>);
+
+  static_assert(!std::floating_point<T&&>);
+  static_assert(!std::floating_point<const T&&>);
+  static_assert(!std::floating_point<volatile T&&>);
+  static_assert(!std::floating_point<const volatile T&&>);
+
+  static_assert(!std::floating_point<T*>);
+  static_assert(!std::floating_point<const T*>);
+  static_assert(!std::floating_point<volatile T*>);
+  static_assert(!std::floating_point<const volatile T*>);
+
+  static_assert(!std::floating_point<T (*)()>);
+  static_assert(!std::floating_point<T (&)()>);
+  static_assert(!std::floating_point<T(&&)()>);
+
+  return result;
+}
+
+constexpr void CheckFloatingPoint() {
+  // floating-point types
+  static_assert(CheckFloatingPointQualifiers<float>());
+  static_assert(CheckFloatingPointQualifiers<double>());
+  static_assert(CheckFloatingPointQualifiers<long double>());
+
+  // types that aren't floating-point
+  static_assert(!CheckFloatingPointQualifiers<signed char>());
+  static_assert(!CheckFloatingPointQualifiers<unsigned char>());
+  static_assert(!CheckFloatingPointQualifiers<short>());
+  static_assert(!CheckFloatingPointQualifiers<unsigned short>());
+  static_assert(!CheckFloatingPointQualifiers<int>());
+  static_assert(!CheckFloatingPointQualifiers<unsigned int>());
+  static_assert(!CheckFloatingPointQualifiers<long>());
+  static_assert(!CheckFloatingPointQualifiers<unsigned long>());
+  static_assert(!CheckFloatingPointQualifiers<long long>());
+  static_assert(!CheckFloatingPointQualifiers<unsigned long long>());
+  static_assert(!CheckFloatingPointQualifiers<wchar_t>());
+  static_assert(!CheckFloatingPointQualifiers<bool>());
+  static_assert(!CheckFloatingPointQualifiers<char>());
+  static_assert(!CheckFloatingPointQualifiers<char8_t>());
+  static_assert(!CheckFloatingPointQualifiers<char16_t>());
+  static_assert(!CheckFloatingPointQualifiers<char32_t>());
+  static_assert(!std::floating_point<void>);
+
+  static_assert(!CheckFloatingPointQualifiers<ClassicEnum>());
+  static_assert(!CheckFloatingPointQualifiers<ScopedEnum>());
+  static_assert(!CheckFloatingPointQualifiers<EmptyStruct>());
+  static_assert(!CheckFloatingPointQualifiers<int EmptyStruct::*>());
+  static_assert(!CheckFloatingPointQualifiers<int (EmptyStruct::*)()>());
+}
+} // namespace
+
+int main(int, char**) {
+  CheckIntegral();
+  CheckSignedIntegral();
+  CheckUnsignedIntegral();
+  static_assert(CheckSubsumption(0));
+  static_assert(CheckSubsumption(0U));
+  CheckFloatingPoint();
+  return 0;
+}