[libc++] Add a __libcpp_pair to avoid debug information

[var-const]

libcxx/include/__utility/pair.h

626

Would using _LIBCPP_NODEBUG on both functions help?

libcxx/include/__algorithm/move.h

 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 // move
 
 template <class _AlgPolicy, class _InIter, class _Sent, class _OutIter>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
-pair<_InIter, _OutIter> __move_impl(_InIter __first, _Sent __last, _OutIter __result) {
+__libcpp_pair<_InIter, _OutIter> __move_impl(_InIter __first, _Sent __last, _OutIter __result) {
   while (__first != __last) {
     *__result = _IterOps<_AlgPolicy>::__iter_move(__first);
     ++__first;
     ++__result;
   }
-  return std::make_pair(std::move(__first), std::move(__result));
+  return std::__make_libcpp_pair(std::move(__first), std::move(__result));
 }
 
 template <class _AlgPolicy,
           class _InType,
           class _OutType,
           class = __enable_if_t<is_same<typename remove_const<_InType>::type, _OutType>::value
                              && is_trivially_move_assignable<_OutType>::value> >
 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11
-pair<_InType*, _OutType*> __move_impl(_InType* __first, _InType* __last, _OutType* __result) {
+__libcpp_pair<_InType*, _OutType*> __move_impl(_InType* __first, _InType* __last, _OutType* __result) {
   if (__libcpp_is_constant_evaluated()
 // TODO: Remove this once GCC supports __builtin_memmove during constant evaluation
 #ifndef _LIBCPP_COMPILER_GCC
    && !is_trivially_copyable<_InType>::value
 #endif
      )
     return std::__move_impl<_AlgPolicy, _InType*, _InType*, _OutType*>(__first, __last, __result);
   const size_t __n = static_cast<size_t>(__last - __first);
   ::__builtin_memmove(__result, __first, __n * sizeof(_OutType));
-  return std::make_pair(__first + __n, __result + __n);
+  return std::__make_libcpp_pair(__first + __n, __result + __n);
 }
 
 template <class>
 struct __is_trivially_move_assignable_unwrapped_impl : false_type {};
 
 template <class _Type>
 struct __is_trivially_move_assignable_unwrapped_impl<_Type*> : is_trivially_move_assignable<_Type> {};
 
 template <class _Iter>
 struct __is_trivially_move_assignable_unwrapped
     : __is_trivially_move_assignable_unwrapped_impl<decltype(std::__unwrap_iter<_Iter>(std::declval<_Iter>()))> {};
 
 template <class _AlgPolicy,
           class _InIter,
           class _OutIter,
           __enable_if_t<is_same<typename remove_const<typename iterator_traits<_InIter>::value_type>::type,
                                 typename iterator_traits<_OutIter>::value_type>::value
                      && __is_cpp17_contiguous_iterator<_InIter>::value
                      && __is_cpp17_contiguous_iterator<_OutIter>::value
                      && is_trivially_move_assignable<__iter_value_type<_OutIter> >::value, int> = 0>
 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14
-pair<reverse_iterator<_InIter>, reverse_iterator<_OutIter> >
+__libcpp_pair<reverse_iterator<_InIter>, reverse_iterator<_OutIter> >
 __move_impl(reverse_iterator<_InIter> __first,
             reverse_iterator<_InIter> __last,
             reverse_iterator<_OutIter> __result) {
   auto __first_base = std::__unwrap_iter(__first.base());
   auto __last_base = std::__unwrap_iter(__last.base());
   auto __result_base = std::__unwrap_iter(__result.base());
   auto __result_first = __result_base - (__first_base - __last_base);
   std::__move_impl<_AlgPolicy>(__last_base, __first_base, __result_first);
-  return std::make_pair(__last, reverse_iterator<_OutIter>(std::__rewrap_iter(__result.base(), __result_first)));
+  return std::__make_libcpp_pair(
+      __last, reverse_iterator<_OutIter>(std::__rewrap_iter(__result.base(), __result_first)));
 }
 
 template <class _AlgPolicy, class _InIter, class _Sent, class _OutIter>
 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11
 __enable_if_t<is_copy_constructible<_InIter>::value
            && is_copy_constructible<_Sent>::value
-           && is_copy_constructible<_OutIter>::value, pair<_InIter, _OutIter> >
+           && is_copy_constructible<_OutIter>::value, __libcpp_pair<_InIter, _OutIter> >
 __move(_InIter __first, _Sent __last, _OutIter __result) {
   auto __ret = std::__move_impl<_AlgPolicy>(
       std::__unwrap_iter(__first), std::__unwrap_iter(__last), std::__unwrap_iter(__result));
-  return std::make_pair(std::__rewrap_iter(__first, __ret.first), std::__rewrap_iter(__result, __ret.second));
+  return std::__make_libcpp_pair(
+      std::__rewrap_iter(__first, __ret.__first_), std::__rewrap_iter(__result, __ret.__second_));
 }
 
 template <class _AlgPolicy, class _InIter, class _Sent, class _OutIter>
 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11
 __enable_if_t<!is_copy_constructible<_InIter>::value
            || !is_copy_constructible<_Sent>::value
-           || !is_copy_constructible<_OutIter>::value, pair<_InIter, _OutIter> >
+           || !is_copy_constructible<_OutIter>::value, __libcpp_pair<_InIter, _OutIter> >
 __move(_InIter __first, _Sent __last, _OutIter __result) {
   return std::__move_impl<_AlgPolicy>(std::move(__first), std::move(__last), std::move(__result));
 }
 
 template <class _InputIterator, class _OutputIterator>
 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17
 _OutputIterator move(_InputIterator __first, _InputIterator __last, _OutputIterator __result) {
-  return std::__move<_ClassicAlgPolicy>(__first, __last, __result).second;
+  return std::__move<_ClassicAlgPolicy>(__first, __last, __result).__second_;
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___ALGORITHM_MOVE_H

libcxx/include/__algorithm/ranges_move.h

 
 namespace __move {
 struct __fn {
 
   template <class _InIter, class _Sent, class _OutIter>
   _LIBCPP_HIDE_FROM_ABI constexpr static
   move_result<_InIter, _OutIter> __move_impl(_InIter __first, _Sent __last, _OutIter __result) {
     auto __ret = std::__move<_RangeAlgPolicy>(std::move(__first), std::move(__last), std::move(__result));
-    return {std::move(__ret.first), std::move(__ret.second)};
+    return {std::move(__ret.__first_), std::move(__ret.__second_)};
   }
 
   template <input_iterator _InIter, sentinel_for<_InIter> _Sent, weakly_incrementable _OutIter>
     requires indirectly_movable<_InIter, _OutIter>
   _LIBCPP_HIDE_FROM_ABI constexpr
   move_result<_InIter, _OutIter> operator()(_InIter __first, _Sent __last, _OutIter __result) const {
     return __move_impl(std::move(__first), std::move(__last), std::move(__result));
   }

libcxx/include/__algorithm/rotate.h

 _LIBCPP_CONSTEXPR_AFTER_CXX11 _ForwardIterator
 __rotate_left(_ForwardIterator __first, _ForwardIterator __last)
 {
     typedef typename iterator_traits<_ForwardIterator>::value_type value_type;
     using _Ops = _IterOps<_AlgPolicy>;
 
     value_type __tmp = _Ops::__iter_move(__first);
     _ForwardIterator __lm1 = std::__move<_AlgPolicy>(
-        _Ops::next(__first), __last, __first).second;
+        _Ops::next(__first), __last, __first).__second_;
     *__lm1 = _VSTD::move(__tmp);
     return __lm1;
 }
 
 template <class _AlgPolicy, class _BidirectionalIterator>
 _LIBCPP_CONSTEXPR_AFTER_CXX11 _BidirectionalIterator
 __rotate_right(_BidirectionalIterator __first, _BidirectionalIterator __last)
 {

libcxx/include/__utility/pair.h

 inline _LIBCPP_INLINE_VISIBILITY
 constexpr _T1 const && get(pair<_T2, _T1> const&& __p) _NOEXCEPT
 {
     return __get_pair<1>::get(_VSTD::move(__p));
 }
 
 #endif
 
+template <class _FirstType, class _SecondType>
+struct __libcpp_pair {
+    template <class _FirstT, class _SecondT>
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR __libcpp_pair(_FirstT&& __first, _SecondT&& __second)
+        : __first_(std::forward<_FirstT>(__first)), __second_(std::forward<_SecondT>(__second)) {}
+    _FirstType __first_;
+    _SecondType __second_;
+};
+
+template <class _FirstType, class _SecondType>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR __libcpp_pair<__uncvref_t<_FirstType>, __uncvref_t<_SecondType> >
+__make_libcpp_pair(_FirstType&& __first, _SecondType&& __second) {
+    return __libcpp_pair<__uncvref_t<_FirstType>, __uncvref_t<_SecondType> >(
+        std::forward<_FirstType>(__first), std::forward<_SecondType>(__second));
+}
+
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___UTILITY_PAIR_H

libcxx/include/module.modulemap.in

module __algorithm {
       module inplace_merge                   { private header "__algorithm/inplace_merge.h" }
       module is_heap                         { private header "__algorithm/is_heap.h" }
       module is_heap_until                   { private header "__algorithm/is_heap_until.h" }
       module is_partitioned                  { private header "__algorithm/is_partitioned.h" }
       module is_permutation                  { private header "__algorithm/is_permutation.h" }
       module is_sorted                       { private header "__algorithm/is_sorted.h" }
       module is_sorted_until                 { private header "__algorithm/is_sorted_until.h" }
       module iter_swap                       { private header "__algorithm/iter_swap.h" }
-      module iterator_operations             { private header "__algorithm/iterator_operations.h" }
+      module iterator_operations             {
+        private header "__algorithm/iterator_operations.h"
+        export *
+      }
       module lexicographical_compare         { private header "__algorithm/lexicographical_compare.h" }
       module lower_bound                     { private header "__algorithm/lower_bound.h" }
       module make_heap                       { private header "__algorithm/make_heap.h" }
       module make_projected                  { private header "__algorithm/make_projected.h" }
       module max                             { private header "__algorithm/max.h" }
       module max_element                     { private header "__algorithm/max_element.h" }
       module merge                           { private header "__algorithm/merge.h" }
       module min                             { private header "__algorithm/min.h" }

libcxx/test/std/algorithms/ranges_robust_against_dangling.pass.cpp

 // <algorithm>
 //
 // Range algorithms should return `std::ranges::dangling` when given a dangling range.
 
 #include <algorithm>
 
 #include <array>
 #include <concepts>
+#include <functional>
 #include <iterator>
 #include <ranges>
 #include <random>
 
 #include "test_iterators.h"
 
 struct NonBorrowedRange {
   using Iter = int*;