[libcxx] Add _LIBCPP_NODEBUG to global std::ranges::__cpo variables

[Michael137]

Summary

The motivation is to avoid cluttering LLDB's global variable view for
std::ranges users.

Before:

(lldb) frame var -g
...
(const std::ranges::__end::__fn) std::__1::ranges::__cpo::end = {}
(const std::ranges::views::__all::__fn) std::__1::ranges::views::__cpo::all = {}
(const std::ranges::__begin::__fn) std::__1::ranges::__cpo::begin = {}
(const std::ranges::views::__take::__fn) std::__1::ranges::views::__cpo::take = {}
(const std::ranges::__max_element::__fn) std::__1::ranges::__cpo::max_element = {}
(const std::ranges::__size::__fn) std::__1::ranges::__cpo::size = {}
(const std::ranges::__data::__fn) std::__1::ranges::__cpo::data = {}

After this patch none of these __cpo variables would show, since no
debug info is available.

[aprantl]

Just double-checking: This doesn't affect LLDB's ability to use range expressions in the expression evaluator, right?

[Michael137]

In D142993#4094284, @aprantl wrote:

Just double-checking: This doesn't affect LLDB's ability to use range expressions in the expression evaluator, right?

Fair point, looks like evaluating ranges expressions currently doesn't quite work. Once that's fixed will check how this patch affects expression evaluation

[ldionne]

This LGTM since it makes the status quo better. I would suggest we make this change right now, and if we need to use a different approach to fix the expression evaluator in the future, then we can cross that bridge when we get to it. But as far as we're concerned right now, this seems to be a pure improvement over the status quo.

Can you please rebase onto main? Once this is merged, we will also want to cherry-pick onto release/16.x.

[Michael137]

In D142993#4159548, @ldionne wrote:

This LGTM since it makes the status quo better. I would suggest we make this change right now, and if we need to use a different approach to fix the expression evaluator in the future, then we can cross that bridge when we get to it. But as far as we're concerned right now, this seems to be a pure improvement over the status quo.

Can you please rebase onto main? Once this is merged, we will also want to cherry-pick onto release/16.x.

@ldionne Thanks for the review

Just to clarify, if we want to get expression evaluation to work we will have to remove these attributes again, since calling these function objects requires debug-info for these variables to be present. But that feature will take some time to complete and is unlikely to make it into this release. So if we're fine with the churn for the immediate benefit then I'll go ahead and land this

[ldionne]

In D142993#4161082, @Michael137 wrote:

Just to clarify, if we want to get expression evaluation to work we will have to remove these attributes again, since calling these function objects requires debug-info for these variables to be present. But that feature will take some time to complete and is unlikely to make it into this release. So if we're fine with the churn for the immediate benefit then I'll go ahead and land this

I am fine with that. I imagine we'll need to add something else to those variables to tell LLDB not to show them in the globals view?

[Michael137]

In D142993#4165116, @ldionne wrote:

In D142993#4161082, @Michael137 wrote:

Just to clarify, if we want to get expression evaluation to work we will have to remove these attributes again, since calling these function objects requires debug-info for these variables to be present. But that feature will take some time to complete and is unlikely to make it into this release. So if we're fine with the churn for the immediate benefit then I'll go ahead and land this

I am fine with that. I imagine we'll need to add something else to those variables to tell LLDB not to show them in the globals view?

Actually we decided to just purely handle this in the debugger, in order to not break expression evaluation

Workaround is here: https://reviews.llvm.org/D145245

[ldionne]

[Github PR transition cleanup]

If we're not doing this in libc++, can we abandon this review?

[Michael137]

We worked around this in xcode

libcxx/include/__algorithm/ranges_copy.h

struct __fn {
   copy_result<borrowed_iterator_t<_Range>, _OutIter> operator()(_Range&& __r, _OutIter __result) const {
     auto __ret = std::__copy<_RangeAlgPolicy>(ranges::begin(__r), ranges::end(__r), std::move(__result));
     return {std::move(__ret.first), std::move(__ret.second)};
   }
 };
 } // namespace __copy
 
 inline namespace __cpo {
-  inline constexpr auto copy = __copy::__fn{};
+_LIBCPP_NODEBUG inline constexpr auto copy = __copy::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER > 17
 
 #endif // _LIBCPP___ALGORITHM_RANGES_COPY_H

libcxx/include/__algorithm/ranges_copy_if.h

struct __fn {
   copy_if_result<borrowed_iterator_t<_Range>, _OutIter>
   operator()(_Range&& __r, _OutIter __result, _Pred __pred, _Proj __proj = {}) const {
     return __copy_if_impl(ranges::begin(__r), ranges::end(__r), std::move(__result), __pred, __proj);
   }
 };
 } // namespace __copy_if
 
 inline namespace __cpo {
-  inline constexpr auto copy_if = __copy_if::__fn{};
+_LIBCPP_NODEBUG inline constexpr auto copy_if = __copy_if::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER > 17
 
 #endif // _LIBCPP___ALGORITHM_RANGES_COPY_IF_H

libcxx/include/__algorithm/ranges_find_if_not.h

struct __fn {
   borrowed_iterator_t<_Rp> operator()(_Rp&& __r, _Pred __pred, _Proj __proj = {}) const {
     auto __pred2 = [&](auto&& __e) { return !std::invoke(__pred, std::forward<decltype(__e)>(__e)); };
     return ranges::__find_if_impl(ranges::begin(__r), ranges::end(__r), __pred2, __proj);
   }
 };
 } // namespace __find_if_not
 
 inline namespace __cpo {
-  inline constexpr auto find_if_not = __find_if_not::__fn{};
+_LIBCPP_NODEBUG inline constexpr auto find_if_not = __find_if_not::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER > 17
 
 #endif // _LIBCPP___ALGORITHM_RANGES_FIND_IF_NOT_H

libcxx/include/__algorithm/ranges_for_each.h

for_each_result<borrowed_iterator_t<_Range>, _Func> operator()(_Range&& __range,
                                                                  _Proj __proj = {}) const {
     return __for_each_impl(ranges::begin(__range), ranges::end(__range), __func, __proj);
   }
 
 };
 } // namespace __for_each
 
 inline namespace __cpo {
-  inline constexpr auto for_each = __for_each::__fn{};
+_LIBCPP_NODEBUG inline constexpr auto for_each = __for_each::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER > 17
 
 #endif // _LIBCPP___ALGORITHM_RANGES_FOR_EACH_H

libcxx/include/__algorithm/ranges_generate_n.h

_OutIter operator()(_OutIter __first, iter_difference_t<_OutIter> __n, _Func __gen) const {
     return __first;
   }
 
 };
 
 } // namespace __generate_n
 
 inline namespace __cpo {
-  inline constexpr auto generate_n = __generate_n::__fn{};
+_LIBCPP_NODEBUG inline constexpr auto generate_n = __generate_n::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER > 17
 
 #endif // _LIBCPP___ALGORITHM_RANGES_GENERATE_N_H

libcxx/include/__algorithm/ranges_make_heap.h

struct __fn {
   borrowed_iterator_t<_Range> operator()(_Range&& __r, _Comp __comp = {}, _Proj __proj = {}) const {
     return __make_heap_fn_impl(ranges::begin(__r), ranges::end(__r), __comp, __proj);
   }
 };
 
 } // namespace __make_heap
 
 inline namespace __cpo {
-  inline constexpr auto make_heap = __make_heap::__fn{};
+_LIBCPP_NODEBUG inline constexpr auto make_heap = __make_heap::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER > 17
 
 #endif // _LIBCPP___ALGORITHM_RANGES_MAKE_HEAP_H

libcxx/include/__algorithm/ranges_max_element.h

struct __fn {
   borrowed_iterator_t<_Rp> operator()(_Rp&& __r, _Comp __comp = {}, _Proj __proj = {}) const {
     auto __comp_lhs_rhs_swapped = [&](auto&& __lhs, auto&& __rhs) { return std::invoke(__comp, __rhs, __lhs); };
     return ranges::__min_element_impl(ranges::begin(__r), ranges::end(__r), __comp_lhs_rhs_swapped, __proj);
   }
 };
 } // namespace __max_element
 
 inline namespace __cpo {
-  inline constexpr auto max_element = __max_element::__fn{};
+_LIBCPP_NODEBUG inline constexpr auto max_element = __max_element::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER > 17
 
 #endif // _LIBCPP___ALGORITHM_RANGES_MAX_ELEMENT_H

libcxx/include/__algorithm/ranges_minmax.h

if constexpr (forward_range<_Range>) {
       }
       return __result;
     }
   }
 };
 } // namespace __minmax
 
 inline namespace __cpo {
-  inline constexpr auto minmax = __minmax::__fn{};
+_LIBCPP_NODEBUG inline constexpr auto minmax = __minmax::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP_STD_VER > 17
 
 #endif // _LIBCPP___ALGORITHM_RANGES_MINMAX_H

libcxx/include/__algorithm/ranges_minmax_element.h

struct __fn {
   operator()(_Rp&& __r, _Comp __comp = {}, _Proj __proj = {}) const {
     auto __ret = std::__minmax_element_impl(ranges::begin(__r), ranges::end(__r), __comp, __proj);
     return {__ret.first, __ret.second};
   }
 };
 } // namespace __minmax_element
 
 inline namespace __cpo {
-  inline constexpr auto minmax_element = __minmax_element::__fn{};
+_LIBCPP_NODEBUG inline constexpr auto minmax_element = __minmax_element::__fn{};
 } // namespace __cpo
 
 } // namespace ranges
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER > 17
 
 #endif // _LIBCPP___ALGORITHM_RANGES_MINMAX_H

libcxx/include/__algorithm/ranges_mismatch.h

struct __fn {
   operator()(_R1&& __r1, _R2&& __r2, _Pred __pred = {}, _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const {
     return __go(ranges::begin(__r1), ranges::end(__r1), ranges::begin(__r2), ranges::end(__r2),
                 __pred, __proj1, __proj2);
   }
 };
 } // namespace __mismatch
 
 inline namespace __cpo {
-  constexpr inline auto mismatch = __mismatch::__fn{};
+_LIBCPP_NODEBUG constexpr inline auto mismatch = __mismatch::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
 #endif // _LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___ALGORITHM_RANGES_MISMATCH_H

libcxx/include/__algorithm/ranges_move.h

struct __fn {
   move_result<borrowed_iterator_t<_Range>, _OutIter> operator()(_Range&& __range, _OutIter __result) const {
     return __move_impl(ranges::begin(__range), ranges::end(__range), std::move(__result));
   }
 
 };
 } // namespace __move
 
 inline namespace __cpo {
-  inline constexpr auto move = __move::__fn{};
+_LIBCPP_NODEBUG inline constexpr auto move = __move::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER > 17
 
 #endif // _LIBCPP___ALGORITHM_RANGES_MOVE_H

libcxx/include/__algorithm/ranges_reverse.h

struct __fn {
   borrowed_iterator_t<_Range> operator()(_Range&& __range) const {
     return (*this)(ranges::begin(__range), ranges::end(__range));
   }
 
 };
 } // namespace __reverse
 
 inline namespace __cpo {
-  inline constexpr auto reverse = __reverse::__fn{};
+_LIBCPP_NODEBUG inline constexpr auto reverse = __reverse::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER > 17
 
 #endif // _LIBCPP___ALGORITHM_RANGES_REVERSE_H

libcxx/include/__algorithm/ranges_rotate_copy.h

struct __fn {
   operator()(_Range&& __range, iterator_t<_Range> __middle, _OutIter __result) const {
     return (*this)(ranges::begin(__range), std::move(__middle), ranges::end(__range), std::move(__result));
   }
 
 };
 } // namespace __rotate_copy
 
 inline namespace __cpo {
-  inline constexpr auto rotate_copy = __rotate_copy::__fn{};
+_LIBCPP_NODEBUG inline constexpr auto rotate_copy = __rotate_copy::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER > 17
 
 #endif // _LIBCPP___ALGORITHM_RANGES_ROTATE_COPY_H

libcxx/include/__algorithm/ranges_sort.h

struct __fn {
   borrowed_iterator_t<_Range> operator()(_Range&& __r, _Comp __comp = {}, _Proj __proj = {}) const {
     return __sort_fn_impl(ranges::begin(__r), ranges::end(__r), __comp, __proj);
   }
 };
 
 } // namespace __sort
 
 inline namespace __cpo {
-  inline constexpr auto sort = __sort::__fn{};
+_LIBCPP_NODEBUG inline constexpr auto sort = __sort::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER > 17
 
 #endif // _LIBCPP___ALGORITHM_RANGES_SORT_H

libcxx/include/__compare/compare_partial_order_fallback.h

struct __fn {
         _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t, _Up&& __u) const
             noexcept(noexcept(__go(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u), __priority_tag<1>())))
             -> decltype(      __go(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u), __priority_tag<1>()))
             { return          __go(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u), __priority_tag<1>()); }
     };
 } // namespace __compare_partial_order_fallback
 
 inline namespace __cpo {
-    inline constexpr auto compare_partial_order_fallback = __compare_partial_order_fallback::__fn{};
+_LIBCPP_NODEBUG inline constexpr auto compare_partial_order_fallback = __compare_partial_order_fallback::__fn{};
 } // namespace __cpo
 
 #endif // _LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___COMPARE_COMPARE_PARTIAL_ORDER_FALLBACK

libcxx/include/__compare/compare_strong_order_fallback.h

struct __fn {
         _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t, _Up&& __u) const
             noexcept(noexcept(__go(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u), __priority_tag<1>())))
             -> decltype(      __go(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u), __priority_tag<1>()))
             { return          __go(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u), __priority_tag<1>()); }
     };
 } // namespace __compare_strong_order_fallback
 
 inline namespace __cpo {
-    inline constexpr auto compare_strong_order_fallback = __compare_strong_order_fallback::__fn{};
+_LIBCPP_NODEBUG inline constexpr auto compare_strong_order_fallback = __compare_strong_order_fallback::__fn{};
 } // namespace __cpo
 
 #endif // _LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___COMPARE_COMPARE_STRONG_ORDER_FALLBACK

libcxx/include/__compare/compare_weak_order_fallback.h

struct __fn {
         _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t, _Up&& __u) const
             noexcept(noexcept(__go(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u), __priority_tag<1>())))
             -> decltype(      __go(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u), __priority_tag<1>()))
             { return          __go(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u), __priority_tag<1>()); }
     };
 } // namespace __compare_weak_order_fallback
 
 inline namespace __cpo {
-    inline constexpr auto compare_weak_order_fallback = __compare_weak_order_fallback::__fn{};
+_LIBCPP_NODEBUG inline constexpr auto compare_weak_order_fallback = __compare_weak_order_fallback::__fn{};
 } // namespace __cpo
 
 #endif // _LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___COMPARE_COMPARE_WEAK_ORDER_FALLBACK

libcxx/include/__compare/partial_order.h

// NOLINTEND(libcpp-robust-against-adl)
         _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t, _Up&& __u) const
             noexcept(noexcept(__go(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u), __priority_tag<2>())))
             -> decltype(      __go(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u), __priority_tag<2>()))
             { return          __go(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u), __priority_tag<2>()); }
     };
 } // namespace __partial_order
 
 inline namespace __cpo {
-    inline constexpr auto partial_order = __partial_order::__fn{};
+_LIBCPP_NODEBUG inline constexpr auto partial_order = __partial_order::__fn{};
 } // namespace __cpo
 
 #endif // _LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___COMPARE_PARTIAL_ORDER

libcxx/include/__compare/strong_order.h

// NOLINTEND(libcpp-robust-against-adl)
         _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t, _Up&& __u) const
             noexcept(noexcept(__go(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u), __priority_tag<2>())))
             -> decltype(      __go(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u), __priority_tag<2>()))
             { return          __go(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u), __priority_tag<2>()); }
     };
 } // namespace __strong_order
 
 inline namespace __cpo {
-    inline constexpr auto strong_order = __strong_order::__fn{};
+_LIBCPP_NODEBUG inline constexpr auto strong_order = __strong_order::__fn{};
 } // namespace __cpo
 
 #endif // _LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP___COMPARE_STRONG_ORDER

libcxx/include/__compare/weak_order.h

// NOLINTEND(libcpp-robust-against-adl)
         _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t, _Up&& __u) const
             noexcept(noexcept(__go(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u), __priority_tag<3>())))
             -> decltype(      __go(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u), __priority_tag<3>()))
             { return          __go(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u), __priority_tag<3>()); }
     };
 } // namespace __weak_order
 
 inline namespace __cpo {
-    inline constexpr auto weak_order = __weak_order::__fn{};
+_LIBCPP_NODEBUG inline constexpr auto weak_order = __weak_order::__fn{};
 } // namespace __cpo
 
 #endif // _LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___COMPARE_WEAK_ORDER

libcxx/include/__concepts/swappable.h

constexpr void operator()(_Tp& __x, _Tp& __y) const
       noexcept(is_nothrow_move_constructible_v<_Tp> && is_nothrow_move_assignable_v<_Tp>)
     {
       __y = _VSTD::exchange(__x, _VSTD::move(__y));
     }
   };
 } // namespace __swap
 
 inline namespace __cpo {
-  inline constexpr auto swap = __swap::__fn{};
+_LIBCPP_NODEBUG inline constexpr auto swap = __swap::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
 template<class _Tp>
 concept swappable = requires(_Tp& __a, _Tp& __b) { ranges::swap(__a, __b); };
 
 template<class _Tp, class _Up>
 concept swappable_with =

libcxx/include/__iterator/advance.h

_LIBCPP_HIDE_FROM_ABI constexpr iter_difference_t<_Ip> operator()(_Ip& __i, iter_difference_t<_Ip> __n,
 
     __libcpp_unreachable();
   }
 };
 
 } // namespace __advance
 
 inline namespace __cpo {
-  inline constexpr auto advance = __advance::__fn{};
+_LIBCPP_NODEBUG inline constexpr auto advance = __advance::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
 #endif // _LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___ITERATOR_ADVANCE_H

libcxx/include/__iterator/distance.h

if constexpr (sized_range<_Rp>) {
       return operator()(ranges::begin(__r), ranges::end(__r));
     }
   }
 };
 
 } // namespace __distance
 
 inline namespace __cpo {
-  inline constexpr auto distance = __distance::__fn{};
+_LIBCPP_NODEBUG inline constexpr auto distance = __distance::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
 #endif // _LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___ITERATOR_DISTANCE_H

libcxx/include/__iterator/iter_move.h

struct __fn {
   [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Ip&& __i) const
     noexcept(noexcept(*std::forward<_Ip>(__i)))
     -> decltype(      *std::forward<_Ip>(__i))
     { return          *std::forward<_Ip>(__i); }
 };
 } // namespace __iter_move
 
 inline namespace __cpo {
-  inline constexpr auto iter_move = __iter_move::__fn{};
+_LIBCPP_NODEBUG inline constexpr auto iter_move = __iter_move::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
 template<__dereferenceable _Tp>
   requires requires(_Tp& __t) { { ranges::iter_move(__t) } -> __can_reference; }
 using iter_rvalue_reference_t = decltype(ranges::iter_move(std::declval<_Tp&>()));
 
 #endif // _LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___ITERATOR_ITER_MOVE_H

libcxx/include/__iterator/iter_swap.h

constexpr void operator()(_T1&& __x, _T2&& __y) const
       iter_value_t<_T2> __old(ranges::iter_move(__y));
       *__y = ranges::iter_move(__x);
       *_VSTD::forward<_T1>(__x) = _VSTD::move(__old);
     }
   };
 } // namespace __iter_swap
 
 inline namespace __cpo {
-  inline constexpr auto iter_swap = __iter_swap::__fn{};
+_LIBCPP_NODEBUG inline constexpr auto iter_swap = __iter_swap::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
 template<class _I1, class _I2 = _I1>
 concept indirectly_swappable =
   indirectly_readable<_I1> && indirectly_readable<_I2> &&
   requires(const _I1 __i1, const _I2 __i2) {
     ranges::iter_swap(__i1, __i1);

libcxx/include/__iterator/next.h

_LIBCPP_HIDE_FROM_ABI constexpr _Ip operator()(_Ip __x, iter_difference_t<_Ip> __n, _Sp __bound_sentinel) const {
     ranges::advance(__x, __n, __bound_sentinel);
     return __x;
   }
 };
 
 } // namespace __next
 
 inline namespace __cpo {
-  inline constexpr auto next = __next::__fn{};
+_LIBCPP_NODEBUG inline constexpr auto next = __next::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
 #endif // _LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___ITERATOR_NEXT_H

libcxx/include/__iterator/prev.h

_LIBCPP_HIDE_FROM_ABI constexpr _Ip operator()(_Ip __x, iter_difference_t<_Ip> __n, _Ip __bound_iter) const {
     ranges::advance(__x, -__n, __bound_iter);
     return __x;
   }
 };
 
 } // namespace __prev
 
 inline namespace __cpo {
-  inline constexpr auto prev = __prev::__fn{};
+_LIBCPP_NODEBUG inline constexpr auto prev = __prev::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
 #endif // _LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___ITERATOR_PREV_H

libcxx/include/__memory/ranges_construct_at.h

struct __fn {
   constexpr _Tp* operator()(_Tp* __location, _Args&& ...__args) const {
     return _VSTD::construct_at(__location, _VSTD::forward<_Args>(__args)...);
   }
 };
 
 } // namespace __construct_at
 
 inline namespace __cpo {
-  inline constexpr auto construct_at = __construct_at::__fn{};
+_LIBCPP_NODEBUG inline constexpr auto construct_at = __construct_at::__fn{};
 } // namespace __cpo
 
 // destroy_at
 
 namespace __destroy_at {
 
 struct __fn {
   template <destructible _Tp>
   _LIBCPP_HIDE_FROM_ABI
   constexpr void operator()(_Tp* __location) const noexcept {
     _VSTD::destroy_at(__location);
   }
 };
 
 } // namespace __destroy_at
 
 inline namespace __cpo {
-  inline constexpr auto destroy_at = __destroy_at::__fn{};
+_LIBCPP_NODEBUG inline constexpr auto destroy_at = __destroy_at::__fn{};
 } // namespace __cpo
 
 // destroy
 
 namespace __destroy {
 
 struct __fn {
   template <__nothrow_input_iterator _InputIterator, __nothrow_sentinel_for<_InputIterator> _Sentinel>
struct __fn {
   constexpr borrowed_iterator_t<_InputRange> operator()(_InputRange&& __range) const noexcept {
     return (*this)(ranges::begin(__range), ranges::end(__range));
   }
 };
 
 } // namespace __destroy
 
 inline namespace __cpo {
-  inline constexpr auto destroy = __destroy::__fn{};
+_LIBCPP_NODEBUG inline constexpr auto destroy = __destroy::__fn{};
 } // namespace __cpo
 
 // destroy_n
 
 namespace __destroy_n {
 
 struct __fn {
   template <__nothrow_input_iterator _InputIterator>
     requires destructible<iter_value_t<_InputIterator>>
   _LIBCPP_HIDE_FROM_ABI
   constexpr _InputIterator operator()(_InputIterator __first, iter_difference_t<_InputIterator> __n) const noexcept {
     return _VSTD::destroy_n(_VSTD::move(__first), __n);
   }
 };
 
 } // namespace __destroy_n
 
 inline namespace __cpo {
-  inline constexpr auto destroy_n = __destroy_n::__fn{};
+_LIBCPP_NODEBUG inline constexpr auto destroy_n = __destroy_n::__fn{};
 } // namespace __cpo
 
 } // namespace ranges
 
 #endif // _LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___MEMORY_RANGES_CONSTRUCT_AT_H

libcxx/include/__memory/ranges_uninitialized_algorithms.h

struct __fn {
   borrowed_iterator_t<_ForwardRange> operator()(_ForwardRange&& __range) const {
     return (*this)(ranges::begin(__range), ranges::end(__range));
   }
 };
 
 } // namespace __uninitialized_default_construct
 
 inline namespace __cpo {
-  inline constexpr auto uninitialized_default_construct = __uninitialized_default_construct::__fn{};
+  _LIBCPP_NODEBUG inline constexpr auto uninitialized_default_construct = __uninitialized_default_construct::__fn{};
 } // namespace __cpo
 
 // uninitialized_default_construct_n
 
 namespace __uninitialized_default_construct_n {
 
 struct __fn {
   template <__nothrow_forward_iterator _ForwardIterator>
     requires default_initializable<iter_value_t<_ForwardIterator>>
   _ForwardIterator operator()(_ForwardIterator __first,
                               iter_difference_t<_ForwardIterator> __n) const {
     using _ValueType = remove_reference_t<iter_reference_t<_ForwardIterator>>;
     return _VSTD::__uninitialized_default_construct_n<_ValueType>(_VSTD::move(__first), __n);
   }
 };
 
 } // namespace __uninitialized_default_construct_n
 
 inline namespace __cpo {
-  inline constexpr auto uninitialized_default_construct_n = __uninitialized_default_construct_n::__fn{};
+  _LIBCPP_NODEBUG inline constexpr auto uninitialized_default_construct_n = __uninitialized_default_construct_n::__fn{};
 } // namespace __cpo
 
 // uninitialized_value_construct
 
 namespace __uninitialized_value_construct {
 
 struct __fn {
   template <__nothrow_forward_iterator _ForwardIterator,
struct __fn {
   borrowed_iterator_t<_ForwardRange> operator()(_ForwardRange&& __range) const {
     return (*this)(ranges::begin(__range), ranges::end(__range));
   }
 };
 
 } // namespace __uninitialized_value_construct
 
 inline namespace __cpo {
-  inline constexpr auto uninitialized_value_construct = __uninitialized_value_construct::__fn{};
+  _LIBCPP_NODEBUG inline constexpr auto uninitialized_value_construct = __uninitialized_value_construct::__fn{};
 } // namespace __cpo
 
 // uninitialized_value_construct_n
 
 namespace __uninitialized_value_construct_n {
 
 struct __fn {
   template <__nothrow_forward_iterator _ForwardIterator>
     requires default_initializable<iter_value_t<_ForwardIterator>>
   _ForwardIterator operator()(_ForwardIterator __first,
                               iter_difference_t<_ForwardIterator> __n) const {
     using _ValueType = remove_reference_t<iter_reference_t<_ForwardIterator>>;
     return _VSTD::__uninitialized_value_construct_n<_ValueType>(_VSTD::move(__first), __n);
   }
 };
 
 } // namespace __uninitialized_value_construct_n
 
 inline namespace __cpo {
-  inline constexpr auto uninitialized_value_construct_n = __uninitialized_value_construct_n::__fn{};
+  _LIBCPP_NODEBUG inline constexpr auto uninitialized_value_construct_n = __uninitialized_value_construct_n::__fn{};
 } // namespace __cpo
 
 // uninitialized_fill
 
 namespace __uninitialized_fill {
 
 struct __fn {
   template <__nothrow_forward_iterator _ForwardIterator,
struct __fn {
   borrowed_iterator_t<_ForwardRange> operator()(_ForwardRange&& __range, const _Tp& __x) const {
     return (*this)(ranges::begin(__range), ranges::end(__range), __x);
   }
 };
 
 } // namespace __uninitialized_fill
 
 inline namespace __cpo {
-  inline constexpr auto uninitialized_fill = __uninitialized_fill::__fn{};
+  _LIBCPP_NODEBUG inline constexpr auto uninitialized_fill = __uninitialized_fill::__fn{};
 } // namespace __cpo
 
 // uninitialized_fill_n
 
 namespace __uninitialized_fill_n {
 
 struct __fn {
   template <__nothrow_forward_iterator _ForwardIterator, class _Tp>
     requires constructible_from<iter_value_t<_ForwardIterator>, const _Tp&>
   _ForwardIterator operator()(_ForwardIterator __first,
                               iter_difference_t<_ForwardIterator> __n,
                               const _Tp& __x) const {
     using _ValueType = remove_reference_t<iter_reference_t<_ForwardIterator>>;
     return _VSTD::__uninitialized_fill_n<_ValueType>(_VSTD::move(__first), __n, __x);
   }
 };
 
 } // namespace __uninitialized_fill_n
 
 inline namespace __cpo {
-  inline constexpr auto uninitialized_fill_n = __uninitialized_fill_n::__fn{};
+  _LIBCPP_NODEBUG inline constexpr auto uninitialized_fill_n = __uninitialized_fill_n::__fn{};
 } // namespace __cpo
 
 // uninitialized_copy
 
 template <class _InputIterator, class _OutputIterator>
 using uninitialized_copy_result = in_out_result<_InputIterator, _OutputIterator>;
 
 namespace __uninitialized_copy {
operator()( _InputRange&& __in_range, _OutputRange&& __out_range) const {
     return (*this)(ranges::begin(__in_range), ranges::end(__in_range),
                    ranges::begin(__out_range), ranges::end(__out_range));
   }
 };
 
 } // namespace __uninitialized_copy
 
 inline namespace __cpo {
-  inline constexpr auto uninitialized_copy = __uninitialized_copy::__fn{};
+  _LIBCPP_NODEBUG inline constexpr auto uninitialized_copy = __uninitialized_copy::__fn{};
 } // namespace __cpo
 
 // uninitialized_copy_n
 
 template <class _InputIterator, class _OutputIterator>
 using uninitialized_copy_n_result = in_out_result<_InputIterator, _OutputIterator>;
 
 namespace __uninitialized_copy_n {
auto __result = _VSTD::__uninitialized_copy_n<_ValueType>(_VSTD::move(__ifirst), __n,
                                                               _VSTD::move(__ofirst), _VSTD::move(__olast));
     return {_VSTD::move(__result.first), _VSTD::move(__result.second)};
   }
 };
 
 } // namespace __uninitialized_copy_n
 
 inline namespace __cpo {
-  inline constexpr auto uninitialized_copy_n = __uninitialized_copy_n::__fn{};
+  _LIBCPP_NODEBUG inline constexpr auto uninitialized_copy_n = __uninitialized_copy_n::__fn{};
 } // namespace __cpo
 
 // uninitialized_move
 
 template <class _InputIterator, class _OutputIterator>
 using uninitialized_move_result = in_out_result<_InputIterator, _OutputIterator>;
 
 namespace __uninitialized_move {
operator()(_InputRange&& __in_range, _OutputRange&& __out_range) const {
     return (*this)(ranges::begin(__in_range), ranges::end(__in_range),
                    ranges::begin(__out_range), ranges::end(__out_range));
   }
 };
 
 } // namespace __uninitialized_move
 
 inline namespace __cpo {
-  inline constexpr auto uninitialized_move = __uninitialized_move::__fn{};
+  _LIBCPP_NODEBUG inline constexpr auto uninitialized_move = __uninitialized_move::__fn{};
 } // namespace __cpo
 
 // uninitialized_move_n
 
 template <class _InputIterator, class _OutputIterator>
 using uninitialized_move_n_result = in_out_result<_InputIterator, _OutputIterator>;
 
 namespace __uninitialized_move_n {
auto __result = _VSTD::__uninitialized_move_n<_ValueType>(_VSTD::move(__ifirst), __n,
                                                               _VSTD::move(__ofirst), _VSTD::move(__olast), __iter_move);
     return {_VSTD::move(__result.first), _VSTD::move(__result.second)};
   }
 };
 
 } // namespace __uninitialized_move_n
 
 inline namespace __cpo {
-  inline constexpr auto uninitialized_move_n = __uninitialized_move_n::__fn{};
+  _LIBCPP_NODEBUG inline constexpr auto uninitialized_move_n = __uninitialized_move_n::__fn{};
 } // namespace __cpo
 
 } // namespace ranges
 
 #endif // _LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___MEMORY_RANGES_UNINITIALIZED_ALGORITHMS_H

libcxx/include/__ranges/access.h

[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
       return _LIBCPP_AUTO_CAST(begin(__t));
     }
 
     void operator()(auto&&) const = delete;
   };
 } // namespace __begin
 
 inline namespace __cpo {
-  inline constexpr auto begin = __begin::__fn{};
+_LIBCPP_NODEBUG inline constexpr auto begin = __begin::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
 // [range.range]
 
 namespace ranges {
   template <class _Tp>
   using iterator_t = decltype(ranges::begin(std::declval<_Tp&>()));
[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
       return _LIBCPP_AUTO_CAST(end(__t));
     }
 
     void operator()(auto&&) const = delete;
   };
 } // namespace __end
 
 inline namespace __cpo {
-  inline constexpr auto end = __end::__fn{};
+_LIBCPP_NODEBUG inline constexpr auto end = __end::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
 // [range.access.cbegin]
 
 namespace ranges {
 namespace __cbegin {
   struct __fn {
struct __fn {
     constexpr auto operator()(_Tp&& __t) const
       noexcept(noexcept(ranges::begin(static_cast<const _Tp&&>(__t))))
       -> decltype(      ranges::begin(static_cast<const _Tp&&>(__t)))
       { return          ranges::begin(static_cast<const _Tp&&>(__t)); }
   };
 } // namespace __cbegin
 
 inline namespace __cpo {
-  inline constexpr auto cbegin = __cbegin::__fn{};
+_LIBCPP_NODEBUG inline constexpr auto cbegin = __cbegin::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
 // [range.access.cend]
 
 namespace ranges {
 namespace __cend {
   struct __fn {
struct __fn {
     constexpr auto operator()(_Tp&& __t) const
       noexcept(noexcept(ranges::end(static_cast<const _Tp&&>(__t))))
       -> decltype(      ranges::end(static_cast<const _Tp&&>(__t)))
       { return          ranges::end(static_cast<const _Tp&&>(__t)); }
   };
 } // namespace __cend
 
 inline namespace __cpo {
-  inline constexpr auto cend = __cend::__fn{};
+_LIBCPP_NODEBUG inline constexpr auto cend = __cend::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
 #endif // _LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___RANGES_ACCESS_H

libcxx/include/__ranges/all.h

constexpr auto operator()(_Tp&& __t) const
       noexcept(noexcept(ranges::owning_view{std::forward<_Tp>(__t)}))
     {
       return ranges::owning_view{std::forward<_Tp>(__t)};
     }
   };
 } // namespace __all
 
 inline namespace __cpo {
-  inline constexpr auto all = __all::__fn{};
+_LIBCPP_NODEBUG inline constexpr auto all = __all::__fn{};
 } // namespace __cpo
 
 template<ranges::viewable_range _Range>
 using all_t = decltype(views::all(std::declval<_Range>()));
 
 } // namespace ranges::views
 
 #endif // _LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___RANGES_ALL_H

libcxx/include/__ranges/as_rvalue_view.h

_LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Range&& __range) const
       noexcept(noexcept(/**/ views::all(std::forward<_Range>(__range))))
           -> decltype(/*--*/ views::all(std::forward<_Range>(__range))) {
     return /*-------------*/ views::all(std::forward<_Range>(__range));
   }
 };
 } // namespace __as_rvalue
 
 inline namespace __cpo {
-constexpr auto as_rvalue = __as_rvalue::__fn{};
+_LIBCPP_NODEBUG constexpr auto as_rvalue = __as_rvalue::__fn{};
 } // namespace __cpo
 } // namespace views
 } // namespace ranges
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 23
 
 #endif // _LIBCPP___RANGES_AS_RVALUE_H

libcxx/include/__ranges/common_view.h

struct __fn : __range_adaptor_closure<__fn> {
     constexpr auto operator()(_Range&& __range) const
       noexcept(noexcept(common_view{std::forward<_Range>(__range)}))
       -> decltype(      common_view{std::forward<_Range>(__range)})
       { return          common_view{std::forward<_Range>(__range)}; }
   };
 } // namespace __common
 
 inline namespace __cpo {
-  inline constexpr auto common = __common::__fn{};
+_LIBCPP_NODEBUG inline constexpr auto common = __common::__fn{};
 } // namespace __cpo
 } // namespace views
 } // namespace ranges
 
 #endif // _LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___RANGES_COMMON_VIEW_H

libcxx/include/__ranges/counted.h

constexpr auto operator()(_It&& __it, _Diff&& __count) const
       noexcept(noexcept(__go(std::forward<_It>(__it), std::forward<_Diff>(__count))))
       -> decltype(      __go(std::forward<_It>(__it), std::forward<_Diff>(__count)))
       { return          __go(std::forward<_It>(__it), std::forward<_Diff>(__count)); }
   };
 
 } // namespace __counted
 
 inline namespace __cpo {
-  inline constexpr auto counted = __counted::__fn{};
+_LIBCPP_NODEBUG inline constexpr auto counted = __counted::__fn{};
 } // namespace __cpo
 
 } // namespace ranges::views
 
 #endif // _LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___RANGES_COUNTED_H

libcxx/include/__ranges/data.h

struct __fn {
     constexpr auto operator()(_Tp&& __t) const
         noexcept(noexcept(std::to_address(ranges::begin(__t)))) {
       return std::to_address(ranges::begin(__t));
     }
   };
 } // namespace __data
 
 inline namespace __cpo {
-  inline constexpr auto data = __data::__fn{};
+_LIBCPP_NODEBUG inline constexpr auto data = __data::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
 // [range.prim.cdata]
 
 namespace ranges {
 namespace __cdata {
   struct __fn {
struct __fn {
     constexpr auto operator()(_Tp&& __t) const
       noexcept(noexcept(ranges::data(static_cast<const _Tp&&>(__t))))
       -> decltype(      ranges::data(static_cast<const _Tp&&>(__t)))
       { return          ranges::data(static_cast<const _Tp&&>(__t)); }
   };
 } // namespace __cdata
 
 inline namespace __cpo {
-  inline constexpr auto cdata = __cdata::__fn{};
+_LIBCPP_NODEBUG inline constexpr auto cdata = __cdata::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
 #endif // _LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___RANGES_DATA_H

libcxx/include/__ranges/drop_view.h

struct __fn {
   constexpr auto operator()(_Np&& __n) const
     noexcept(is_nothrow_constructible_v<decay_t<_Np>, _Np>)
   { return __range_adaptor_closure_t(std::__bind_back(*this, std::forward<_Np>(__n))); }
 };
 
 } // namespace __drop
 
 inline namespace __cpo {
-  inline constexpr auto drop = __drop::__fn{};
+  _LIBCPP_NODEBUG inline constexpr auto drop = __drop::__fn{};
 } // namespace __cpo
 } // namespace views
 
 } // namespace ranges
 
 #endif // _LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP___RANGES_DROP_VIEW_H

libcxx/include/__ranges/drop_while_view.h

[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Pred&& __pred) const
       noexcept(is_nothrow_constructible_v<decay_t<_Pred>, _Pred>) {
     return __range_adaptor_closure_t(std::__bind_back(*this, std::forward<_Pred>(__pred)));
   }
 };
 
 } // namespace __drop_while
 
 inline namespace __cpo {
-inline constexpr auto drop_while = __drop_while::__fn{};
+_LIBCPP_NODEBUG inline constexpr auto drop_while = __drop_while::__fn{};
 } // namespace __cpo
 } // namespace views
 } // namespace ranges
 
 #endif // _LIBCPP_STD_VER >= 20
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___RANGES_DROP_WHILE_VIEW_H

libcxx/include/__ranges/elements_view.h

[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Range&& __range) const
       /*------*/ -> decltype(elements_view<all_t<_Range&&>, _Np>(std::forward<_Range>(__range))) {
     /*-------------*/ return elements_view<all_t<_Range&&>, _Np>(std::forward<_Range>(__range));
   }
 };
 } // namespace __elements
 
 inline namespace __cpo {
 template <size_t _Np>
-inline constexpr auto elements = __elements::__fn<_Np>{};
-inline constexpr auto keys     = elements<0>;
-inline constexpr auto values   = elements<1>;
+_LIBCPP_NODEBUG inline constexpr auto elements = __elements::__fn<_Np>{};
+_LIBCPP_NODEBUG inline constexpr auto keys     = elements<0>;
+_LIBCPP_NODEBUG inline constexpr auto values   = elements<1>;
 } // namespace __cpo
 } // namespace views
 } // namespace ranges
 
 #endif // _LIBCPP_STD_VER >= 20
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___RANGES_ELEMENTS_VIEW_H

libcxx/include/__ranges/empty.h

struct __fn {
     [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool operator()(_Tp&& __t) const
         noexcept(noexcept(bool(ranges::begin(__t) == ranges::end(__t)))) {
       return ranges::begin(__t) == ranges::end(__t);
     }
   };
 } // namespace __empty
 
 inline namespace __cpo {
-  inline constexpr auto empty = __empty::__fn{};
+_LIBCPP_NODEBUG inline constexpr auto empty = __empty::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
 #endif // _LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___RANGES_EMPTY_H

libcxx/include/__ranges/filter_view.h

struct __fn {
     [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
     constexpr auto operator()(_Pred&& __pred) const
       noexcept(is_nothrow_constructible_v<decay_t<_Pred>, _Pred>)
     { return __range_adaptor_closure_t(std::__bind_back(*this, std::forward<_Pred>(__pred))); }
   };
 } // namespace __filter
 
 inline namespace __cpo {
-  inline constexpr auto filter = __filter::__fn{};
+_LIBCPP_NODEBUG inline constexpr auto filter = __filter::__fn{};
 } // namespace __cpo
 } // namespace views
 
 } // namespace ranges
 
 #endif // _LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___RANGES_FILTER_VIEW_H

libcxx/include/__ranges/iota_view.h

struct __fn {
     _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Start&& __start, _BoundSentinel&& __bound_sentinel) const
       noexcept(noexcept(ranges::iota_view(std::forward<_Start>(__start), std::forward<_BoundSentinel>(__bound_sentinel))))
       -> decltype(      ranges::iota_view(std::forward<_Start>(__start), std::forward<_BoundSentinel>(__bound_sentinel)))
       { return          ranges::iota_view(std::forward<_Start>(__start), std::forward<_BoundSentinel>(__bound_sentinel)); }
   };
 } // namespace __iota
 
 inline namespace __cpo {
-  inline constexpr auto iota = __iota::__fn{};
+  _LIBCPP_NODEBUG inline constexpr auto iota = __iota::__fn{};
 } // namespace __cpo
 } // namespace views
 } // namespace ranges
 
 #endif // _LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___RANGES_IOTA_VIEW_H

libcxx/include/__ranges/istream_view.h

_LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Up&& __u) const
     }
 };
 // clang-format on
 
 } // namespace __istream
 
 inline namespace __cpo {
 template <class _Tp>
-inline constexpr auto istream = __istream::__fn<_Tp>{};
+_LIBCPP_NODEBUG inline constexpr auto istream = __istream::__fn<_Tp>{};
 } // namespace __cpo
 } // namespace views
 
 } // namespace ranges
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
 #endif // _LIBCPP___RANGES_ISTREAM_VIEW_H

libcxx/include/__ranges/join_view.h

struct __fn : __range_adaptor_closure<__fn> {
   [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
   constexpr auto operator()(_Range&& __range) const
     noexcept(noexcept(join_view<all_t<_Range&&>>(std::forward<_Range>(__range))))
     -> decltype(      join_view<all_t<_Range&&>>(std::forward<_Range>(__range)))
     { return          join_view<all_t<_Range&&>>(std::forward<_Range>(__range)); }
 };
 } // namespace __join_view
 inline namespace __cpo {
-  inline constexpr auto join = __join_view::__fn{};
+  _LIBCPP_NODEBUG inline constexpr auto join = __join_view::__fn{};
 } // namespace __cpo
 } // namespace views
 } // namespace ranges
 
 template <class _View, bool _Const>
   requires(ranges::common_range<typename ranges::__join_view_iterator<_View, _Const>::_Parent> &&
            __is_cpp17_random_access_iterator<typename ranges::__join_view_iterator<_View, _Const>::_Outer>::value &&
            __is_cpp17_random_access_iterator<typename ranges::__join_view_iterator<_View, _Const>::_Inner>::value)

libcxx/include/__ranges/lazy_split_view.h

struct __fn : __range_adaptor_closure<__fn> {
   constexpr auto operator()(_Pattern&& __pattern) const
       noexcept(is_nothrow_constructible_v<decay_t<_Pattern>, _Pattern>) {
     return __range_adaptor_closure_t(std::__bind_back(*this, std::forward<_Pattern>(__pattern)));
   }
 };
 } // namespace __lazy_split_view
 
 inline namespace __cpo {
-  inline constexpr auto lazy_split = __lazy_split_view::__fn{};
+  _LIBCPP_NODEBUG inline constexpr auto lazy_split = __lazy_split_view::__fn{};
 } // namespace __cpo
 } // namespace views
 
 } // namespace ranges
 
 #endif // _LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___RANGES_LAZY_SPLIT_VIEW_H

libcxx/include/__ranges/rbegin.h

[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
     return std::make_reverse_iterator(ranges::end(__t));
   }
 
   void operator()(auto&&) const = delete;
 };
 } // namespace __rbegin
 
 inline namespace __cpo {
-  inline constexpr auto rbegin = __rbegin::__fn{};
+_LIBCPP_NODEBUG inline constexpr auto rbegin = __rbegin::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
 // [range.access.crbegin]
 
 namespace ranges {
 namespace __crbegin {
 struct __fn {
struct __fn {
   constexpr auto operator()(_Tp&& __t) const
     noexcept(noexcept(ranges::rbegin(static_cast<const _Tp&&>(__t))))
     -> decltype(      ranges::rbegin(static_cast<const _Tp&&>(__t)))
     { return          ranges::rbegin(static_cast<const _Tp&&>(__t)); }
 };
 } // namespace __crbegin
 
 inline namespace __cpo {
-  inline constexpr auto crbegin = __crbegin::__fn{};
+_LIBCPP_NODEBUG inline constexpr auto crbegin = __crbegin::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
 #endif // _LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___RANGES_RBEGIN_H

libcxx/include/__ranges/rend.h

[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
     return std::make_reverse_iterator(ranges::begin(__t));
   }
 
   void operator()(auto&&) const = delete;
 };
 } // namespace __rend
 
 inline namespace __cpo {
-  inline constexpr auto rend = __rend::__fn{};
+_LIBCPP_NODEBUG inline constexpr auto rend = __rend::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
 // [range.access.crend]
 
 namespace ranges {
 namespace __crend {
 struct __fn {
struct __fn {
   constexpr auto operator()(_Tp&& __t) const
     noexcept(noexcept(ranges::rend(static_cast<const _Tp&&>(__t))))
     -> decltype(      ranges::rend(static_cast<const _Tp&&>(__t)))
     { return          ranges::rend(static_cast<const _Tp&&>(__t)); }
 };
 } // namespace __crend
 
 inline namespace __cpo {
-  inline constexpr auto crend = __crend::__fn{};
+_LIBCPP_NODEBUG inline constexpr auto crend = __crend::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
 #endif // _LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___RANGES_REND_H

libcxx/include/__ranges/reverse_view.h

struct __fn : __range_adaptor_closure<__fn> {
       constexpr auto operator()(_Range&& __range) const
         noexcept(noexcept(reverse_view{std::forward<_Range>(__range)}))
         -> decltype(      reverse_view{std::forward<_Range>(__range)})
         { return          reverse_view{std::forward<_Range>(__range)}; }
     };
   } // namespace __reverse
 
   inline namespace __cpo {
-    inline constexpr auto reverse = __reverse::__fn{};
+  _LIBCPP_NODEBUG inline constexpr auto reverse = __reverse::__fn{};
   } // namespace __cpo
   } // namespace views
 } // namespace ranges
 
 #endif // _LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___RANGES_REVERSE_VIEW_H

libcxx/include/__ranges/single_view.h

struct __fn : __range_adaptor_closure<__fn> {
   constexpr auto operator()(_Range&& __range) const
     noexcept(noexcept(single_view<decay_t<_Range&&>>(std::forward<_Range>(__range))))
     -> decltype(      single_view<decay_t<_Range&&>>(std::forward<_Range>(__range)))
     { return          single_view<decay_t<_Range&&>>(std::forward<_Range>(__range)); }
 };
 } // namespace __single_view
 
 inline namespace __cpo {
-  inline constexpr auto single = __single_view::__fn{};
+_LIBCPP_NODEBUG inline constexpr auto single = __single_view::__fn{};
 } // namespace __cpo
 
 } // namespace views
 } // namespace ranges
 
 #endif // _LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___RANGES_SINGLE_VIEW_H

libcxx/include/__ranges/size.h

[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
     -> decltype(      std::__to_unsigned_like(ranges::end(__t) - ranges::begin(__t)))
     { return          std::__to_unsigned_like(ranges::end(__t) - ranges::begin(__t));
   }
 };
 
 } // namespace __size
 
 inline namespace __cpo {
-  inline constexpr auto size = __size::__fn{};
+_LIBCPP_NODEBUG inline constexpr auto size = __size::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
 // [range.prim.ssize]
 
 namespace ranges {
 namespace __ssize {
 struct __fn {
   template<class _Tp>
     requires requires (_Tp&& __t) { ranges::size(__t); }
   [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr integral auto operator()(_Tp&& __t) const
     noexcept(noexcept(ranges::size(__t))) {
     using _Signed = make_signed_t<decltype(ranges::size(__t))>;
     if constexpr (sizeof(ptrdiff_t) > sizeof(_Signed))
       return static_cast<ptrdiff_t>(ranges::size(__t));
     else
       return static_cast<_Signed>(ranges::size(__t));
   }
 };
 } // namespace __ssize
 
 inline namespace __cpo {
-  inline constexpr auto ssize = __ssize::__fn{};
+_LIBCPP_NODEBUG inline constexpr auto ssize = __ssize::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
 #endif // _LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___RANGES_SIZE_H

libcxx/include/__ranges/split_view.h

struct __fn : __range_adaptor_closure<__fn> {
   _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Pattern&& __pattern) const
       noexcept(is_nothrow_constructible_v<decay_t<_Pattern>, _Pattern>) {
     return __range_adaptor_closure_t(std::__bind_back(*this, std::forward<_Pattern>(__pattern)));
   }
 };
 } // namespace __split_view
 
 inline namespace __cpo {
-inline constexpr auto split = __split_view::__fn{};
+_LIBCPP_NODEBUG inline constexpr auto split = __split_view::__fn{};
 } // namespace __cpo
 } // namespace views
 
 } // namespace ranges
 
 #endif // _LIBCPP_STD_VER >= 20
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___RANGES_SPLIT_VIEW_H

libcxx/include/__ranges/take_view.h

struct __fn {
   constexpr auto operator()(_Np&& __n) const
     noexcept(is_nothrow_constructible_v<decay_t<_Np>, _Np>)
   { return __range_adaptor_closure_t(std::__bind_back(*this, std::forward<_Np>(__n))); }
 };
 
 } // namespace __take
 
 inline namespace __cpo {
-  inline constexpr auto take = __take::__fn{};
+  _LIBCPP_NODEBUG inline constexpr auto take = __take::__fn{};
 } // namespace __cpo
 } // namespace views
 
 } // namespace ranges
 
 #endif // _LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP___RANGES_TAKE_VIEW_H

libcxx/include/__ranges/take_while_view.h

[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Pred&& __pred) const
       noexcept(is_nothrow_constructible_v<decay_t<_Pred>, _Pred>) {
     return __range_adaptor_closure_t(std::__bind_back(*this, std::forward<_Pred>(__pred)));
   }
 };
 
 } // namespace __take_while
 
 inline namespace __cpo {
-inline constexpr auto take_while = __take_while::__fn{};
+_LIBCPP_NODEBUG inline constexpr auto take_while = __take_while::__fn{};
 } // namespace __cpo
 } // namespace views
 } // namespace ranges
 
 #endif // _LIBCPP_STD_VER >= 20
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___RANGES_TAKE_WHILE_VIEW_H

libcxx/include/__ranges/transform_view.h

struct __fn {
     [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
     constexpr auto operator()(_Fn&& __f) const
       noexcept(is_nothrow_constructible_v<decay_t<_Fn>, _Fn>)
     { return __range_adaptor_closure_t(std::__bind_back(*this, std::forward<_Fn>(__f))); }
   };
 } // namespace __transform
 
 inline namespace __cpo {
-  inline constexpr auto transform = __transform::__fn{};
+  _LIBCPP_NODEBUG inline constexpr auto transform = __transform::__fn{};
 } // namespace __cpo
 } // namespace views
 
 } // namespace ranges
 
 #endif // _LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___RANGES_TRANSFORM_VIEW_H

libcxx/include/__ranges/zip_view.h

_LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Ranges&&... __rs) const
       noexcept(noexcept(zip_view<all_t<_Ranges&&>...>(std::forward<_Ranges>(__rs)...)))
           -> decltype(zip_view<all_t<_Ranges&&>...>(std::forward<_Ranges>(__rs)...)) {
     return zip_view<all_t<_Ranges>...>(std::forward<_Ranges>(__rs)...);
   }
 };
 
 } // namespace __zip
 inline namespace __cpo {
-  inline constexpr auto zip = __zip::__fn{};
+  _LIBCPP_NODEBUG inline constexpr auto zip = __zip::__fn{};
 } // namespace __cpo
 } // namespace views
 } // namespace ranges
 
 #endif // _LIBCPP_STD_VER > 20
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP___RANGES_ZIP_VIEW_H