[libcxx-commits] [libcxx] f56dfb7 - [libc++] Fix modules issues on OS X
Louis Dionne via libcxx-commits
libcxx-commits at lists.llvm.org
Wed Mar 1 07:34:11 PST 2023
Author: Arthur O'Dwyer
Date: 2023-03-01T10:33:40-05:00
New Revision: f56dfb78aa3fcc96bf7e5b6c3bdff8fa620aefd1
URL: https://github.com/llvm/llvm-project/commit/f56dfb78aa3fcc96bf7e5b6c3bdff8fa620aefd1
DIFF: https://github.com/llvm/llvm-project/commit/f56dfb78aa3fcc96bf7e5b6c3bdff8fa620aefd1.diff
LOG: [libc++] Fix modules issues on OS X
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 types::. 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 */
^
Finally, add a CI configuration for modules on OS X to make sure it
does not regress.
Differential Revision: https://reviews.llvm.org/D144915
Added:
Modified:
libcxx/test/libcxx/type_traits/is_always_bitcastable.compile.pass.cpp
libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/ranges.copy.pass.cpp
libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/ranges.copy.segmented.pass.cpp
libcxx/test/std/algorithms/alg.nonmodifying/alg.equal/equal.pass.cpp
libcxx/test/std/depr/depr.c.headers/math_h.pass.cpp
libcxx/test/std/language.support/support.limits/limits/is_specialized.pass.cpp
libcxx/test/std/numerics/c.math/isfinite.pass.cpp
libcxx/test/std/numerics/c.math/isinf.pass.cpp
libcxx/test/std/numerics/c.math/isnan.pass.cpp
libcxx/test/std/numerics/c.math/isnormal.pass.cpp
libcxx/test/std/ranges/range.adaptors/range.as.rvalue/begin.pass.cpp
libcxx/test/std/ranges/range.adaptors/range.as.rvalue/end.pass.cpp
libcxx/test/std/ranges/range.adaptors/range.filter/iterator/arrow.pass.cpp
libcxx/test/std/strings/basic.string/string.access/at.pass.cpp
libcxx/test/support/test.support/type_algorithms.pass.cpp
libcxx/test/support/test_iterators.h
libcxx/test/support/type_algorithms.h
libcxx/utils/ci/buildkite-pipeline.yml
Removed:
################################################################################
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
index 4e78fa1bf4eff..3dc2da8f2d99a 100644
--- 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 @@ constexpr void check_with_cv() {
template <bool Expected, class Types1, class Types2 = Types1>
constexpr void check() {
- meta::for_each(Types1{}, []<class T>() {
- meta::for_each(Types2{}, []<class U>() {
+ types::for_each(Types1{}, []<class T>() {
+ types::for_each(Types2{}, []<class U>() {
check_with_cv<Expected, T, U>();
});
});
@@ -71,91 +71,91 @@ constexpr void test() {
// 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 = types::type_list<char8_t, int8_t, uint8_t>;
+ using chars = types::type_list<char, unsigned char, signed char>;
#if CHAR_BIT == 8
- check<true, meta::concatenate_t<integral_8, chars>>();
+ check<true, types::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 = types::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, types::concatenate_t<integral_16, types::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 = types::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, types::concatenate_t<integral_32, types::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 = types::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, types::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, types::type_list<bool>, types::concatenate_t<types::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, types::floating_point_types, types::integral_types>();
+ check_both_ways<false, types::type_list<float>, types::type_list<double, long double>>();
+ check_both_ways<false, types::type_list<double>, types::type_list<float, long double>>();
+ check_both_ways<false, types::type_list<long double>, types::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, types::concatenate_t<integral_16, integral_32, integral_64>>();
+ check_both_ways<false, integral_16, types::concatenate_t<integral_8, integral_32, integral_64>>();
+ check_both_ways<false, integral_32, types::concatenate_t<integral_8, integral_16, integral_64>>();
+ check_both_ways<false, integral_64, types::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, types::type_list<bool>, integral_8>();
+ using larger_than_bool = types::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>>();
+ types::floating_point_types>;
+ check<false, types::type_list<bool>, larger_than_bool>();
+ check<false, types::concatenate_t<integral_8, larger_than_bool>, types::type_list<bool>>();
// Different representations -- floating point vs. integral.
- check_both_ways<false, meta::floating_point_types, meta::integral_types>();
+ check_both_ways<false, types::floating_point_types, types::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, types::type_list<E1>>();
+ check_both_ways<false, types::type_list<E1>, types::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, types::type_list<ScopedE1>>();
+ check_both_ways<false, types::type_list<ScopedE1>, types::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, types::type_list<int*>>();
+ check_both_ways<false, types::type_list<int*>, types::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, types::type_list<FuncPtr1>>();
+ check_both_ways<false, types::type_list<FuncPtr1>, types::type_list<FuncPtr2>>();
}
// Pointers to members.
@@ -171,49 +171,49 @@ constexpr void test() {
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, types::type_list<MemObjPtr1>>();
+ check<true, types::type_list<MemFuncPtr1>>();
+ check_both_ways<false, types::type_list<MemObjPtr1>, types::type_list<MemObjPtr2>>();
+ check_both_ways<false, types::type_list<MemFuncPtr1>, types::type_list<MemFuncPtr2>>();
}
// Trivial classes.
{
struct S1 {};
- check<true, meta::type_list<S1>>();
+ check<true, types::type_list<S1>>();
struct S2 {};
- check_both_ways<false, meta::type_list<S1>, meta::type_list<S2>>();
+ check_both_ways<false, types::type_list<S1>, types::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, types::type_list<VolatileMembersS>>();
}
// Trivial unions.
{
union U1 {};
- check<true, meta::type_list<U1>>();
+ check<true, types::type_list<U1>>();
union U2 {};
- check_both_ways<false, meta::type_list<U1>, meta::type_list<U2>>();
+ check_both_ways<false, types::type_list<U1>, types::type_list<U2>>();
union VolatileMembersU {
volatile int x;
};
- check<true, meta::type_list<VolatileMembersU>>();
+ check<true, types::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, types::type_list<int&>, types::type_list<int&>>();
}
// Arrays.
{
- check<true, meta::type_list<int[8]>>();
+ check<true, types::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
index 7a5c0a7531727..bc9c2788293cd 100644
--- 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 @@ constexpr void test_iterators() {
// clang-format on
constexpr bool test() {
- meta::for_each(meta::forward_iterator_list<int*>{}, []<class Out>() {
+ types::for_each(types::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>() {
+ types::for_each(types::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
index cf1f926031ed8..9291c0aa1f434 100644
--- 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 @@ int main(int, char**) {
test_containers<std::vector<int>, std::vector<int>>();
}
- meta::for_each(meta::forward_iterator_list<int*>{}, []<class Iter> {
+ types::for_each(types::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
index c182feb8df834..e40f1ed6dbbfa 100644
--- 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 @@ template <class UnderlyingType, class TypeList>
struct TestIter2 {
template <class Iter1>
TEST_CONSTEXPR_CXX20 void operator()() {
- meta::for_each(TypeList(), Test<UnderlyingType, Iter1>());
+ types::for_each(TypeList(), Test<UnderlyingType, Iter1>());
}
};
@@ -99,12 +99,12 @@ struct AddressCompare {
};
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*> >());
+ types::for_each(types::cpp17_input_iterator_list<int*>(), TestIter2<int, types::cpp17_input_iterator_list<int*> >());
+ types::for_each(types::cpp17_input_iterator_list<char*>(), TestIter2<char, types::cpp17_input_iterator_list<char*> >());
+ types::for_each(types::cpp17_input_iterator_list<AddressCompare*>(),
+ TestIter2<AddressCompare, types::cpp17_input_iterator_list<AddressCompare*> >());
- meta::for_each(meta::integral_types(), TestNarrowingEqualTo());
+ types::for_each(types::integral_types(), TestNarrowingEqualTo());
return true;
}
@@ -118,10 +118,10 @@ int main(int, char**) {
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> > >());
+ types::for_each(types::as_pointers<types::cv_qualified_versions<int> >(),
+ TestIter2<int, types::as_pointers<types::cv_qualified_versions<int> > >());
+ types::for_each(types::as_pointers<types::cv_qualified_versions<char> >(),
+ TestIter2<char, types::as_pointers<types::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
index db815f97fd1f4..8ce3b0816d518 100644
--- 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 test_three_args {
};
struct CallTwoArgs {
- using integral_float_double = meta::concatenate_t<meta::integral_types, meta::type_list<float, double> >;
+ using integral_float_double = types::concatenate_t<types::integral_types, types::type_list<float, double> >;
template <class Arg2>
void operator()() {
- meta::for_each(integral_float_double(), test_two_args</*PromoteResult=*/double, /*Iterate*/void, Arg2>());
+ types::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 = types::concatenate_t<types::integral_types, types::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>());
+ types::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>());
+ types::for_each(integral_float_double(), Helper<Arg3>());
}
};
int main(int, char**)
{
- meta::for_each(meta::integral_types(), test_single_arg</*PromoteResult=*/double>());
+ types::for_each(types::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());
+ types::for_each(types::integral_types(), CallTwoArgs());
- meta::for_each(
- meta::integral_types(), test_two_args</*PromoteResult=*/long double, /*Arg1=*/void, /*Arg2=*/long double>());
+ types::for_each(
+ types::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>());
+ types::for_each(types::integral_types(), CallThreeArgs<double>());
+ types::for_each(
+ types::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
index 0c39f9fccce57..f27c73157582d 100644
--- 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 @@ struct Test {
int main(int, char**)
{
- meta::for_each(meta::arithmetic_types(), Test());
+ types::for_each(types::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
index fd2ad11523b30..6bbc3aaac6d13 100644
--- a/libcxx/test/std/numerics/c.math/isfinite.pass.cpp
+++ b/libcxx/test/std/numerics/c.math/isfinite.pass.cpp
@@ -63,8 +63,8 @@ struct TestInt {
};
int main(int, char**) {
- meta::for_each(meta::floating_point_types(), TestFloat());
- meta::for_each(meta::integral_types(), TestInt());
+ types::for_each(types::floating_point_types(), TestFloat());
+ types::for_each(types::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
index 3b1e54fa08223..e935b53187fe6 100644
--- a/libcxx/test/std/numerics/c.math/isinf.pass.cpp
+++ b/libcxx/test/std/numerics/c.math/isinf.pass.cpp
@@ -63,8 +63,8 @@ struct TestInt {
};
int main(int, char**) {
- meta::for_each(meta::floating_point_types(), TestFloat());
- meta::for_each(meta::integral_types(), TestInt());
+ types::for_each(types::floating_point_types(), TestFloat());
+ types::for_each(types::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
index c8ac0551c997e..fffb124645862 100644
--- a/libcxx/test/std/numerics/c.math/isnan.pass.cpp
+++ b/libcxx/test/std/numerics/c.math/isnan.pass.cpp
@@ -63,8 +63,8 @@ struct TestInt {
};
int main(int, char**) {
- meta::for_each(meta::floating_point_types(), TestFloat());
- meta::for_each(meta::integral_types(), TestInt());
+ types::for_each(types::floating_point_types(), TestFloat());
+ types::for_each(types::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
index 681438efe2281..c3b8f31359f98 100644
--- a/libcxx/test/std/numerics/c.math/isnormal.pass.cpp
+++ b/libcxx/test/std/numerics/c.math/isnormal.pass.cpp
@@ -63,8 +63,8 @@ struct TestInt {
};
int main(int, char**) {
- meta::for_each(meta::floating_point_types(), TestFloat());
- meta::for_each(meta::integral_types(), TestInt());
+ types::for_each(types::floating_point_types(), TestFloat());
+ types::for_each(types::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
index 684cdd875a364..db846b25b9551 100644
--- 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 @@ struct move_iterator_view : std::ranges::view_base {
};
constexpr bool test() {
- meta::for_each(meta::cpp20_input_iterator_list<int*>{}, []<class Iter> {
+ types::for_each(types::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> {
+ types::for_each(types::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
index eb79e141feb6a..529a609a3bbe1 100644
--- 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 @@ constexpr bool test() {
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> {
+ types::for_each(types::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
index b9b1a4e00fc25..71d16e4e7e04b 100644
--- 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 @@ 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
diff erence_type = std::ptr
diff _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 WithNonCopyableIterator : std::ranges::view_base {
struct iterator {
using iterator_category = std::input_iterator_tag;
using
diff erence_type = std::ptr
diff _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 void test() {
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 @@ constexpr bool tests() {
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
index 3e17d07e2d811..9530950b33673 100644
--- 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 @@ struct TestCaller {
};
TEST_CONSTEXPR_CXX20 bool test() {
- meta::for_each(meta::character_types(), TestCaller());
+ types::for_each(types::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
index f94487d1c868e..cf6144d1cb04f 100644
--- 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<types::concatenate_t<types::type_list<> >, types::type_list<> >::value, "");
+static_assert(std::is_same<types::concatenate_t<types::type_list<int> >, types::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<types::concatenate_t<types::type_list<int>, types::type_list<long> >, types::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<types::concatenate_t<types::type_list<int>, types::type_list<long>, types::type_list<long long> >,
+ types::type_list<int, long, long long> >::value,
"");
// apply_all
@@ -57,7 +57,7 @@ struct Identity {
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));
+ types::for_each(types::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
index ab64619143ec2..b03687447c14b 100644
--- a/libcxx/test/support/test_iterators.h
+++ b/libcxx/test/support/test_iterators.h
@@ -1420,7 +1420,7 @@ ProxyRange(R&&) -> ProxyRange<std::views::all_t<R&&>>;
#endif // TEST_STD_VER > 17
-namespace meta {
+namespace types {
template <class Ptr>
using random_access_iterator_list =
type_list<Ptr,
@@ -1444,7 +1444,7 @@ 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 types
#endif // SUPPORT_TEST_ITERATORS_H
diff --git a/libcxx/test/support/type_algorithms.h b/libcxx/test/support/type_algorithms.h
index a066e54ce50cb..95a282b7b0bcf 100644
--- 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 types {
template <class... Types>
struct type_list {};
@@ -114,6 +114,6 @@ struct type_list_as_pointers<type_list<Types...> > {
template <class T>
using as_pointers = typename type_list_as_pointers<T>::type;
-} // namespace meta
+} // namespace types
#endif // TEST_SUPPORT_TYPE_ALGORITHMS_H
diff --git a/libcxx/utils/ci/buildkite-pipeline.yml b/libcxx/utils/ci/buildkite-pipeline.yml
index f4ff83a67a531..e80c536346aed 100644
--- a/libcxx/utils/ci/buildkite-pipeline.yml
+++ b/libcxx/utils/ci/buildkite-pipeline.yml
@@ -812,6 +812,20 @@ steps:
limit: 2
timeout_in_minutes: 120
+ - label: "MacOS with Modules"
+ command: "libcxx/utils/ci/run-buildbot generic-modules"
+ artifact_paths:
+ - "**/test-results.xml"
+ - "**/*.abilist"
+ agents:
+ queue: "libcxx-builders"
+ os: "macos"
+ retry:
+ automatic:
+ - exit_status: -1 # Agent was lost
+ limit: 2
+ timeout_in_minutes: 120
+
# Build with the configuration we use to generate libc++.dylib on Apple platforms
- label: "Apple system"
command: "libcxx/utils/ci/run-buildbot apple-system"
More information about the libcxx-commits
mailing list