diff --git a/libcxx/test/libcxx/type_traits/is_always_bitcastable.compile.pass.cpp b/libcxx/test/libcxx/type_traits/is_always_bitcastable.compile.pass.cpp
--- a/libcxx/test/libcxx/type_traits/is_always_bitcastable.compile.pass.cpp
+++ b/libcxx/test/libcxx/type_traits/is_always_bitcastable.compile.pass.cpp
@@ -52,8 +52,8 @@
 
 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>();
     });
   });
@@ -71,91 +71,91 @@
     // 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.
@@ -171,49 +171,49 @@
     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]>>();
   }
 }
diff --git a/libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/ranges.copy.pass.cpp b/libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/ranges.copy.pass.cpp
--- a/libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/ranges.copy.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/ranges.copy.pass.cpp
@@ -100,13 +100,13 @@
 // 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>>();
diff --git a/libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/ranges.copy.segmented.pass.cpp b/libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/ranges.copy.segmented.pass.cpp
--- a/libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/ranges.copy.segmented.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/ranges.copy.segmented.pass.cpp
@@ -100,7 +100,7 @@
     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>>();
diff --git a/libcxx/test/std/algorithms/alg.nonmodifying/alg.equal/equal.pass.cpp b/libcxx/test/std/algorithms/alg.nonmodifying/alg.equal/equal.pass.cpp
--- a/libcxx/test/std/algorithms/alg.nonmodifying/alg.equal/equal.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.nonmodifying/alg.equal/equal.pass.cpp
@@ -79,7 +79,7 @@
 struct TestIter2 {
   template <class Iter1>
   TEST_CONSTEXPR_CXX20 void operator()() {
-    meta::for_each(TypeList(), Test<UnderlyingType, Iter1>());
+    TestMeta::for_each(TypeList(), Test<UnderlyingType, Iter1>());
   }
 };
 
@@ -99,12 +99,12 @@
 };
 
 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;
 }
@@ -118,10 +118,10 @@
   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;
diff --git a/libcxx/test/std/depr/depr.c.headers/math_h.pass.cpp b/libcxx/test/std/depr/depr.c.headers/math_h.pass.cpp
--- a/libcxx/test/std/depr/depr.c.headers/math_h.pass.cpp
+++ b/libcxx/test/std/depr/depr.c.headers/math_h.pass.cpp
@@ -947,53 +947,53 @@
 };
 
 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>();
diff --git a/libcxx/test/std/language.support/support.limits/limits/is_specialized.pass.cpp b/libcxx/test/std/language.support/support.limits/limits/is_specialized.pass.cpp
--- a/libcxx/test/std/language.support/support.limits/limits/is_specialized.pass.cpp
+++ b/libcxx/test/std/language.support/support.limits/limits/is_specialized.pass.cpp
@@ -44,7 +44,7 @@
 
 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");
diff --git a/libcxx/test/std/numerics/c.math/isfinite.pass.cpp b/libcxx/test/std/numerics/c.math/isfinite.pass.cpp
--- a/libcxx/test/std/numerics/c.math/isfinite.pass.cpp
+++ b/libcxx/test/std/numerics/c.math/isfinite.pass.cpp
@@ -63,8 +63,8 @@
 };
 
 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;
 }
diff --git a/libcxx/test/std/numerics/c.math/isinf.pass.cpp b/libcxx/test/std/numerics/c.math/isinf.pass.cpp
--- a/libcxx/test/std/numerics/c.math/isinf.pass.cpp
+++ b/libcxx/test/std/numerics/c.math/isinf.pass.cpp
@@ -63,8 +63,8 @@
 };
 
 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;
 }
diff --git a/libcxx/test/std/numerics/c.math/isnan.pass.cpp b/libcxx/test/std/numerics/c.math/isnan.pass.cpp
--- a/libcxx/test/std/numerics/c.math/isnan.pass.cpp
+++ b/libcxx/test/std/numerics/c.math/isnan.pass.cpp
@@ -63,8 +63,8 @@
 };
 
 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;
 }
diff --git a/libcxx/test/std/numerics/c.math/isnormal.pass.cpp b/libcxx/test/std/numerics/c.math/isnormal.pass.cpp
--- a/libcxx/test/std/numerics/c.math/isnormal.pass.cpp
+++ b/libcxx/test/std/numerics/c.math/isnormal.pass.cpp
@@ -63,8 +63,8 @@
 };
 
 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;
 }
diff --git a/libcxx/test/std/ranges/range.adaptors/range.as.rvalue/begin.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.as.rvalue/begin.pass.cpp
--- a/libcxx/test/std/ranges/range.adaptors/range.as.rvalue/begin.pass.cpp
+++ b/libcxx/test/std/ranges/range.adaptors/range.as.rvalue/begin.pass.cpp
@@ -84,14 +84,14 @@
 };
 
 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>>();
diff --git a/libcxx/test/std/ranges/range.adaptors/range.as.rvalue/end.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.as.rvalue/end.pass.cpp
--- a/libcxx/test/std/ranges/range.adaptors/range.as.rvalue/end.pass.cpp
+++ b/libcxx/test/std/ranges/range.adaptors/range.as.rvalue/end.pass.cpp
@@ -118,7 +118,7 @@
   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>();
diff --git a/libcxx/test/std/ranges/range.adaptors/range.filter/iterator/arrow.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.filter/iterator/arrow.pass.cpp
--- a/libcxx/test/std/ranges/range.adaptors/range.filter/iterator/arrow.pass.cpp
+++ b/libcxx/test/std/ranges/range.adaptors/range.filter/iterator/arrow.pass.cpp
@@ -25,7 +25,7 @@
 #include "test_macros.h"
 #include "../types.h"
 
-struct Point {
+struct XYPoint {
   int x;
   int y;
 };
@@ -34,21 +34,21 @@
 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>);
 
@@ -56,29 +56,29 @@
   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>;
@@ -100,10 +100,10 @@
 
 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.
@@ -114,11 +114,11 @@
       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*>();
   }
 
diff --git a/libcxx/test/std/strings/basic.string/string.access/at.pass.cpp b/libcxx/test/std/strings/basic.string/string.access/at.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.access/at.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.access/at.pass.cpp
@@ -76,7 +76,7 @@
 };
 
 TEST_CONSTEXPR_CXX20 bool test() {
-  meta::for_each(meta::character_types(), TestCaller());
+  TestMeta::for_each(TestMeta::character_types(), TestCaller());
 
   return true;
 }
diff --git a/libcxx/test/support/test.support/type_algorithms.pass.cpp b/libcxx/test/support/test.support/type_algorithms.pass.cpp
--- a/libcxx/test/support/test.support/type_algorithms.pass.cpp
+++ b/libcxx/test/support/test.support/type_algorithms.pass.cpp
@@ -14,14 +14,14 @@
 #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
@@ -57,7 +57,7 @@
 
 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()));
 }
 
diff --git a/libcxx/test/support/test_iterators.h b/libcxx/test/support/test_iterators.h
--- a/libcxx/test/support/test_iterators.h
+++ b/libcxx/test/support/test_iterators.h
@@ -1420,7 +1420,7 @@
 
 #endif // TEST_STD_VER > 17
 
-namespace meta {
+namespace TestMeta {
 template <class Ptr>
 using random_access_iterator_list =
     type_list<Ptr,
@@ -1444,7 +1444,7 @@
 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
diff --git a/libcxx/test/support/type_algorithms.h b/libcxx/test/support/type_algorithms.h
--- a/libcxx/test/support/type_algorithms.h
+++ b/libcxx/test/support/type_algorithms.h
@@ -13,7 +13,7 @@
 
 #include "test_macros.h"
 
-namespace meta {
+namespace TestMeta {
 template <class... Types>
 struct type_list {};
 
@@ -114,6 +114,6 @@
 
 template <class T>
 using as_pointers = typename type_list_as_pointers<T>::type;
-} // namespace meta
+} // namespace TestMeta
 
 #endif // TEST_SUPPORT_TYPE_ALGORITHMS_H