[libc++] Adds TEST_IF_INT128.

[Mordante]

Summary

This macro makes it possible to conditionally enable code when 128-bit
integral support is available. This improves the readablity of the
tests. (This patch is also intended to be used in new format tests.)

[ldionne]

I will admit I'm not convinced that we're saving much here, in particular I'm a bit concerned with the fact that these IF(...) macros are less usual (if more terse) than the basic #if defined(...), and so one might have to look it up.

All in all I'm not strongly against, and I especially don't want to block you if it makes a big difference in upcoming std::format tests, but if the gain in std::format is not compelling, I'd rather not do this. If it's a compelling gain for std::format, I can definitely live with this.

[• Quuxplusone]

I agree with what Louis said: the cost/benefit seems not favorable at the moment. (I hadn't looked at this yet because I assumed it was adding the-equivalent-of-TEST_HAS_NO_INT128 — I forgot we already had one of those!)
If you do land this, could you name it TEST_IF_HAS_INT128?

[Mordante]

For format I use it in a few places. The difference there is it's at the end of the list which makes it more awkward to use #ifdef due to the "hanging" >. For example

  std::tuple<
      unsigned long long, long long, unsigned long, long, unsigned int, int,
      unsigned short, short, unsigned char, signed char
#ifndef TEST_HAS_NO_INT128
      , __int128_t, __uint128_t
#endif
      > types;

The reason to put them at the end is that the test does something like auto foo = std::get<1>(types).

Regarding the name, I based the name on _LIBCPP_IF_WIDE_CHARACTERS which also lacks _HAS. I prefer to keep things consistent. @ldionne @Quuxplusone do you prefer 1 or 2?

1. _LIBCPP_IF_WIDE_CHARACTERS and TEST_IF_INT128
2. _LIBCPP_IF_HAS_WIDE_CHARACTERS and TEST_IF_HAS_INT128

Based on Arthur's suggestion I'm now more tending to option 2.

[• Quuxplusone]

In D118926#3305279, @Mordante wrote:

For format I use it in a few places. The difference there is it's at the end of the list which makes it more awkward to use #ifdef due to the "hanging" >. [...] The reason to put them at the end is that the test does something like auto foo = std::get<1>(types).

Sounds like std::get<1>(types) is the root of the problem. Since you know get<1>(types) is always long long, why not replace the magic number 1 with the "magic number" long long? Then the test would be more robust not only against people adding uint128_t at the beginning of the list, but also against people sorting the list, or adding char16_t, or whatever other permutations they might do under maintenance. (Btw, I can imagine a reason it wouldn't be quite that simple: maybe the type list contains both long long and int64_t, so long long would be ambiguous while 1 is unambiguous. But still.)

Also, how come these format-uses aren't part of this PR? Are they not landed yet? Could we defer this PR until after the format-uses are landed, and/or take this (currently too-abstract) discussion over to that PR?

1. _LIBCPP_IF_WIDE_CHARACTERS and TEST_IF_INT128
2. _LIBCPP_IF_HAS_WIDE_CHARACTERS and TEST_IF_HAS_INT128

Based on Arthur's suggestion I'm now more tending to option 2.

Weakly option 2. However, I remain unconvinced that the macro is needed at all.

[Mordante]

I'll leave this open for the other use case.
@ldionne which do you prefer for naming 1 or 2? When also 2 I'll make a separate patch to s/_LIBCPP_IF_WIDE_CHARACTERS/_LIBCPP_IF_HAS_WIDE_CHARACTERS/

[ldionne]

In D118926#3308241, @Mordante wrote:

I'll leave this open for the other use case.
@ldionne which do you prefer for naming 1 or 2? When also 2 I'll make a separate patch to s/_LIBCPP_IF_WIDE_CHARACTERS/_LIBCPP_IF_HAS_WIDE_CHARACTERS/

I've looked at the places where this is used in D121514 and my preference to use a simple #if defined(...) would remain, TBH. It's only used in two places in D121514, and the unusual look of the macro makes me scratch my head more than anything.

[Mordante]

As discussed: When this patch doesn't carry its weight for D121514 we won't land this.

libcxx/test/std/utilities/utility/utility.intcmp/intcmp.cmp_equal/cmp_equal.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

 
 template <class... Ts, class UTuple>
 constexpr void test2(const std::tuple<Ts...>&, const UTuple& utuple) {
   (test2_impl<Ts>(utuple) , ...);
 }
 
 constexpr bool test() {
   std::tuple<
-#ifndef TEST_HAS_NO_INT128
-      __int128_t, __uint128_t,
-#endif
+      TEST_IF_INT128(__int128_t, __uint128_t,)
       unsigned long long, long long, unsigned long, long, unsigned int, int,
       unsigned short, short, unsigned char, signed char> types;
   test1(types);
   test2(types, types);
   return true;
 }
 
 int main(int, char**) {
   ASSERT_NOEXCEPT(std::cmp_equal(0, 0));
   test();
   static_assert(test());
   return 0;
 }

libcxx/test/std/utilities/utility/utility.intcmp/intcmp.cmp_greater/cmp_greater.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

 
 template <class... Ts, class UTuple>
 constexpr void test2(const std::tuple<Ts...>&, const UTuple& utuple) {
   (test2_impl<Ts>(utuple) , ...);
 }
 
 constexpr bool test() {
   std::tuple<
-#ifndef TEST_HAS_NO_INT128
-      __int128_t, __uint128_t,
-#endif
+      TEST_IF_INT128(__int128_t, __uint128_t,)
       unsigned long long, long long, unsigned long, long, unsigned int, int,
       unsigned short, short, unsigned char, signed char> types;
   test1(types);
   test2(types, types);
   return true;
 }
 
 int main(int, char**) {
   ASSERT_NOEXCEPT(std::cmp_greater(1, 0));
   test();
   static_assert(test());
   return 0;
 }

libcxx/test/std/utilities/utility/utility.intcmp/intcmp.cmp_greater_equal/cmp_greater_equal.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

 
 template <class... Ts, class UTuple>
 constexpr void test2(const std::tuple<Ts...>&, const UTuple& utuple) {
   (test2_impl<Ts>(utuple) , ...);
 }
 
 constexpr bool test() {
   std::tuple<
-#ifndef TEST_HAS_NO_INT128
-      __int128_t, __uint128_t,
-#endif
+      TEST_IF_INT128(__int128_t, __uint128_t,)
       unsigned long long, long long, unsigned long, long, unsigned int, int,
       unsigned short, short, unsigned char, signed char> types;
   test1(types);
   test2(types, types);
   return true;
 }
 
 int main(int, char**) {
   ASSERT_NOEXCEPT(std::cmp_greater_equal(1, 0));
   test();
   static_assert(test());
   return 0;
 }

libcxx/test/std/utilities/utility/utility.intcmp/intcmp.cmp_less/cmp_less.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

 
 template <class... Ts, class UTuple>
 constexpr void test2(const std::tuple<Ts...>&, const UTuple& utuple) {
   (test2_impl<Ts>(utuple) , ...);
 }
 
 constexpr bool test() {
   std::tuple<
-#ifndef TEST_HAS_NO_INT128
-      __int128_t, __uint128_t,
-#endif
+      TEST_IF_INT128(__int128_t, __uint128_t,)
       unsigned long long, long long, unsigned long, long, unsigned int, int,
       unsigned short, short, unsigned char, signed char> types;
   test1(types);
   test2(types, types);
   return true;
 }
 
 int main(int, char**) {
   ASSERT_NOEXCEPT(std::cmp_less(0, 1));
   test();
   static_assert(test());
   return 0;
 }

libcxx/test/std/utilities/utility/utility.intcmp/intcmp.cmp_less_equal/cmp_less_equal.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

 
 template <class... Ts, class UTuple>
 constexpr void test2(const std::tuple<Ts...>&, const UTuple& utuple) {
   (test2_impl<Ts>(utuple) , ...);
 }
 
 constexpr bool test() {
   std::tuple<
-#ifndef TEST_HAS_NO_INT128
-      __int128_t, __uint128_t,
-#endif
+      TEST_IF_INT128(__int128_t, __uint128_t,)
       unsigned long long, long long, unsigned long, long, unsigned int, int,
       unsigned short, short, unsigned char, signed char> types;
   test1(types);
   test2(types, types);
   return true;
 }
 
 int main(int, char**) {
   ASSERT_NOEXCEPT(std::cmp_less_equal(0, 1));
   test();
   static_assert(test());
   return 0;
 }

libcxx/test/std/utilities/utility/utility.intcmp/intcmp.cmp_not_equal/cmp_not_equal.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

 
 template <class... Ts, class UTuple>
 constexpr void test2(const std::tuple<Ts...>&, const UTuple& utuple) {
   (test2_impl<Ts>(utuple) , ...);
 }
 
 constexpr bool test() {
   std::tuple<
-#ifndef TEST_HAS_NO_INT128
-      __int128_t, __uint128_t,
-#endif
+      TEST_IF_INT128(__int128_t, __uint128_t,)
       unsigned long long, long long, unsigned long, long, unsigned int, int,
       unsigned short, short, unsigned char, signed char> types;
   test1(types);
   test2(types, types);
   return true;
 }
 
 int main(int, char**) {
   ASSERT_NOEXCEPT(std::cmp_not_equal(0, 0));
   test();
   static_assert(test());
   return 0;
 }

libcxx/test/std/utilities/utility/utility.intcmp/intcmp.in_range/in_range.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

 
 template <class... Ts>
 constexpr void test1(const std::tuple<Ts...>&) {
   (test_in_range1<Ts>() , ...);
 }
 
 constexpr bool test() {
   std::tuple<
-#ifndef TEST_HAS_NO_INT128
-      __int128_t, __uint128_t,
-#endif
+      TEST_IF_INT128(__int128_t, __uint128_t,)
       unsigned long long, long long, unsigned long, long, unsigned int, int,
       unsigned short, short, unsigned char, signed char> types;
   test1(types);
   test_in_range();
   return true;
 }
 
 int main(int, char**) {
   ASSERT_NOEXCEPT(std::in_range<int>(-1));
   test();
   static_assert(test());
   return 0;
 }

libcxx/test/support/test_macros.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 

 #if defined(_LIBCPP_HAS_NO_UNICODE)
 #   define TEST_HAS_NO_UNICODE
 #elif defined(_MSVC_EXECUTION_CHARACTER_SET) && _MSVC_EXECUTION_CHARACTER_SET != 65001
 #   define TEST_HAS_NO_UNICODE
 #endif
 
 #if defined(_LIBCPP_HAS_NO_INT128) || defined(TEST_COMPILER_MSVC)
 #   define TEST_HAS_NO_INT128
+#   define TEST_IF_INT128(...)
+#else
+#   define TEST_IF_INT128(...) __VA_ARGS__
 #endif
 
 #if defined(_LIBCPP_HAS_NO_UNICODE_CHARS)
 #   define TEST_HAS_NO_UNICODE_CHARS
 #endif
 
 #if defined(__GNUC__)
 #pragma GCC diagnostic pop
 #endif
 
 #endif // SUPPORT_TEST_MACROS_HPP