[libc++][C++03] Remove code that is not used in C++03

libcxx/include/__cxx03/__algorithm/equal.h

@@ -66,65 +66,6 @@ equal(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first
   return std::equal(__first1, __last1, __first2, __equal_to());
 }
 
-#if _LIBCPP_STD_VER >= 14
-
-template <class _Iter1, class _Sent1, class _Iter2, class _Sent2, class _Pred, class _Proj1, class _Proj2>
-_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool __equal_impl(
-    _Iter1 __first1, _Sent1 __last1, _Iter2 __first2, _Sent2 __last2, _Pred& __comp, _Proj1& __proj1, _Proj2& __proj2) {
-  while (__first1 != __last1 && __first2 != __last2) {
-    if (!std::__invoke(__comp, std::__invoke(__proj1, *__first1), std::__invoke(__proj2, *__first2)))
-      return false;
-    ++__first1;
-    ++__first2;
-  }
-  return __first1 == __last1 && __first2 == __last2;
-}
-
-template <class _Tp,
-          class _Up,
-          class _Pred,
-          class _Proj1,
-          class _Proj2,
-          __enable_if_t<__desugars_to_v<__equal_tag, _Pred, _Tp, _Up> && __is_identity<_Proj1>::value &&
-                            __is_identity<_Proj2>::value && !is_volatile<_Tp>::value && !is_volatile<_Up>::value &&
-                            __libcpp_is_trivially_equality_comparable<_Tp, _Up>::value,
-                        int> = 0>
-_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool
-__equal_impl(_Tp* __first1, _Tp* __last1, _Up* __first2, _Up*, _Pred&, _Proj1&, _Proj2&) {
-  return std::__constexpr_memcmp_equal(__first1, __first2, __element_count(__last1 - __first1));
-}
-
-template <class _InputIterator1, class _InputIterator2, class _BinaryPredicate>
-_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool
-equal(_InputIterator1 __first1,
-      _InputIterator1 __last1,
-      _InputIterator2 __first2,
-      _InputIterator2 __last2,
-      _BinaryPredicate __pred) {
-  if constexpr (__has_random_access_iterator_category<_InputIterator1>::value &&
-                __has_random_access_iterator_category<_InputIterator2>::value) {
-    if (std::distance(__first1, __last1) != std::distance(__first2, __last2))
-      return false;
-  }
-  __identity __proj;
-  return std::__equal_impl(
-      std::__unwrap_iter(__first1),
-      std::__unwrap_iter(__last1),
-      std::__unwrap_iter(__first2),
-      std::__unwrap_iter(__last2),
-      __pred,
-      __proj,
-      __proj);
-}
-
-template <class _InputIterator1, class _InputIterator2>
-_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool
-equal(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2) {
-  return std::equal(__first1, __last1, __first2, __last2, __equal_to());
-}
-
-#endif // _LIBCPP_STD_VER >= 14
-
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS

libcxx/include/__cxx03/__algorithm/for_each.h

@@ -33,21 +33,6 @@ for_each(_InputIterator __first, _InputIterator __last, _Function __f) {
   return __f;
 }
 
-// __movable_box is available in C++20, but is actually a copyable-box, so optimization is only correct in C++23
-#if _LIBCPP_STD_VER >= 23
-template <class _SegmentedIterator, class _Function>
-  requires __is_segmented_iterator<_SegmentedIterator>::value
-_LIBCPP_HIDE_FROM_ABI constexpr _Function
-for_each(_SegmentedIterator __first, _SegmentedIterator __last, _Function __func) {
-  ranges::__movable_box<_Function> __wrapped_func(in_place, std::move(__func));
-  std::__for_each_segment(__first, __last, [&](auto __lfirst, auto __llast) {
-    __wrapped_func =
-        ranges::__movable_box<_Function>(in_place, std::for_each(__lfirst, __llast, std::move(*__wrapped_func)));
-  });
-  return std::move(*__wrapped_func);
-}
-#endif // _LIBCPP_STD_VER >= 23
-
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS

libcxx/include/__cxx03/__algorithm/is_permutation.h

@@ -33,18 +33,6 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 template <class _Iter1, class _Sent1, class _Iter2, class _Sent2, class = void>
 struct _ConstTimeDistance : false_type {};
 
-#if _LIBCPP_STD_VER >= 20
-
-template <class _Iter1, class _Sent1, class _Iter2, class _Sent2>
-struct _ConstTimeDistance<_Iter1,
-                          _Sent1,
-                          _Iter2,
-                          _Sent2,
-                          __enable_if_t< sized_sentinel_for<_Sent1, _Iter1> && sized_sentinel_for<_Sent2, _Iter2> >>
-    : true_type {};
-
-#else
-
 template <class _Iter1, class _Iter2>
 struct _ConstTimeDistance<
     _Iter1,
@@ -55,8 +43,6 @@ struct _ConstTimeDistance<
                    is_same<typename iterator_traits<_Iter2>::iterator_category, random_access_iterator_tag>::value > >
     : true_type {};
 
-#endif // _LIBCPP_STD_VER >= 20
-
 // Internal functions
 
 // For each element in [f1, l1) see if there are the same number of equal elements in [f2, l2)
@@ -261,45 +247,6 @@ is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIt
   return std::is_permutation(__first1, __last1, __first2, __equal_to());
 }
 
-#if _LIBCPP_STD_VER >= 14
-
-// 2+2 iterators
-template <class _ForwardIterator1, class _ForwardIterator2>
-_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool is_permutation(
-    _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2) {
-  return std::__is_permutation<_ClassicAlgPolicy>(
-      std::move(__first1),
-      std::move(__last1),
-      std::move(__first2),
-      std::move(__last2),
-      __equal_to(),
-      __identity(),
-      __identity());
-}
-
-// 2+2 iterators, predicate
-template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool is_permutation(
-    _ForwardIterator1 __first1,
-    _ForwardIterator1 __last1,
-    _ForwardIterator2 __first2,
-    _ForwardIterator2 __last2,
-    _BinaryPredicate __pred) {
-  static_assert(__is_callable<_BinaryPredicate, decltype(*__first1), decltype(*__first2)>::value,
-                "The predicate has to be callable");
-
-  return std::__is_permutation<_ClassicAlgPolicy>(
-      std::move(__first1),
-      std::move(__last1),
-      std::move(__first2),
-      std::move(__last2),
-      __pred,
-      __identity(),
-      __identity());
-}
-
-#endif // _LIBCPP_STD_VER >= 14
-
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS

libcxx/include/__cxx03/__algorithm/iterator_operations.h

@@ -37,31 +37,6 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 template <class _AlgPolicy>
 struct _IterOps;
 
-#if _LIBCPP_STD_VER >= 20
-struct _RangeAlgPolicy {};
-
-template <>
-struct _IterOps<_RangeAlgPolicy> {
-  template <class _Iter>
-  using __value_type = iter_value_t<_Iter>;
-
-  template <class _Iter>
-  using __iterator_category = ranges::__iterator_concept<_Iter>;
-
-  template <class _Iter>
-  using __difference_type = iter_difference_t<_Iter>;
-
-  static constexpr auto advance      = ranges::advance;
-  static constexpr auto distance     = ranges::distance;
-  static constexpr auto __iter_move  = ranges::iter_move;
-  static constexpr auto iter_swap    = ranges::iter_swap;
-  static constexpr auto next         = ranges::next;
-  static constexpr auto prev         = ranges::prev;
-  static constexpr auto __advance_to = ranges::advance;
-};
-
-#endif
-
 struct _ClassicAlgPolicy {};
 
 template <>

libcxx/include/__cxx03/__algorithm/make_projected.h

@@ -73,33 +73,4 @@ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _Pred& __make_projected(_Pred& __pred, _
 
 _LIBCPP_END_NAMESPACE_STD
 
-#if _LIBCPP_STD_VER >= 20
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-namespace ranges {
-
-template <class _Comp, class _Proj1, class _Proj2>
-_LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) __make_projected_comp(_Comp& __comp, _Proj1& __proj1, _Proj2& __proj2) {
-  if constexpr (__is_identity<decay_t<_Proj1>>::value && __is_identity<decay_t<_Proj2>>::value &&
-                !is_member_pointer_v<decay_t<_Comp>>) {
-    // Avoid creating the lambda and just use the pristine comparator -- for certain algorithms, this would enable
-    // optimizations that rely on the type of the comparator.
-    return __comp;
-
-  } else {
-    return [&](auto&& __lhs, auto&& __rhs) -> bool {
-      return std::invoke(__comp,
-                         std::invoke(__proj1, std::forward<decltype(__lhs)>(__lhs)),
-                         std::invoke(__proj2, std::forward<decltype(__rhs)>(__rhs)));
-    };
-  }
-}
-
-} // namespace ranges
-
-_LIBCPP_END_NAMESPACE_STD
-
-#endif // _LIBCPP_STD_VER >= 20
-
 #endif // _LIBCPP___CXX03___ALGORITHM_MAKE_PROJECTED_H

libcxx/include/__cxx03/__algorithm/max.h

@@ -35,21 +35,6 @@ max(_LIBCPP_LIFETIMEBOUND const _Tp& __a, _LIBCPP_LIFETIMEBOUND const _Tp& __b)
   return std::max(__a, __b, __less<>());
 }
 
-#ifndef _LIBCPP_CXX03_LANG
-
-template <class _Tp, class _Compare>
-_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _Tp
-max(initializer_list<_Tp> __t, _Compare __comp) {
-  return *std::__max_element<__comp_ref_type<_Compare> >(__t.begin(), __t.end(), __comp);
-}
-
-template <class _Tp>
-_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _Tp max(initializer_list<_Tp> __t) {
-  return *std::max_element(__t.begin(), __t.end(), __less<>());
-}
-
-#endif // _LIBCPP_CXX03_LANG
-
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS

libcxx/include/__cxx03/__algorithm/min.h

@@ -35,21 +35,6 @@ min(_LIBCPP_LIFETIMEBOUND const _Tp& __a, _LIBCPP_LIFETIMEBOUND const _Tp& __b)
   return std::min(__a, __b, __less<>());
 }
 
-#ifndef _LIBCPP_CXX03_LANG
-
-template <class _Tp, class _Compare>
-_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _Tp
-min(initializer_list<_Tp> __t, _Compare __comp) {
-  return *std::__min_element<__comp_ref_type<_Compare> >(__t.begin(), __t.end(), __comp);
-}
-
-template <class _Tp>
-_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _Tp min(initializer_list<_Tp> __t) {
-  return *std::min_element(__t.begin(), __t.end(), __less<>());
-}
-
-#endif // _LIBCPP_CXX03_LANG
-
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS

libcxx/include/__cxx03/__algorithm/minmax.h

@@ -34,25 +34,6 @@ minmax(_LIBCPP_LIFETIMEBOUND const _Tp& __a, _LIBCPP_LIFETIMEBOUND const _Tp& __
   return std::minmax(__a, __b, __less<>());
 }
 
-#ifndef _LIBCPP_CXX03_LANG
-
-template <class _Tp, class _Compare>
-_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<_Tp, _Tp>
-minmax(initializer_list<_Tp> __t, _Compare __comp) {
-  static_assert(__is_callable<_Compare, _Tp, _Tp>::value, "The comparator has to be callable");
-  __identity __proj;
-  auto __ret = std::__minmax_element_impl(__t.begin(), __t.end(), __comp, __proj);
-  return pair<_Tp, _Tp>(*__ret.first, *__ret.second);
-}
-
-template <class _Tp>
-_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<_Tp, _Tp>
-minmax(initializer_list<_Tp> __t) {
-  return std::minmax(__t, __less<>());
-}
-
-#endif // _LIBCPP_CXX03_LANG
-
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___CXX03___ALGORITHM_MINMAX_H

libcxx/include/__cxx03/__algorithm/mismatch.h

@@ -164,52 +164,6 @@ mismatch(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __fi
   return std::mismatch(__first1, __last1, __first2, __equal_to());
 }
 
-#if _LIBCPP_STD_VER >= 14
-template <class _Iter1, class _Sent1, class _Iter2, class _Sent2, class _Pred, class _Proj1, class _Proj2>
-_LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 pair<_Iter1, _Iter2> __mismatch(
-    _Iter1 __first1, _Sent1 __last1, _Iter2 __first2, _Sent2 __last2, _Pred& __pred, _Proj1& __proj1, _Proj2& __proj2) {
-  while (__first1 != __last1 && __first2 != __last2) {
-    if (!std::__invoke(__pred, std::__invoke(__proj1, *__first1), std::__invoke(__proj2, *__first2)))
-      break;
-    ++__first1;
-    ++__first2;
-  }
-  return {std::move(__first1), std::move(__first2)};
-}
-
-template <class _Tp, class _Pred, class _Proj1, class _Proj2>
-_LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 pair<_Tp*, _Tp*>
-__mismatch(_Tp* __first1, _Tp* __last1, _Tp* __first2, _Tp* __last2, _Pred& __pred, _Proj1& __proj1, _Proj2& __proj2) {
-  auto __len = std::min(__last1 - __first1, __last2 - __first2);
-  return std::__mismatch(__first1, __first1 + __len, __first2, __pred, __proj1, __proj2);
-}
-
-template <class _InputIterator1, class _InputIterator2, class _BinaryPredicate>
-_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 pair<_InputIterator1, _InputIterator2>
-mismatch(_InputIterator1 __first1,
-         _InputIterator1 __last1,
-         _InputIterator2 __first2,
-         _InputIterator2 __last2,
-         _BinaryPredicate __pred) {
-  __identity __proj;
-  auto __res = std::__mismatch(
-      std::__unwrap_iter(__first1),
-      std::__unwrap_iter(__last1),
-      std::__unwrap_iter(__first2),
-      std::__unwrap_iter(__last2),
-      __pred,
-      __proj,
-      __proj);
-  return {std::__rewrap_iter(__first1, __res.first), std::__rewrap_iter(__first2, __res.second)};
-}
-
-template <class _InputIterator1, class _InputIterator2>
-_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 pair<_InputIterator1, _InputIterator2>
-mismatch(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2) {
-  return std::mismatch(__first1, __last1, __first2, __last2, __equal_to());
-}
-#endif
-
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS

libcxx/include/__cxx03/__algorithm/search.h

@@ -177,15 +177,6 @@ search(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2
   return std::search(__first1, __last1, __first2, __last2, __equal_to());
 }
 
-#if _LIBCPP_STD_VER >= 17
-template <class _ForwardIterator, class _Searcher>
-[[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _ForwardIterator
-search(_ForwardIterator __f, _ForwardIterator __l, const _Searcher& __s) {
-  return __s(__f, __l).first;
-}
-
-#endif
-
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___CXX03___ALGORITHM_SEARCH_H

libcxx/include/__cxx03/__algorithm/shuffle.h

@@ -62,7 +62,6 @@ class _LIBCPP_EXPORTED_FROM_ABI __libcpp_debug_randomizer {
   }
 };
 
-#if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_RANDOM_SHUFFLE) || defined(_LIBCPP_BUILDING_LIBRARY)
 class _LIBCPP_EXPORTED_FROM_ABI __rs_default;
 
 _LIBCPP_EXPORTED_FROM_ABI __rs_default __rs_get();
@@ -111,14 +110,7 @@ random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last) {
 
 template <class _RandomAccessIterator, class _RandomNumberGenerator>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_DEPRECATED_IN_CXX14 void
-random_shuffle(_RandomAccessIterator __first,
-               _RandomAccessIterator __last,
-#  ifndef _LIBCPP_CXX03_LANG
-               _RandomNumberGenerator&& __rand)
-#  else
-               _RandomNumberGenerator& __rand)
-#  endif
-{
+random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last, _RandomNumberGenerator&& __rand) {
   typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
   difference_type __d = __last - __first;
   if (__d > 1) {
@@ -129,7 +121,6 @@ random_shuffle(_RandomAccessIterator __first,
     }
   }
 }
-#endif
 
 template <class _AlgPolicy, class _RandomAccessIterator, class _Sentinel, class _UniformRandomNumberGenerator>
 _LIBCPP_HIDE_FROM_ABI _RandomAccessIterator