[libcxx] rearranges all concept tests

[cjdb]

Summary

moves tests into directories matching their stable names so that the
tests can reflect the concept name

[ldionne]

I'm fine with this but I would like to see CI passing. Is this based on top of another patch that isn't in main? Also, if we agree that we don't like .compile.pass.cpp tests, I think we should get rid of that test format completely. I must admit I agree with @EricWF's comment about .compile.pass.cpp tests potentially causing runtime tests to be skipped.

[CaseyCarter]

In D99104#2642503, @ldionne wrote:

I must admit I agree with @EricWF's comment about .compile.pass.cpp tests potentially causing runtime tests to be skipped.

FWIW, we use a convention that main in a compile-only test is annotated (int main() {} // COMPILE-ONLY) to avoid such problems. This convention predates us actually having technology in our test runners to support compile-only tests, or we'd probably be using the superior int main() { return 1; } // COMPILE-ONLY. (Hmmm, I may go make a PR for that change right now.)

[cjdb]

removed the very unnecessary dependency on D98983

[zoecarver]

I won't oppose this patch, but FWIW, I would rather keep the .compile.pass.cpp tests and apply a comment as @CaseyCarter suggested. If there's a comment at the end of the function, I don't think anyone will accidentally modify it (and if they do, it will be easy to catch in review). Then we don't have to slow down the test suite (actually, it would be super interesting to see how much slower the test suite is after this change).

libcxx/test/std/concepts/concepts.callable/concept.regularinvocable/regular_invocable.pass.cpp

20

What do you think about doing this in two patches?

1. rename .compile.pass.cpp -> .pass.cpp.
2. move around the location in tree/rename files.

[• Quuxplusone]

@zoecarver wrote:

If there's a comment at the end of the function, I don't think anyone will accidentally modify it (and if they do, it will be easy to catch in review).

The failure mode to defend against is "someone creates a new .compile.pass.cpp test (maybe brain fart, or maybe because they think that's just the naming convention), without adding such a comment; and then adds runtime assertions to it." But suppose we have no .compile.pass.cpp tests checked in, so that nobody ever creates a new one by accident (because there's no old ones to copy); then that failure mode goes away forever. Also, any need to explain the difference to newbies also goes away. I think that getting into that world would be worth some (but not an arbitrarily large) buildbot slowdown.

It might be interesting for someone to measure the slowdown from globally changing all .compile.pass.cpp tests into .pass.cpp tests.

[cjdb]

libcxx/test/std/concepts/concepts.callable/concept.regularinvocable/regular_invocable.pass.cpp

20

What's the motivation? I'm not against it, just want to make sure the effort is justified.

[cjdb]

@zoecarver, for your inspection

[ldionne]

The original motivation for .compile.pass.cpp is to avoid running the tests when it's not needed. It doesn't actually matter in any current configuration we test in the CI, but it does matter a bit more when the executor is slow, for example when running the tests through SSH or when running on an emulator for some embedded chip. I still think it would be reasonable to get rid of them for the reasons explained by others, but I wanted to clarify what the actual purpose of that test format is.

[zoecarver]

Thanks for separating the patches. Now it's super easy to verify correctness. This LGTM (sans the comment about functions.h).

libcxx/test/std/concepts/callable/invocable.compile.pass.cpp

21

Where else is functions.h used? Maybe we should move it into this directory. Or maybe in the support folder?

[cjdb]

Will merge once CI passes.

libcxx/test/std/concepts/callable/invocable.compile.pass.cpp

21

I deliberately kept this one here because it's pretty specific to the tests for [concepts.callable] (and if I get my way, functions.h will be deleted in D99398).

[cjdb]

rebases to (hopefully) fix CI

libcxx/test/std/concepts/concepts.callable/concept.invocable/invocable.compile.pass.cpp

 // concept invocable;
 
 #include <chrono>
 #include <concepts>
 #include <memory>
 #include <random>
 #include <type_traits>
 
-#include "functions.h"
+#include "../functions.h"
 
 // clang-format off
 template <class F, class... Args>
 requires std::invocable<F, Args...>
 constexpr void ModelsInvocable(F, Args&&...) noexcept{}
 
 template <class F, class... Args>
 requires(!std::invocable<F, Args...>)

libcxx/test/std/concepts/concepts.callable/concept.regularinvocable/regular_invocable.pass.cpp

 // template<class T, class U>
 // concept regular_invocable;
 
 #include <concepts>
 #include <memory>
 #include <random>
 #include <type_traits>
 
-#include "functions.h"
+#include "../functions.h"
 
 // clang-format off
 template <class F, class... Args>
 requires std::regular_invocable<F, Args...>
 constexpr void ModelsRegularInvocable(F, Args&&...) noexcept {}
 
 template <class F, class... Args>
 requires (!std::regular_invocable<F, Args...>)

libcxx/test/std/concepts/concepts.lang/concept.constructible/constructible_from.compile.pass.cpp

void test() {
   test<std::unique_ptr<int>, std::unique_ptr<int> >();
   test<std::unique_ptr<int>, std::unique_ptr<int>&>();
   test<std::unique_ptr<int>, std::unique_ptr<int>&&>();
 
   test<std::array<int, 1> >();
   test<std::array<int, 1>, int>();
   test<std::array<int, 1>, int, int>();
 }
+
+int main(int, char**) { return 0; }

libcxx/test/std/concepts/concepts.lang/concepts.arithmetic/arithmetic.h

+//===----------------------------------------------------------------------===//
+//
+// 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 LIBCXX_TEST_CONCEPTS_LANG_CONCEPTS_ARITHMETIC_H_
+#define LIBCXX_TEST_CONCEPTS_LANG_CONCEPTS_ARITHMETIC_H_
+
+#include <concepts>
+
+// This overload should never be called. It exists solely to force subsumption.
+template <std::integral I>
+[[nodiscard]] constexpr bool CheckSubsumption(I) {
+  return false;
+}
+
+// clang-format off
+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>;
+}
+// clang-format on
+
+enum ClassicEnum { a, b, c };
+enum class ScopedEnum { x, y, z };
+struct EmptyStruct {};
+
+#endif // LIBCXX_TEST_CONCEPTS_LANG_CONCEPTS_ARITHMETIC_H_

libcxx/test/std/concepts/concepts.lang/concepts.arithmetic/floating_point.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
+// UNSUPPORTED: libcpp-no-concepts
+
+// template<class T>
+// concept floating_point = // see below
+
+#include <concepts>
+#include <type_traits>
+
+#include "arithmetic.h"
+
+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;
+}
+
+// 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::*)()>());
+
+int main(int, char**) { return 0; }

libcxx/test/std/concepts/concepts.lang/concepts.arithmetic/integral.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
+// UNSUPPORTED: libcpp-no-concepts
+
+// template<class T>
+// concept integral = // see below
+
+#include <concepts>
+#include <type_traits>
+
+#include "arithmetic.h"
+
+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;
+}
+
+// standard signed and unsigned integers
+static_assert(CheckIntegralQualifiers<signed char>());
+static_assert(CheckIntegralQualifiers<unsigned char>());
+static_assert(CheckIntegralQualifiers<short>());
+static_assert(CheckIntegralQualifiers<unsigned short>());
+static_assert(CheckIntegralQualifiers<int>());
+static_assert(CheckIntegralQualifiers<unsigned int>());
+static_assert(CheckIntegralQualifiers<long>());
+static_assert(CheckIntegralQualifiers<unsigned long>());
+static_assert(CheckIntegralQualifiers<long long>());
+static_assert(CheckIntegralQualifiers<unsigned long long>());
+
+// extended integers
+#ifndef _LIBCPP_HAS_NO_INT128
+static_assert(CheckIntegralQualifiers<__int128_t>());
+static_assert(CheckIntegralQualifiers<__uint128_t>());
+#endif
+
+// bool and char types are also integral
+static_assert(CheckIntegralQualifiers<wchar_t>());
+static_assert(CheckIntegralQualifiers<bool>());
+static_assert(CheckIntegralQualifiers<char>());
+static_assert(CheckIntegralQualifiers<char8_t>());
+static_assert(CheckIntegralQualifiers<char16_t>());
+static_assert(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::*)()>());
+
+static_assert(CheckSubsumption(0));
+static_assert(CheckSubsumption(0U));
+
+int main(int, char**) { return 0; }

libcxx/test/std/concepts/concepts.lang/concepts.arithmetic/signed_integral.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
+// UNSUPPORTED: libcpp-no-concepts
+
+// template<class T>
+// concept signed_integral = // see below
+
+#include <concepts>
+#include <type_traits>
+
+#include "arithmetic.h"
+
+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;
+}
+
+// standard signed integers
+static_assert(CheckSignedIntegralQualifiers<signed char>());
+static_assert(CheckSignedIntegralQualifiers<short>());
+static_assert(CheckSignedIntegralQualifiers<int>());
+static_assert(CheckSignedIntegralQualifiers<long>());
+static_assert(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
+static_assert(CheckSignedIntegralQualifiers<__int128_t>());
+static_assert(!CheckSignedIntegralQualifiers<__uint128_t>());
+#endif
+
+// 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::*)()>());
+
+static_assert(CheckSubsumption(0));
+static_assert(CheckSubsumption(0U));
+
+int main(int, char**) { return 0; }

libcxx/test/std/concepts/concepts.lang/concepts.arithmetic/unsigned_integral.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
+// UNSUPPORTED: libcpp-no-concepts
+
+// template<class T>
+// concept unsigned_integral = // see below
+
+#include <concepts>
+#include <type_traits>
+
+#include "arithmetic.h"
+
+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;
+}
+
+// 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
+static_assert(CheckUnsignedIntegralQualifiers<__uint128_t>());
+static_assert(!CheckUnsignedIntegralQualifiers<__int128_t>());
+#endif
+
+// 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::*)()>());
+
+static_assert(CheckSubsumption(0));
+static_assert(CheckSubsumption(0U));
+
+int main(int, char**) { return 0; }

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++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
-  static_assert(CheckIntegralQualifiers<signed char>());
-  static_assert(CheckIntegralQualifiers<unsigned char>());
-  static_assert(CheckIntegralQualifiers<short>());
-  static_assert(CheckIntegralQualifiers<unsigned short>());
-  static_assert(CheckIntegralQualifiers<int>());
-  static_assert(CheckIntegralQualifiers<unsigned int>());
-  static_assert(CheckIntegralQualifiers<long>());
-  static_assert(CheckIntegralQualifiers<unsigned long>());
-  static_assert(CheckIntegralQualifiers<long long>());
-  static_assert(CheckIntegralQualifiers<unsigned long long>());
-
-  // extended integers
-#ifndef _LIBCPP_HAS_NO_INT128
-  static_assert(CheckIntegralQualifiers<__int128_t>());
-  static_assert(CheckIntegralQualifiers<__uint128_t>());
-#endif
-
-  // bool and char types are also integral
-  static_assert(CheckIntegralQualifiers<wchar_t>());
-  static_assert(CheckIntegralQualifiers<bool>());
-  static_assert(CheckIntegralQualifiers<char>());
-  static_assert(CheckIntegralQualifiers<char8_t>());
-  static_assert(CheckIntegralQualifiers<char16_t>());
-  static_assert(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
-  static_assert(CheckSignedIntegralQualifiers<signed char>());
-  static_assert(CheckSignedIntegralQualifiers<short>());
-  static_assert(CheckSignedIntegralQualifiers<int>());
-  static_assert(CheckSignedIntegralQualifiers<long>());
-  static_assert(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
-  static_assert(CheckSignedIntegralQualifiers<__int128_t>());
-  static_assert(!CheckSignedIntegralQualifiers<__uint128_t>());
-#endif
-
-  // 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
-  static_assert(CheckUnsignedIntegralQualifiers<__uint128_t>());
-  static_assert(!CheckUnsignedIntegralQualifiers<__int128_t>());
-#endif
-
-  // 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;
-}
-
-// clang-format off
-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>;
-}
-// clang-format on
-
-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;
-}