Implement P2404 as a DR rather than only in 23

Author: randomnetcat

libcxx/include/__concepts/comparison_common_type.h

@@ -24,14 +24,6 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20
 
-#  if _LIBCPP_STD_VER < 23
-
-template <class _Tp, class _Up>
-concept __comparison_common_type_with =
-    common_reference_with<__make_const_lvalue_ref<_Tp>, __make_const_lvalue_ref<_Up>>;
-
-#  else
-
 template <class _Tp, class _Up, class _CommonRef = common_reference_t<const _Tp&, const _Up&>>
 concept __comparison_common_type_with_impl =
     same_as<common_reference_t<const _Tp&, const _Up&>, common_reference_t<const _Up&, const _Tp&>> && requires {
@@ -42,8 +34,6 @@ concept __comparison_common_type_with_impl =
 template <class _Tp, class _Up>
 concept __comparison_common_type_with = __comparison_common_type_with_impl<remove_cvref_t<_Tp>, remove_cvref_t<_Up>>;
 
-#  endif // _LIBCPP_STD_VER < 23
-
 #endif // _LIBCPP_STD_VER >= 20
 
 _LIBCPP_END_NAMESPACE_STD

libcxx/test/std/algorithms/alg.sorting/alg.sort/partial.sort.copy/ranges_partial_sort_copy.pass.cpp

@@ -89,12 +89,8 @@ struct NoComparator {};
 // !indirect_strict_weak_order<Comp, projected<I1, Proj1>, projected<I2, Proj2>>
 static_assert(!HasPartialSortCopyIter<NoComparator*, NoComparator*, NoComparator*, NoComparator*>);
 
-#if TEST_STD_VER < 23
-static_assert(!HasPartialSortCopyIter<int*, int*, MoveOnly*, MoveOnly*>);
-#else
 // P2404
 static_assert(HasPartialSortCopyIter<int*, int*, MoveOnly*, MoveOnly*>);
-#endif // TEST_STD_VER < 23
 
 // Test constraints of the (range) overload.
 // ======================================================
@@ -129,12 +125,8 @@ static_assert(!HasPartialSortCopyRange<R<int*>, R<const int*>>);
 // !indirect_strict_weak_order<Comp, projected<iterator_t<R1>, Proj1>, projected<iterator_t<R2>, Proj2>>
 static_assert(!HasPartialSortCopyRange<R<NoComparator*>, R<NoComparator*>>);
 
-#if TEST_STD_VER < 23
-static_assert(!HasPartialSortCopyRange<R<int*>, R<MoveOnly*>>);
-#else
 // P2404
 static_assert(HasPartialSortCopyRange<R<int*>, R<MoveOnly*>>);
-#endif // TEST_STD_VER < 23
 
 static_assert(std::is_same_v<std::ranges::partial_sort_copy_result<int, int>, std::ranges::in_out_result<int, int>>);
 

libcxx/test/std/concepts/concepts.compare/concept.equalitycomparable/equality_comparable_with.compile.pass.cpp

@@ -1117,14 +1117,8 @@ static_assert(
 static_assert(
     !check_equality_comparable_with<one_way_ne, explicit_operators>());
 
-#if TEST_STD_VER < 23
-static_assert(!check_equality_comparable_with<move_only_equality_with_int, int>());
-static_assert(!check_equality_comparable_with<std::unique_ptr<int>, std::nullptr_t>());
-#else
 // P2404
 static_assert(check_equality_comparable_with<move_only_equality_with_int, int>());
 static_assert(check_equality_comparable_with<std::unique_ptr<int>, std::nullptr_t>());
-#endif // TEST_STD_VER < 23
-
 static_assert(!check_equality_comparable_with<nonmovable_equality_with_int, int>());
 } // namespace types_fit_for_purpose

libcxx/test/std/language.support/cmp/cmp.concept/three_way_comparable_with.compile.pass.cpp

@@ -235,12 +235,8 @@ struct MoveOnlyIntComparable {
   friend auto operator<=>(MoveOnlyIntComparable const&, MoveOnlyIntComparable const&) = default;
 };
 
-#if TEST_STD_VER < 23
-static_assert(!check_three_way_comparable_with<MoveOnlyIntComparable, int>());
-#else
 // P2404
 static_assert(check_three_way_comparable_with<MoveOnlyIntComparable, int>());
-#endif // TEST_STD_VER < 23
 
 struct NonMovableIntComparable {
   NonMovableIntComparable(int) {}

libcxx/test/std/utilities/function.objects/range.cmp/equal_to.pass.cpp

@@ -30,12 +30,8 @@ struct NotEqualityComparable {
 static_assert(!std::is_invocable_v<std::ranges::equal_to, NotEqualityComparable, NotEqualityComparable>);
 static_assert(std::is_invocable_v<std::ranges::equal_to, explicit_operators, explicit_operators>);
 
-#if TEST_STD_VER < 23
-static_assert(!std::is_invocable_v<std::ranges::equal_to, int, MoveOnly>);
-#else
 // P2404
 static_assert(std::is_invocable_v<std::ranges::equal_to, int, MoveOnly>);
-#endif // TEST_STD_VER < 23
 
 static_assert(requires { typename std::ranges::equal_to::is_transparent; });
 

libcxx/test/std/utilities/function.objects/range.cmp/greater.pass.cpp

@@ -29,12 +29,8 @@ struct NotTotallyOrdered {
 static_assert(!std::is_invocable_v<std::ranges::greater, NotTotallyOrdered, NotTotallyOrdered>);
 static_assert(std::is_invocable_v<std::ranges::greater, explicit_operators, explicit_operators>);
 
-#if TEST_STD_VER < 23
-static_assert(!std::is_invocable_v<std::ranges::greater, int, MoveOnly>);
-#else
 // P2404
 static_assert(std::is_invocable_v<std::ranges::greater, int, MoveOnly>);
-#endif // TEST_STD_VER < 23
 
 static_assert(requires { typename std::ranges::greater::is_transparent; });
 

libcxx/test/std/utilities/function.objects/range.cmp/greater_equal.pass.cpp

@@ -29,12 +29,8 @@ struct NotTotallyOrdered {
 static_assert(!std::is_invocable_v<std::ranges::greater_equal, NotTotallyOrdered, NotTotallyOrdered>);
 static_assert(std::is_invocable_v<std::ranges::greater_equal, explicit_operators, explicit_operators>);
 
-#if TEST_STD_VER < 23
-static_assert(!std::is_invocable_v<std::ranges::greater_equal, int, MoveOnly>);
-#else
 // P2404
 static_assert(std::is_invocable_v<std::ranges::greater_equal, int, MoveOnly>);
-#endif // TEST_STD_VER < 23
 
 static_assert(requires { typename std::ranges::greater_equal::is_transparent; });
 

libcxx/test/std/utilities/function.objects/range.cmp/less.pass.cpp

@@ -29,12 +29,8 @@ struct NotTotallyOrdered {
 static_assert(!std::is_invocable_v<std::ranges::less, NotTotallyOrdered, NotTotallyOrdered>);
 static_assert(std::is_invocable_v<std::ranges::less, explicit_operators, explicit_operators>);
 
-#if TEST_STD_VER < 23
-static_assert(!std::is_invocable_v<std::ranges::less, int, MoveOnly>);
-#else
 // P2404
 static_assert(std::is_invocable_v<std::ranges::less, int, MoveOnly>);
-#endif // TEST_STD_VER < 23
 
 static_assert(requires { typename std::ranges::less::is_transparent; });
 

libcxx/test/std/utilities/function.objects/range.cmp/less_equal.pass.cpp

@@ -29,12 +29,8 @@ struct NotTotallyOrdered {
 static_assert(!std::is_invocable_v<std::ranges::less_equal, NotTotallyOrdered, NotTotallyOrdered>);
 static_assert(std::is_invocable_v<std::ranges::less_equal, explicit_operators, explicit_operators>);
 
-#if TEST_STD_VER < 23
-static_assert(!std::is_invocable_v<std::ranges::less_equal, int, MoveOnly>);
-#else
 // P2404
 static_assert(std::is_invocable_v<std::ranges::less_equal, int, MoveOnly>);
-#endif // TEST_STD_VER < 23
 
 static_assert(requires { typename std::ranges::less_equal::is_transparent; });
 

libcxx/test/std/utilities/function.objects/range.cmp/not_equal_to.pass.cpp

@@ -30,12 +30,8 @@ struct NotEqualityComparable {
 static_assert(!std::is_invocable_v<std::ranges::equal_to, NotEqualityComparable, NotEqualityComparable>);
 static_assert(std::is_invocable_v<std::ranges::equal_to, explicit_operators, explicit_operators>);
 
-#if TEST_STD_VER < 23
-static_assert(!std::is_invocable_v<std::ranges::not_equal_to, int, MoveOnly>);
-#else
 // P2404
 static_assert(std::is_invocable_v<std::ranges::not_equal_to, int, MoveOnly>);
-#endif // TEST_STD_VER < 23
 
 static_assert(requires { typename std::ranges::not_equal_to::is_transparent; });