On Thu, Sep 11, 2025 at 2:18 PM Jonathan Wakely <[email protected]> wrote:
> Most of the basis operations for ranges such as ranges::begin and
> ranges::next are trivial one-line function bodies, so can be made
> always_inline to reduce the abstraction penalty for -O0 code.
>
> Now that we no longer need to support the -fconcepts-ts grammar, we can
> also move some [[nodiscard]] attributes to the more natural position
> before the function declaration, instead of between the declarator-id
> and the function parameters, e.g. we can use:
>
> template<typename T> requires C<T> [[nodiscard]] auto operator()(T&&)
>
> instead of:
>
> template<typename T> requires C<T> auto operator() [[nodiscard]] (T&&)
>
> The latter form was necessary because -fconcepts-ts used a different
> grammar for the requires-clause, parsing 'C<T>[[x]]' as a subscripting
> operator with an ill-formed argument '[x]'. In the C++20 grammar you
> would need to use parentheses to use a subscript in a constraint, so
> without parentheses it's parsed as an attribute.
>
> libstdc++-v3/ChangeLog:
>
> * include/bits/ranges_base.h (__detail::__to_unsigned_like)
> (__access::__possible_const_range, __access::__as_const)
> (__distance_fn::operator(), __next_fn::operator())
> (__prev_fn::operator()): Add always_inline attribute.
> (_Begin::operator(), _End::operator(), _RBegin::operator())
> (_REnd::operator(), _Size::operator(), _SSize::operator())
> (_Empty::operator(), _Data::operator(), _SSize::operator()):
> Likewise. Move nodiscard attribute to start of declaration.
> ---
>
> This change was inspired when I was adding more uses of ranges::next and
> ranges::prev to fix the iterator arithmetic not using difference_type.
>
LGTM.
>
> Tested powerpc64-linux.
>
> libstdc++-v3/include/bits/ranges_base.h | 47 ++++++++++++++++---------
> 1 file changed, 30 insertions(+), 17 deletions(-)
>
> diff --git a/libstdc++-v3/include/bits/ranges_base.h
> b/libstdc++-v3/include/bits/ranges_base.h
> index 02e13a2027d1..c1a9f6a90009 100644
> --- a/libstdc++-v3/include/bits/ranges_base.h
> +++ b/libstdc++-v3/include/bits/ranges_base.h
> @@ -61,29 +61,32 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
> namespace ranges
> {
> template<typename>
> inline constexpr bool disable_sized_range = false;
>
> template<typename _Tp>
> inline constexpr bool enable_borrowed_range = false;
>
> namespace __detail
> {
> + [[__gnu__::__always_inline__]]
> constexpr __max_size_type
> __to_unsigned_like(__max_size_type __t) noexcept
> { return __t; }
>
> + [[__gnu__::__always_inline__]]
> constexpr __max_size_type
> __to_unsigned_like(__max_diff_type __t) noexcept
> { return __max_size_type(__t); }
>
> template<integral _Tp>
> + [[__gnu__::__always_inline__]]
> constexpr auto
> __to_unsigned_like(_Tp __t) noexcept
> { return static_cast<make_unsigned_t<_Tp>>(__t); }
>
> template<typename _Tp>
> using __make_unsigned_like_t
> = decltype(__detail::__to_unsigned_like(std::declval<_Tp>()));
>
> // Part of the constraints of ranges::borrowed_range
> template<typename _Tp>
> @@ -111,22 +114,23 @@ namespace ranges
> else if constexpr (__member_begin<_Tp>)
> return
> noexcept(_GLIBCXX_AUTO_CAST(std::declval<_Tp&>().begin()));
> else
> return
> noexcept(_GLIBCXX_AUTO_CAST(begin(std::declval<_Tp&>())));
> }
>
> public:
> template<__maybe_borrowed_range _Tp>
> requires is_array_v<remove_reference_t<_Tp>> || __member_begin<_Tp>
> || __adl_begin<_Tp>
> + [[nodiscard, __gnu__::__always_inline__]]
> constexpr auto
> - operator()[[nodiscard]](_Tp&& __t) const
> noexcept(_S_noexcept<_Tp&>())
> + operator()(_Tp&& __t) const noexcept(_S_noexcept<_Tp&>())
> {
> if constexpr (is_array_v<remove_reference_t<_Tp>>)
> {
> static_assert(is_lvalue_reference_v<_Tp>);
> return __t + 0;
> }
> else if constexpr (__member_begin<_Tp>)
> return __t.begin();
> else
> return begin(__t);
> @@ -161,22 +165,23 @@ namespace ranges
> else if constexpr (__member_end<_Tp>)
> return
> noexcept(_GLIBCXX_AUTO_CAST(std::declval<_Tp&>().end()));
> else
> return noexcept(_GLIBCXX_AUTO_CAST(end(std::declval<_Tp&>())));
> }
>
> public:
> template<__maybe_borrowed_range _Tp>
> requires is_bounded_array_v<remove_reference_t<_Tp>>
> || __member_end<_Tp> || __adl_end<_Tp>
> + [[nodiscard, __gnu__::__always_inline__]]
> constexpr auto
> - operator()[[nodiscard]](_Tp&& __t) const
> noexcept(_S_noexcept<_Tp&>())
> + operator()(_Tp&& __t) const noexcept(_S_noexcept<_Tp&>())
> {
> if constexpr (is_bounded_array_v<remove_reference_t<_Tp>>)
> {
> static_assert(is_lvalue_reference_v<_Tp>);
> return __t + extent_v<remove_reference_t<_Tp>>;
> }
> else if constexpr (__member_end<_Tp>)
> return __t.end();
> else
> return end(__t);
> @@ -225,22 +230,23 @@ namespace ranges
> return is_nothrow_copy_constructible_v<_It>;
> }
> else
> return false;
> }
> }
>
> public:
> template<__maybe_borrowed_range _Tp>
> requires __member_rbegin<_Tp> || __adl_rbegin<_Tp> ||
> __reversable<_Tp>
> + [[nodiscard, __gnu__::__always_inline__]]
> constexpr auto
> - operator()[[nodiscard]](_Tp&& __t) const
> + operator()(_Tp&& __t) const
> noexcept(_S_noexcept<_Tp&>())
> {
> if constexpr (__member_rbegin<_Tp>)
> return __t.rbegin();
> else if constexpr (__adl_rbegin<_Tp>)
> return rbegin(__t);
> else
> return std::make_reverse_iterator(_End{}(__t));
> }
> };
> @@ -282,22 +288,23 @@ namespace ranges
> return is_nothrow_copy_constructible_v<_It>;
> }
> else
> return false;
> }
> }
>
> public:
> template<__maybe_borrowed_range _Tp>
> requires __member_rend<_Tp> || __adl_rend<_Tp> || __reversable<_Tp>
> + [[nodiscard, __gnu__::__always_inline__]]
> constexpr auto
> - operator()[[nodiscard]](_Tp&& __t) const
> + operator()(_Tp&& __t) const
> noexcept(_S_noexcept<_Tp&>())
> {
> if constexpr (__member_rend<_Tp>)
> return __t.rend();
> else if constexpr (__adl_rend<_Tp>)
> return rend(__t);
> else
> return std::make_reverse_iterator(_Begin{}(__t));
> }
> };
> @@ -346,42 +353,44 @@ namespace ranges
> return
> noexcept(_GLIBCXX_AUTO_CAST(size(std::declval<_Tp&>())));
> else if constexpr (__sentinel_size<_Tp>)
> return noexcept(_End{}(std::declval<_Tp&>())
> - _Begin{}(std::declval<_Tp&>()));
> }
>
> public:
> template<typename _Tp>
> requires is_bounded_array_v<remove_reference_t<_Tp>>
> || __member_size<_Tp> || __adl_size<_Tp> || __sentinel_size<_Tp>
> + [[nodiscard, __gnu__::__always_inline__]]
> constexpr auto
> - operator()[[nodiscard]](_Tp&& __t) const
> noexcept(_S_noexcept<_Tp&>())
> + operator()(_Tp&& __t) const noexcept(_S_noexcept<_Tp&>())
> {
> if constexpr (is_bounded_array_v<remove_reference_t<_Tp>>)
> return extent_v<remove_reference_t<_Tp>>;
> else if constexpr (__member_size<_Tp>)
> return __t.size();
> else if constexpr (__adl_size<_Tp>)
> return size(__t);
> else if constexpr (__sentinel_size<_Tp>)
> return __detail::__to_unsigned_like(_End{}(__t) -
> _Begin{}(__t));
> }
> };
>
> struct _SSize
> {
> // _GLIBCXX_RESOLVE_LIB_DEFECTS
> // 3403. Domain of ranges::ssize(E) doesn't match ranges::size(E)
> template<typename _Tp>
> requires requires (_Tp& __t) { _Size{}(__t); }
> + [[nodiscard, __gnu__::__always_inline__]]
> constexpr auto
> - operator()[[nodiscard]](_Tp&& __t) const
> noexcept(noexcept(_Size{}(__t)))
> + operator()(_Tp&& __t) const noexcept(noexcept(_Size{}(__t)))
> {
> auto __size = _Size{}(__t);
> using __size_type = decltype(__size);
> // Return the wider of ptrdiff_t and
> make-signed-like-t<__size_type>.
> if constexpr (integral<__size_type>)
> {
> using __gnu_cxx::__int_traits;
> if constexpr (__int_traits<__size_type>::__digits
> < __int_traits<ptrdiff_t>::__digits)
> return static_cast<ptrdiff_t>(__size);
> @@ -422,22 +431,23 @@ namespace ranges
> return noexcept(_Size{}(std::declval<_Tp&>()) == 0);
> else
> return noexcept(bool(_Begin{}(std::declval<_Tp&>())
> == _End{}(std::declval<_Tp&>())));
> }
>
> public:
> template<typename _Tp>
> requires __member_empty<_Tp> || __size0_empty<_Tp>
> || __eq_iter_empty<_Tp>
> + [[nodiscard, __gnu__::__always_inline__]]
> constexpr bool
> - operator()[[nodiscard]](_Tp&& __t) const
> noexcept(_S_noexcept<_Tp&>())
> + operator()(_Tp&& __t) const noexcept(_S_noexcept<_Tp&>())
> {
> if constexpr (__member_empty<_Tp>)
> return bool(__t.empty());
> else if constexpr (__size0_empty<_Tp>)
> return _Size{}(__t) == 0;
> else
> return bool(_Begin{}(__t) == _End{}(__t));
> }
> };
>
> @@ -463,22 +473,23 @@ namespace ranges
> {
> if constexpr (__member_data<_Tp>)
> return
> noexcept(_GLIBCXX_AUTO_CAST(std::declval<_Tp&>().data()));
> else
> return noexcept(_Begin{}(std::declval<_Tp&>()));
> }
>
> public:
> template<__maybe_borrowed_range _Tp>
> requires __member_data<_Tp> || __begin_data<_Tp>
> + [[nodiscard, __gnu__::__always_inline__]]
> constexpr auto
> - operator()[[nodiscard]](_Tp&& __t) const
> noexcept(_S_noexcept<_Tp>())
> + operator()(_Tp&& __t) const noexcept(_S_noexcept<_Tp>())
> {
> if constexpr (__member_data<_Tp>)
> return __t.data();
> else
> return std::to_address(_Begin{}(__t));
> }
> };
>
> } // namespace __access
>
> @@ -625,33 +636,35 @@ namespace ranges
> #if __glibcxx_ranges_as_const // >= C++23
> template<typename _Tp>
> concept constant_range
> = input_range<_Tp> &&
> std::__detail::__constant_iterator<iterator_t<_Tp>>;
> #endif
>
> namespace __access
> {
> #if __glibcxx_ranges_as_const // >= C++23
> template<input_range _Range>
> + [[__gnu__::__always_inline__]]
> constexpr auto&
> __possibly_const_range(_Range& __r) noexcept
> {
> // _GLIBCXX_RESOLVE_LIB_DEFECTS
> // 4027. possibly-const-range should prefer returning const R&
> if constexpr (input_range<const _Range>)
> return const_cast<const _Range&>(__r);
> else
> return __r;
> }
> #else
> // If _To is an lvalue-reference, return const _Tp&, otherwise const
> _Tp&&.
> template<typename _To, typename _Tp>
> + [[__gnu__::__always_inline__]]
> constexpr decltype(auto)
> __as_const(_Tp& __t) noexcept
> {
> static_assert(std::is_same_v<_To&, _Tp&>);
>
> if constexpr (is_lvalue_reference_v<_To>)
> return const_cast<const _Tp&>(__t);
> else
> return static_cast<const _Tp&&>(__t);
> }
> @@ -960,106 +973,106 @@ namespace ranges
> iter_difference_t<_It> __n = 0;
> while (__first != __last)
> {
> ++__first;
> ++__n;
> }
> return __n;
> }
>
> template<typename _It, sized_sentinel_for<decay_t<_It>> _Sent>
> - [[nodiscard]]
> + [[nodiscard, __gnu__::__always_inline__]]
> constexpr iter_difference_t<decay_t<_It>>
> operator()(_It&& __first, _Sent __last) const
> { return __last - static_cast<const decay_t<_It>&>(__first); }
>
> template<range _Range>
> - [[nodiscard]]
> + [[nodiscard, __gnu__::__always_inline__]]
> constexpr range_difference_t<_Range>
> operator()(_Range&& __r) const
> {
> if constexpr (sized_range<_Range>)
> return
> static_cast<range_difference_t<_Range>>(ranges::size(__r));
> else
> return (*this)(ranges::begin(__r), ranges::end(__r));
> }
>
> void operator&() const = delete;
> };
>
> inline constexpr __distance_fn distance{};
>
> struct __next_fn final
> {
> template<input_or_output_iterator _It>
> - [[nodiscard]]
> + [[nodiscard, __gnu__::__always_inline__]]
> constexpr _It
> operator()(_It __x) const
> {
> ++__x;
> return __x;
> }
>
> template<input_or_output_iterator _It>
> - [[nodiscard]]
> + [[nodiscard, __gnu__::__always_inline__]]
> constexpr _It
> operator()(_It __x, iter_difference_t<_It> __n) const
> {
> ranges::advance(__x, __n);
> return __x;
> }
>
> template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
> - [[nodiscard]]
> + [[nodiscard, __gnu__::__always_inline__]]
> constexpr _It
> operator()(_It __x, _Sent __bound) const
> {
> ranges::advance(__x, __bound);
> return __x;
> }
>
> template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
> - [[nodiscard]]
> + [[nodiscard, __gnu__::__always_inline__]]
> constexpr _It
> operator()(_It __x, iter_difference_t<_It> __n, _Sent __bound) const
> {
> ranges::advance(__x, __n, __bound);
> return __x;
> }
>
> void operator&() const = delete;
> };
>
> inline constexpr __next_fn next{};
>
> struct __prev_fn final
> {
> template<bidirectional_iterator _It>
> - [[nodiscard]]
> + [[nodiscard, __gnu__::__always_inline__]]
> constexpr _It
> operator()(_It __x) const
> {
> --__x;
> return __x;
> }
>
> template<bidirectional_iterator _It>
> - [[nodiscard]]
> + [[nodiscard, __gnu__::__always_inline__]]
> constexpr _It
> operator()(_It __x, iter_difference_t<_It> __n) const
> {
> ranges::advance(__x, -__n);
> return __x;
> }
>
> template<bidirectional_iterator _It>
> - [[nodiscard]]
> + [[nodiscard, __gnu__::__always_inline__]]
> constexpr _It
> operator()(_It __x, iter_difference_t<_It> __n, _It __bound) const
> {
> ranges::advance(__x, -__n, __bound);
> return __x;
> }
>
> void operator&() const = delete;
> };
>
> --
> 2.51.0
>
>
