[libc++] Fix modules issues on OS X

[ldionne]

Summary

First, fix a collision with the Point type from MacTypes.h, which was
reported on Slack, 2022-07-31: https://cpplang.slack.com/archives/C2X659D1B/p1659284691275889

Second, rename the meta:: namespace to TestMeta::. OSX's "/usr/include/ncurses.h"
defines a meta function, and is (for some reason) included in
"<SDK>/usr/include/module.modulemap", so that identifier is
off-limits for us to use in anything that compiles with -fmodules:

libcxx/test/support/type_algorithms.h:16:11: error: redefinition of 'meta' as different kind of symbol
namespace meta {
           ^
<SDK>/usr/include/ncurses.h:603:28: note: previous definition is here
extern NCURSES_EXPORT(int) meta (WINDOW *,bool);                        /* implemented */
                            ^

[ldionne]

I don't have a strong preference for the new name of the namespace.

[Mordante]

Mainly curios, but how do curses get pulled into our tests?

I don't have a strong opinion regarding the name, maybe @philnik has. LGTM.

[philnik]

We could rename it to types or something similar. It would actually also make sense to put stuff like MoveOnly, input_iterator etc. inside there. Then we'd have types::for_each(types::integral_types{}, ...). WDYT?

Could we maybe get a modules build on macOS, since it seems there are some pretty horrible things inside the system headers? Who thought it would be a good idea to reserve Point? I think Android has a few horrific things in the system headers too, but there we don't have any CI currently.

[ldionne]

In D144915#4159110, @Mordante wrote:

Mainly curios, but how do curses get pulled into our tests?

I think this is via Apple's SDK, which seem to provide ncurses. This is arguably not very clean.

In D144915#4159182, @philnik wrote:

We could rename it to types or something similar. It would actually also make sense to put stuff like MoveOnly, input_iterator etc. inside there. Then we'd have types::for_each(types::integral_types{}, ...). WDYT?

Yeah, I've been wanting a namespace to put our test support utilities. Let's use types:: for now, however I think support:: could also be a good candidate if we want to generalize this to also contain functions and so on.

Could we maybe get a modules build on macOS, since it seems there are some pretty horrible things inside the system headers? Who thought it would be a good idea to reserve Point? I think Android has a few horrific things in the system headers too, but there we don't have any CI currently.

That's a good idea, adding one.

[ldionne]

Use types:: instead of TestMeta, and add CI bot.

[philnik]

Thanks! LGTM with green CI.

[Mordante]

In D144915#4159876, @ldionne wrote:

In D144915#4159110, @Mordante wrote:

Mainly curios, but how do curses get pulled into our tests?

I think this is via Apple's SDK, which seem to provide ncurses. This is arguably not very clean.

Interesting.

Could we maybe get a modules build on macOS, since it seems there are some pretty horrible things inside the system headers? Who thought it would be a good idea to reserve Point? I think Android has a few horrific things in the system headers too, but there we don't have any CI currently.

That's a good idea, adding one.

I really like this, thanks.

libcxx/test/libcxx/type_traits/is_always_bitcastable.compile.pass.cpp

constexpr void check_with_cv() {
   check_with_volatile<Expected, T, U>();
   check_with_volatile<Expected, const T, U>();
   check_with_volatile<Expected, T, const U>();
   check_with_volatile<Expected, const T, const U>();
 }
 
 template <bool Expected, class Types1, class Types2 = Types1>
 constexpr void check() {
-  meta::for_each(Types1{}, []<class T>() {
-    meta::for_each(Types2{}, []<class U>() {
+  TestMeta::for_each(Types1{}, []<class T>() {
+    TestMeta::for_each(Types2{}, []<class U>() {
       check_with_cv<Expected, T, U>();
     });
   });
 }
 
 template <bool Expected, class Types1, class Types2>
 constexpr void check_both_ways() {
   check<Expected, Types1, Types2>();
   check<Expected, Types2, Types1>();
 }
 
 constexpr void test() {
   // Arithmetic types.
   {
     // Bit-castable arithmetic types.
 
     // 8-bit types.
-    using integral_8 = meta::type_list<char8_t, int8_t, uint8_t>;
-    using chars = meta::type_list<char, unsigned char, signed char>;
+    using integral_8 = TestMeta::type_list<char8_t, int8_t, uint8_t>;
+    using chars = TestMeta::type_list<char, unsigned char, signed char>;
 #if CHAR_BIT == 8
-    check<true, meta::concatenate_t<integral_8, chars>>();
+    check<true, TestMeta::concatenate_t<integral_8, chars>>();
 #else
     check<true, integral_8>();
     check<true, chars>();
 #endif
 
     // 16-bit types.
-    using integral_16 = meta::type_list<char16_t, int16_t, uint16_t>;
+    using integral_16 = TestMeta::type_list<char16_t, int16_t, uint16_t>;
 #if !defined(TEST_HAS_NO_WIDE_CHARACTERS) && __WCHAR_WIDTH__ == 16
-    check<true, meta::concatenate_t<integral_16, meta::type_list<wchar_t>>>();
+    check<true, TestMeta::concatenate_t<integral_16, TestMeta::type_list<wchar_t>>>();
 #else
     check<true, integral_16>();
 #endif
 
     // 32-bit types.
-    using integral_32 = meta::type_list<char32_t, int32_t, uint32_t>;
+    using integral_32 = TestMeta::type_list<char32_t, int32_t, uint32_t>;
 #if !defined(TEST_HAS_NO_WIDE_CHARACTERS) && __WCHAR_WIDTH__ == 32
-    check<true, meta::concatenate_t<integral_32, meta::type_list<wchar_t>>>();
+    check<true, TestMeta::concatenate_t<integral_32, TestMeta::type_list<wchar_t>>>();
 #else
     check<true, integral_32>();
 #endif
 
     // 64-bit types.
-    using integral_64 = meta::type_list<int64_t, uint64_t>;
+    using integral_64 = TestMeta::type_list<int64_t, uint64_t>;
     check<true, integral_64>();
 
     // 128-bit types.
 #ifndef TEST_HAS_NO_INT128
-    check<true, meta::type_list<__int128_t, __uint128_t>>();
+    check<true, TestMeta::type_list<__int128_t, __uint128_t>>();
 #endif
 
     // Bool.
-    check<true, meta::type_list<bool>, meta::concatenate_t<meta::type_list<bool>, integral_8>>();
+    check<true, TestMeta::type_list<bool>, TestMeta::concatenate_t<TestMeta::type_list<bool>, integral_8>>();
 
     // Non-bit-castable arithmetic types.
 
     // Floating-point.
-    check_both_ways<false, meta::floating_point_types, meta::integral_types>();
-    check_both_ways<false, meta::type_list<float>, meta::type_list<double, long double>>();
-    check_both_ways<false, meta::type_list<double>, meta::type_list<float, long double>>();
-    check_both_ways<false, meta::type_list<long double>, meta::type_list<float, double>>();
+    check_both_ways<false, TestMeta::floating_point_types, TestMeta::integral_types>();
+    check_both_ways<false, TestMeta::type_list<float>, TestMeta::type_list<double, long double>>();
+    check_both_ways<false, TestMeta::type_list<double>, TestMeta::type_list<float, long double>>();
+    check_both_ways<false, TestMeta::type_list<long double>, TestMeta::type_list<float, double>>();
 
     // Different sizes.
-    check_both_ways<false, integral_8, meta::concatenate_t<integral_16, integral_32, integral_64>>();
-    check_both_ways<false, integral_16, meta::concatenate_t<integral_8, integral_32, integral_64>>();
-    check_both_ways<false, integral_32, meta::concatenate_t<integral_8, integral_16, integral_64>>();
-    check_both_ways<false, integral_64, meta::concatenate_t<integral_8, integral_16, integral_32>>();
+    check_both_ways<false, integral_8, TestMeta::concatenate_t<integral_16, integral_32, integral_64>>();
+    check_both_ways<false, integral_16, TestMeta::concatenate_t<integral_8, integral_32, integral_64>>();
+    check_both_ways<false, integral_32, TestMeta::concatenate_t<integral_8, integral_16, integral_64>>();
+    check_both_ways<false, integral_64, TestMeta::concatenate_t<integral_8, integral_16, integral_32>>();
 
     // Different representations -- can convert from bool to other integral types, but not vice versa.
-    check<true, meta::type_list<bool>, integral_8>();
-    using larger_than_bool = meta::concatenate_t<
+    check<true, TestMeta::type_list<bool>, integral_8>();
+    using larger_than_bool = TestMeta::concatenate_t<
       integral_16,
       integral_32,
       integral_64,
-      meta::floating_point_types>;
-    check<false, meta::type_list<bool>, larger_than_bool>();
-    check<false, meta::concatenate_t<integral_8, larger_than_bool>, meta::type_list<bool>>();
+      TestMeta::floating_point_types>;
+    check<false, TestMeta::type_list<bool>, larger_than_bool>();
+    check<false, TestMeta::concatenate_t<integral_8, larger_than_bool>, TestMeta::type_list<bool>>();
 
     // Different representations -- floating point vs. integral.
-    check_both_ways<false, meta::floating_point_types, meta::integral_types>();
+    check_both_ways<false, TestMeta::floating_point_types, TestMeta::integral_types>();
   }
 
   // Enumerations.
   {
     enum E1 { Value1 };
     enum E2 { Value2 };
-    check<true, meta::type_list<E1>>();
-    check_both_ways<false, meta::type_list<E1>, meta::type_list<E2>>();
+    check<true, TestMeta::type_list<E1>>();
+    check_both_ways<false, TestMeta::type_list<E1>, TestMeta::type_list<E2>>();
 
     enum class ScopedE1 { Value1 };
     enum class ScopedE2 { Value1 };
-    check<true, meta::type_list<ScopedE1>>();
-    check_both_ways<false, meta::type_list<ScopedE1>, meta::type_list<ScopedE2>>();
+    check<true, TestMeta::type_list<ScopedE1>>();
+    check_both_ways<false, TestMeta::type_list<ScopedE1>, TestMeta::type_list<ScopedE2>>();
   }
 
   // Pointers.
   {
-    check<true, meta::type_list<int*>>();
-    check_both_ways<false, meta::type_list<int*>, meta::type_list<const int*, long*, void*>>();
+    check<true, TestMeta::type_list<int*>>();
+    check_both_ways<false, TestMeta::type_list<int*>, TestMeta::type_list<const int*, long*, void*>>();
 
-    check<true, meta::type_list<FuncPtr1>>();
-    check_both_ways<false, meta::type_list<FuncPtr1>, meta::type_list<FuncPtr2>>();
+    check<true, TestMeta::type_list<FuncPtr1>>();
+    check_both_ways<false, TestMeta::type_list<FuncPtr1>, TestMeta::type_list<FuncPtr2>>();
   }
 
   // Pointers to members.
   {
     struct S {
       int mem_obj1 = 0;
       long mem_obj2 = 0;
       void MemFunc1() {}
       int MemFunc2() { return 0; }
     };
     using MemObjPtr1 = decltype(&S::mem_obj1);
     using MemObjPtr2 = decltype(&S::mem_obj2);
     using MemFuncPtr1 = decltype(&S::MemFunc1);
     using MemFuncPtr2 = decltype(&S::MemFunc2);
 
-    check<true, meta::type_list<MemObjPtr1>>();
-    check<true, meta::type_list<MemFuncPtr1>>();
-    check_both_ways<false, meta::type_list<MemObjPtr1>, meta::type_list<MemObjPtr2>>();
-    check_both_ways<false, meta::type_list<MemFuncPtr1>, meta::type_list<MemFuncPtr2>>();
+    check<true, TestMeta::type_list<MemObjPtr1>>();
+    check<true, TestMeta::type_list<MemFuncPtr1>>();
+    check_both_ways<false, TestMeta::type_list<MemObjPtr1>, TestMeta::type_list<MemObjPtr2>>();
+    check_both_ways<false, TestMeta::type_list<MemFuncPtr1>, TestMeta::type_list<MemFuncPtr2>>();
   }
 
   // Trivial classes.
   {
     struct S1 {};
-    check<true, meta::type_list<S1>>();
+    check<true, TestMeta::type_list<S1>>();
 
     struct S2 {};
-    check_both_ways<false, meta::type_list<S1>, meta::type_list<S2>>();
+    check_both_ways<false, TestMeta::type_list<S1>, TestMeta::type_list<S2>>();
 
     // Having a `volatile` member doesn't prevent a class type from being considered trivially copyable. This is
     // unfortunate behavior but it is consistent with the Standard.
     struct VolatileMembersS {
       volatile int x;
     };
-    check<true, meta::type_list<VolatileMembersS>>();
+    check<true, TestMeta::type_list<VolatileMembersS>>();
   }
 
   // Trivial unions.
   {
     union U1 {};
-    check<true, meta::type_list<U1>>();
+    check<true, TestMeta::type_list<U1>>();
 
     union U2 {};
-    check_both_ways<false, meta::type_list<U1>, meta::type_list<U2>>();
+    check_both_ways<false, TestMeta::type_list<U1>, TestMeta::type_list<U2>>();
 
     union VolatileMembersU {
       volatile int x;
     };
-    check<true, meta::type_list<VolatileMembersU>>();
+    check<true, TestMeta::type_list<VolatileMembersU>>();
   }
 
   // References are not objects, and thus are not bit-castable.
   {
-    check_both_ways<false, meta::type_list<int&>, meta::type_list<int&>>();
+    check_both_ways<false, TestMeta::type_list<int&>, TestMeta::type_list<int&>>();
   }
 
   // Arrays.
   {
-    check<true, meta::type_list<int[8]>>();
+    check<true, TestMeta::type_list<int[8]>>();
   }
 }

libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/ranges.copy.pass.cpp

constexpr void test_iterators() {
       assert(base(ret.in) == in.data());
       assert(base(ret.out) == out.data());
     }
   }
 }
 // clang-format on
 
 constexpr bool test() {
-  meta::for_each(meta::forward_iterator_list<int*>{}, []<class Out>() {
+  TestMeta::for_each(TestMeta::forward_iterator_list<int*>{}, []<class Out>() {
     test_iterators<cpp20_input_iterator<int*>, Out, sentinel_wrapper<cpp20_input_iterator<int*>>>();
     test_iterators<ProxyIterator<cpp20_input_iterator<int*>>,
                    ProxyIterator<Out>,
                    sentinel_wrapper<ProxyIterator<cpp20_input_iterator<int*>>>>();
 
-    meta::for_each(meta::forward_iterator_list<int*>{}, []<class In>() {
+    TestMeta::for_each(TestMeta::forward_iterator_list<int*>{}, []<class In>() {
       test_iterators<In, Out>();
       test_iterators<In, Out, sized_sentinel<In>>();
       test_iterators<In, Out, sentinel_wrapper<In>>();
 
       test_iterators<ProxyIterator<In>, ProxyIterator<Out>>();
       test_iterators<ProxyIterator<In>, ProxyIterator<Out>, sized_sentinel<ProxyIterator<In>>>();
       test_iterators<ProxyIterator<In>, ProxyIterator<Out>, sentinel_wrapper<ProxyIterator<In>>>();
     });

libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/ranges.copy.segmented.pass.cpp

 int main(int, char**) {
   if (!std::is_constant_evaluated()) {
     test_containers<std::deque<int>, std::deque<int>>();
     test_containers<std::deque<int>, std::vector<int>>();
     test_containers<std::vector<int>, std::deque<int>>();
     test_containers<std::vector<int>, std::vector<int>>();
   }
 
-  meta::for_each(meta::forward_iterator_list<int*>{}, []<class Iter> {
+  TestMeta::for_each(TestMeta::forward_iterator_list<int*>{}, []<class Iter> {
     test_join_view<Iter, Iter>();
     test_join_view<Iter, sentinel_wrapper<Iter>>();
     test_join_view<Iter, sized_sentinel<Iter>>();
   });
 
   return 0;
 }

libcxx/test/std/algorithms/alg.nonmodifying/alg.equal/equal.pass.cpp

 #endif
   }
 };
 
 template <class UnderlyingType, class TypeList>
 struct TestIter2 {
   template <class Iter1>
   TEST_CONSTEXPR_CXX20 void operator()() {
-    meta::for_each(TypeList(), Test<UnderlyingType, Iter1>());
+    TestMeta::for_each(TypeList(), Test<UnderlyingType, Iter1>());
   }
 };
 
 struct AddressCompare {
   int i = 0;
   TEST_CONSTEXPR_CXX20 AddressCompare(int) {}
 
   operator char() { return static_cast<char>(i); }
 
   friend TEST_CONSTEXPR_CXX20 bool operator==(const AddressCompare& lhs, const AddressCompare& rhs) {
     return &lhs == &rhs;
   }
 
   friend TEST_CONSTEXPR_CXX20 bool operator!=(const AddressCompare& lhs, const AddressCompare& rhs) {
     return &lhs != &rhs;
   }
 };
 
 TEST_CONSTEXPR_CXX20 bool test() {
-  meta::for_each(meta::cpp17_input_iterator_list<int*>(), TestIter2<int, meta::cpp17_input_iterator_list<int*> >());
-  meta::for_each(meta::cpp17_input_iterator_list<char*>(), TestIter2<char, meta::cpp17_input_iterator_list<char*> >());
-  meta::for_each(meta::cpp17_input_iterator_list<AddressCompare*>(),
-                 TestIter2<AddressCompare, meta::cpp17_input_iterator_list<AddressCompare*> >());
+  TestMeta::for_each(TestMeta::cpp17_input_iterator_list<int*>(), TestIter2<int, TestMeta::cpp17_input_iterator_list<int*> >());
+  TestMeta::for_each(TestMeta::cpp17_input_iterator_list<char*>(), TestIter2<char, TestMeta::cpp17_input_iterator_list<char*> >());
+  TestMeta::for_each(TestMeta::cpp17_input_iterator_list<AddressCompare*>(),
+                 TestIter2<AddressCompare, TestMeta::cpp17_input_iterator_list<AddressCompare*> >());
 
-  meta::for_each(meta::integral_types(), TestNarrowingEqualTo());
+  TestMeta::for_each(TestMeta::integral_types(), TestNarrowingEqualTo());
 
   return true;
 }
 
 struct Base {};
 struct Derived : virtual Base {};
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER >= 20
   static_assert(test());
 #endif
 
-  meta::for_each(meta::as_pointers<meta::cv_qualified_versions<int> >(),
-                 TestIter2<int, meta::as_pointers<meta::cv_qualified_versions<int> > >());
-  meta::for_each(meta::as_pointers<meta::cv_qualified_versions<char> >(),
-                 TestIter2<char, meta::as_pointers<meta::cv_qualified_versions<char> > >());
+  TestMeta::for_each(TestMeta::as_pointers<TestMeta::cv_qualified_versions<int> >(),
+                 TestIter2<int, TestMeta::as_pointers<TestMeta::cv_qualified_versions<int> > >());
+  TestMeta::for_each(TestMeta::as_pointers<TestMeta::cv_qualified_versions<char> >(),
+                 TestIter2<char, TestMeta::as_pointers<TestMeta::cv_qualified_versions<char> > >());
 
   {
     Derived d;
     Derived* a[] = {&d, nullptr};
     Base* b[]    = {&d, nullptr};
 
     assert(std::equal(a, a + 2, b));
 #if TEST_STD_VER >= 14
     assert(std::equal(a, a + 2, b, b + 2));
 #endif
   }
 
   return 0;
 }

libcxx/test/std/depr/depr.c.headers/math_h.pass.cpp

struct test_three_args {
   template <class T = Arg1, class U = Arg2, class V = Arg3>
   void operator()() {
     static_assert((std::is_same<decltype(::fma(T(), U(), V())), PromoteResult>::value), "");
     (void)::fma(T(), U(), V());
   }
 };
 
 struct CallTwoArgs {
-  using integral_float_double = meta::concatenate_t<meta::integral_types, meta::type_list<float, double> >;
+  using integral_float_double = TestMeta::concatenate_t<TestMeta::integral_types, TestMeta::type_list<float, double> >;
 
   template <class Arg2>
   void operator()() {
-    meta::for_each(integral_float_double(), test_two_args</*PromoteResult=*/double, /*Iterate*/void, Arg2>());
+    TestMeta::for_each(integral_float_double(), test_two_args</*PromoteResult=*/double, /*Iterate*/void, Arg2>());
   }
 };
 
 template <class T>
 struct CallThreeArgs {
-  using integral_float_double = meta::concatenate_t<meta::integral_types, meta::type_list<float, double> >;
+  using integral_float_double = TestMeta::concatenate_t<TestMeta::integral_types, TestMeta::type_list<float, double> >;
 
   template <class Arg3>
   struct Helper {
 
     template <class Arg2>
     void operator()() {
-      meta::for_each(integral_float_double(), test_three_args</*PromoteResult=*/double, /*Iterate*/void, Arg2, Arg3>());
+      TestMeta::for_each(integral_float_double(), test_three_args</*PromoteResult=*/double, /*Iterate*/void, Arg2, Arg3>());
     }
   };
 
   template <class Arg3>
   void operator()() {
-    meta::for_each(integral_float_double(), Helper<Arg3>());
+    TestMeta::for_each(integral_float_double(), Helper<Arg3>());
   }
 };
 
 int main(int, char**)
 {
-  meta::for_each(meta::integral_types(), test_single_arg</*PromoteResult=*/double>());
+  TestMeta::for_each(TestMeta::integral_types(), test_single_arg</*PromoteResult=*/double>());
   test_single_arg</*PromoteResult=*/float, /*Arg=*/float>();
   test_single_arg</*PromoteResult=*/double, /*Arg=*/double>();
   test_single_arg</*PromoteResult=*/long double, /*Arg=*/long double>();
 
-  meta::for_each(meta::integral_types(), CallTwoArgs());
+  TestMeta::for_each(TestMeta::integral_types(), CallTwoArgs());
 
-  meta::for_each(
-      meta::integral_types(), test_two_args</*PromoteResult=*/long double, /*Arg1=*/void, /*Arg2=*/long double>());
+  TestMeta::for_each(
+      TestMeta::integral_types(), test_two_args</*PromoteResult=*/long double, /*Arg1=*/void, /*Arg2=*/long double>());
 
   test_two_args</*PromoteResult=*/float, /*Args=*/float, float>();
   test_two_args</*PromoteResult=*/float, /*Args=*/double, double>();
   test_two_args</*PromoteResult=*/double, /*Args=*/float, double>();
   test_two_args</*PromoteResult=*/double, /*Args=*/double, double>();
 
-  meta::for_each(meta::integral_types(), CallThreeArgs<double>());
-  meta::for_each(
-      meta::integral_types(), test_three_args</*PromoteResult=*/long double, /*Iterate*/ void, long double, double>());
+  TestMeta::for_each(TestMeta::integral_types(), CallThreeArgs<double>());
+  TestMeta::for_each(
+      TestMeta::integral_types(), test_three_args</*PromoteResult=*/long double, /*Iterate*/ void, long double, double>());
 
   test_three_args</*PromoteResult=*/float, /*Args=*/float, float, float>();
   test_three_args</*PromoteResult=*/double, /*Args=*/double, double, double>();
   test_three_args</*PromoteResult=*/long double, /*Args=*/long double, long double, long double>();
 
   test_abs();
   test_acos();
   test_asin();

libcxx/test/std/language.support/support.limits/limits/is_specialized.pass.cpp

static_assert(std::numeric_limits<volatile T>::is_specialized,
                  "std::numeric_limits<volatile T>::is_specialized");
     static_assert(std::numeric_limits<const volatile T>::is_specialized,
                  "std::numeric_limits<const volatile T>::is_specialized");
   }
 };
 
 int main(int, char**)
 {
-  meta::for_each(meta::arithmetic_types(), Test());
+  TestMeta::for_each(TestMeta::arithmetic_types(), Test());
 
   static_assert(!std::numeric_limits<std::complex<double> >::is_specialized,
                 "!std::numeric_limits<std::complex<double> >::is_specialized");
 
   return 0;
 }

libcxx/test/std/numerics/c.math/isfinite.pass.cpp

TEST_CONSTEXPR_CXX23 void operator()() {
     test<T>();
 #if TEST_STD_VER >= 23
     static_assert(test<T>());
 #endif
   }
 };
 
 int main(int, char**) {
-  meta::for_each(meta::floating_point_types(), TestFloat());
-  meta::for_each(meta::integral_types(), TestInt());
+  TestMeta::for_each(TestMeta::floating_point_types(), TestFloat());
+  TestMeta::for_each(TestMeta::integral_types(), TestInt());
 
   return 0;
 }

libcxx/test/std/numerics/c.math/isinf.pass.cpp

TEST_CONSTEXPR_CXX23 void operator()() {
     test<T>();
 #if TEST_STD_VER >= 23
     static_assert(test<T>());
 #endif
   }
 };
 
 int main(int, char**) {
-  meta::for_each(meta::floating_point_types(), TestFloat());
-  meta::for_each(meta::integral_types(), TestInt());
+  TestMeta::for_each(TestMeta::floating_point_types(), TestFloat());
+  TestMeta::for_each(TestMeta::integral_types(), TestInt());
 
   return 0;
 }

libcxx/test/std/numerics/c.math/isnan.pass.cpp

TEST_CONSTEXPR_CXX23 void operator()() {
     test<T>();
 #if TEST_STD_VER >= 23
     static_assert(test<T>());
 #endif
   }
 };
 
 int main(int, char**) {
-  meta::for_each(meta::floating_point_types(), TestFloat());
-  meta::for_each(meta::integral_types(), TestInt());
+  TestMeta::for_each(TestMeta::floating_point_types(), TestFloat());
+  TestMeta::for_each(TestMeta::integral_types(), TestInt());
 
   return 0;
 }

libcxx/test/std/numerics/c.math/isnormal.pass.cpp

TEST_CONSTEXPR_CXX23 void operator()() {
     test<T>();
 #if TEST_STD_VER >= 23
     static_assert(test<T>());
 #endif
   }
 };
 
 int main(int, char**) {
-  meta::for_each(meta::floating_point_types(), TestFloat());
-  meta::for_each(meta::integral_types(), TestInt());
+  TestMeta::for_each(TestMeta::floating_point_types(), TestFloat());
+  TestMeta::for_each(TestMeta::integral_types(), TestInt());
 
   return 0;
 }

libcxx/test/std/ranges/range.adaptors/range.as.rvalue/begin.pass.cpp

 }
 
 struct move_iterator_view : std::ranges::view_base {
   constexpr std::move_iterator<int*> begin() const { return {}; }
   constexpr std::move_iterator<int*> end() const { return {}; }
 };
 
 constexpr bool test() {
-  meta::for_each(meta::cpp20_input_iterator_list<int*>{}, []<class Iter> {
+  TestMeta::for_each(TestMeta::cpp20_input_iterator_list<int*>{}, []<class Iter> {
     if constexpr (std::sentinel_for<Iter, Iter>)
       test_range<Iter, Iter>();
     test_range<Iter, sentinel_wrapper<Iter>>();
     test_range<Iter, sized_sentinel<Iter>>();
   });
 
-  meta::for_each(meta::forward_iterator_list<const int*>{}, []<class Iter> {
+  TestMeta::for_each(TestMeta::forward_iterator_list<const int*>{}, []<class Iter> {
     test_const_range<Iter, Iter>();
     test_const_range<Iter, sentinel_wrapper<Iter>>();
     test_const_range<Iter, sized_sentinel<Iter>>();
   });
 
   { // check that with a std::move_iterator begin() doesn't return move_iterator<move_iterator<T>>
     std::ranges::as_rvalue_view view{move_iterator_view{}};
     std::same_as<std::move_iterator<int*>> decltype(auto) it = view.begin();

libcxx/test/std/ranges/range.adaptors/range.as.rvalue/end.pass.cpp

 };
 
 constexpr bool test() {
   test_range<cpp17_input_iterator<int*>, sentinel_wrapper<cpp17_input_iterator<int*>>, false>();
   test_range<cpp17_input_iterator<int*>, sized_sentinel<cpp17_input_iterator<int*>>, false>();
   test_range<cpp20_input_iterator<int*>, sentinel_wrapper<cpp20_input_iterator<int*>>, false>();
   test_range<cpp20_input_iterator<int*>, sized_sentinel<cpp20_input_iterator<int*>>, false>();
 
-  meta::for_each(meta::forward_iterator_list<int*>{}, []<class Iter> {
+  TestMeta::for_each(TestMeta::forward_iterator_list<int*>{}, []<class Iter> {
     test_range<Iter, Iter, true>();
     test_range<Iter, sentinel_wrapper<Iter>, false>();
     test_range<Iter, sized_sentinel<Iter>, false>();
   });
 
   {
     std::ranges::as_rvalue_view view(CVCallView{});
     (void)view.end();

libcxx/test/std/ranges/range.adaptors/range.filter/iterator/arrow.pass.cpp

 #include <cassert>
 #include <concepts>
 #include <cstddef>
 #include <utility>
 #include "test_iterators.h"
 #include "test_macros.h"
 #include "../types.h"
 
-struct Point {
+struct XYPoint {
   int x;
   int y;
 };
 
 template <class T>
 concept has_arrow = requires (T t) {
   { t->x };
 };
-static_assert(has_arrow<Point*>); // test the test
+static_assert(has_arrow<XYPoint*>); // test the test
 
 struct WithArrowOperator {
   using iterator_category = std::input_iterator_tag;
   using difference_type = std::ptrdiff_t;
-  using value_type = Point;
+  using value_type = XYPoint;
 
-  constexpr explicit WithArrowOperator(Point* p) : p_(p) { }
-  constexpr Point& operator*() const { return *p_; }
-  constexpr Point* operator->() const { return p_; } // has arrow
+  constexpr explicit WithArrowOperator(XYPoint* p) : p_(p) { }
+  constexpr XYPoint& operator*() const { return *p_; }
+  constexpr XYPoint* operator->() const { return p_; } // has arrow
   constexpr WithArrowOperator& operator++() { ++p_; return *this; }
   constexpr WithArrowOperator operator++(int) { return WithArrowOperator(p_++); }
 
-  friend constexpr Point* base(WithArrowOperator const& i) { return i.p_; }
-  Point* p_;
+  friend constexpr XYPoint* base(WithArrowOperator const& i) { return i.p_; }
+  XYPoint* p_;
 };
 static_assert(std::input_iterator<WithArrowOperator>);
 
 struct WithNonCopyableIterator : std::ranges::view_base {
   struct iterator {
     using iterator_category = std::input_iterator_tag;
     using difference_type = std::ptrdiff_t;
-    using value_type = Point;
+    using value_type = XYPoint;
 
     iterator(iterator const&) = delete; // not copyable
     iterator(iterator&&);
     iterator& operator=(iterator&&);
-    Point& operator*() const;
+    XYPoint& operator*() const;
     iterator operator->() const;
     iterator& operator++();
     iterator operator++(int);
 
-    // We need this to use Point* as a sentinel type below. sentinel_wrapper
+    // We need this to use XYPoint* as a sentinel type below. sentinel_wrapper
     // can't be used because this iterator is not copyable.
-    friend bool operator==(iterator const&, Point*);
+    friend bool operator==(iterator const&, XYPoint*);
   };
 
   iterator begin() const;
-  Point* end() const;
+  XYPoint* end() const;
 };
 static_assert(std::ranges::input_range<WithNonCopyableIterator>);
 
 template <class Iterator, class Sentinel = sentinel_wrapper<Iterator>>
 constexpr void test() {
-  std::array<Point, 5> array{{{0, 0}, {1, 1}, {2, 2}, {3, 3}, {4, 4}}};
+  std::array<XYPoint, 5> array{{{0, 0}, {1, 1}, {2, 2}, {3, 3}, {4, 4}}};
   using View = minimal_view<Iterator, Sentinel>;
   using FilterView = std::ranges::filter_view<View, AlwaysTrue>;
   using FilterIterator = std::ranges::iterator_t<FilterView>;
 
   auto make_filter_view = [](auto begin, auto end, auto pred) {
     View view{Iterator(begin), Sentinel(Iterator(end))};
     return FilterView(std::move(view), pred);
   };
 
   for (std::ptrdiff_t n = 0; n != 5; ++n) {
     FilterView view = make_filter_view(array.begin(), array.end(), AlwaysTrue{});
     FilterIterator const iter(view, Iterator(array.begin() + n));
     std::same_as<Iterator> decltype(auto) result = iter.operator->();
     assert(base(result) == array.begin() + n);
     assert(iter->x == n);
     assert(iter->y == n);
   }
 }
 
 constexpr bool tests() {
   test<WithArrowOperator>();
-  test<Point*>();
-  test<Point const*>();
-  test<contiguous_iterator<Point*>>();
-  test<contiguous_iterator<Point const*>>();
+  test<XYPoint*>();
+  test<XYPoint const*>();
+  test<contiguous_iterator<XYPoint*>>();
+  test<contiguous_iterator<XYPoint const*>>();
 
   // Make sure filter_view::iterator doesn't have operator-> if the
   // underlying iterator doesn't have one.
   {
     auto check_no_arrow = []<class It> {
       using View = minimal_view<It, sentinel_wrapper<It>>;
       using FilterView = std::ranges::filter_view<View, AlwaysTrue>;
       using FilterIterator = std::ranges::iterator_t<FilterView>;
       static_assert(!has_arrow<FilterIterator>);
     };
-    check_no_arrow.operator()<cpp17_input_iterator<Point*>>();
-    check_no_arrow.operator()<cpp20_input_iterator<Point*>>();
-    check_no_arrow.operator()<forward_iterator<Point*>>();
-    check_no_arrow.operator()<bidirectional_iterator<Point*>>();
-    check_no_arrow.operator()<random_access_iterator<Point*>>();
+    check_no_arrow.operator()<cpp17_input_iterator<XYPoint*>>();
+    check_no_arrow.operator()<cpp20_input_iterator<XYPoint*>>();
+    check_no_arrow.operator()<forward_iterator<XYPoint*>>();
+    check_no_arrow.operator()<bidirectional_iterator<XYPoint*>>();
+    check_no_arrow.operator()<random_access_iterator<XYPoint*>>();
     check_no_arrow.operator()<int*>();
   }
 
   // Make sure filter_view::iterator doesn't have operator-> if the
   // underlying iterator is not copyable.
   {
     using FilterView = std::ranges::filter_view<WithNonCopyableIterator, AlwaysTrue>;
     using FilterIterator = std::ranges::iterator_t<FilterView>;

libcxx/test/std/strings/basic.string/string.access/at.pass.cpp

TEST_CONSTEXPR_CXX20 void operator()() {
         test_string<std::basic_string<T> >();
 #if TEST_STD_VER >= 11
         test_string<std::basic_string<T, std::char_traits<T>, min_allocator<T> > >();
 #endif
   }
 };
 
 TEST_CONSTEXPR_CXX20 bool test() {
-  meta::for_each(meta::character_types(), TestCaller());
+  TestMeta::for_each(TestMeta::character_types(), TestCaller());
 
   return true;
 }
 
 int main(int, char**)
 {
   test();
 #if TEST_STD_VER > 17
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/support/test.support/type_algorithms.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
 //
 //===----------------------------------------------------------------------===//
 
 #include <algorithm>
 #include <cassert>
 #include <type_traits>
 
 #include "test_macros.h"
 #include "type_algorithms.h"
 
 // concatenate
-static_assert(std::is_same<meta::concatenate_t<meta::type_list<> >, meta::type_list<> >::value, "");
-static_assert(std::is_same<meta::concatenate_t<meta::type_list<int> >, meta::type_list<int> >::value, "");
+static_assert(std::is_same<TestMeta::concatenate_t<TestMeta::type_list<> >, TestMeta::type_list<> >::value, "");
+static_assert(std::is_same<TestMeta::concatenate_t<TestMeta::type_list<int> >, TestMeta::type_list<int> >::value, "");
 static_assert(
-    std::is_same<meta::concatenate_t<meta::type_list<int>, meta::type_list<long> >, meta::type_list<int, long> >::value,
+    std::is_same<TestMeta::concatenate_t<TestMeta::type_list<int>, TestMeta::type_list<long> >, TestMeta::type_list<int, long> >::value,
     "");
 static_assert(
-    std::is_same<meta::concatenate_t<meta::type_list<int>, meta::type_list<long>, meta::type_list<long long> >,
-                 meta::type_list<int, long, long long> >::value,
+    std::is_same<TestMeta::concatenate_t<TestMeta::type_list<int>, TestMeta::type_list<long>, TestMeta::type_list<long long> >,
+                 TestMeta::type_list<int, long, long long> >::value,
     "");
 
 // apply_all
 template <int N>
 class NumT {};
 
 struct ApplyAllTest {
   bool* is_called_array_;

 };
 
 struct Identity {
   TEST_CONSTEXPR bool operator()(bool b) const { return b; }
 };
 
 TEST_CONSTEXPR_CXX20 void test_for_each() {
   bool is_called_array[3] = {};
-  meta::for_each(meta::type_list<NumT<0>, NumT<1>, NumT<2> >(), ApplyAllTest(is_called_array));
+  TestMeta::for_each(TestMeta::type_list<NumT<0>, NumT<1>, NumT<2> >(), ApplyAllTest(is_called_array));
   assert(std::all_of(is_called_array, is_called_array + 3, Identity()));
 }
 
 TEST_CONSTEXPR_CXX20 bool test() {
   test_for_each();
   return true;
 }
 
 int main(int, char**) {
   test();
 #if TEST_STD_VER >= 20
   static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/support/test_iterators.h

 };
 
 template <std::ranges::input_range R>
   requires std::ranges::viewable_range<R&&>
 ProxyRange(R&&) -> ProxyRange<std::views::all_t<R&&>>;
 
 #endif // TEST_STD_VER > 17
 
-namespace meta {
+namespace TestMeta {
 template <class Ptr>
 using random_access_iterator_list =
     type_list<Ptr,
 #if TEST_STD_VER >= 20
               contiguous_iterator<Ptr>,
 #endif
               random_access_iterator<Ptr> >;
 
 template <class Ptr>
 using bidirectional_iterator_list =
     concatenate_t<random_access_iterator_list<Ptr>, type_list<bidirectional_iterator<Ptr> > >;
 
 template <class Ptr>
 using forward_iterator_list = concatenate_t<bidirectional_iterator_list<Ptr>, type_list<forward_iterator<Ptr> > >;
 
 template <class Ptr>
 using cpp17_input_iterator_list = concatenate_t<forward_iterator_list<Ptr>, type_list<cpp17_input_iterator<Ptr> > >;
 
 #if TEST_STD_VER >= 20
 template <class Ptr>
 using cpp20_input_iterator_list =
     concatenate_t<forward_iterator_list<Ptr>, type_list<cpp20_input_iterator<Ptr>, cpp17_input_iterator<Ptr>>>;
 #endif
-} // namespace meta
+} // namespace TestMeta
 
 
 #endif // SUPPORT_TEST_ITERATORS_H

libcxx/test/support/type_algorithms.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 TEST_SUPPORT_TYPE_ALGORITHMS_H
 #define TEST_SUPPORT_TYPE_ALGORITHMS_H
 
 #include <type_traits>
 
 #include "test_macros.h"
 
-namespace meta {
+namespace TestMeta {
 template <class... Types>
 struct type_list {};
 
 // concatenates N type_lists to one (for N >= 1)
 template <class...>
 struct concatenate;
 
 template <class... Types>

 
 template <class... Types>
 struct type_list_as_pointers<type_list<Types...> > {
   using type = type_list<Types*...>;
 };
 
 template <class T>
 using as_pointers = typename type_list_as_pointers<T>::type;
-} // namespace meta
+} // namespace TestMeta
 
 #endif // TEST_SUPPORT_TYPE_ALGORITHMS_H