[libc++] [P0849R8] Introduce _LIBCPP_AUTO_CAST(x) for auto(x)

[• Quuxplusone]

Summary

Clang is gaining auto(x) support in D113393, but sadly there seems to be no feature-test macro for it.

Use this where C++20 specifies we should use auto(x); stop using __decay_copy(x), which calls more move-constructors than it should.
Add regression tests.

Drive-by fix some places in std::ranges::size that were perfect-forwarding when they shouldn't; this affects one test case. Did this only because I was touching those lines already: __decay_copy(forward(x)) becomes just _LIBCPP_AUTO_CAST(x).

[jloser]

That's a bit surprising there's no feature test macro for it - but I agree after reading the paper. :(

[• Quuxplusone]

Fix generated files.

[ldionne]

We should have an entry for P0849R8 in our status pages. It's a CWG paper but it does have some effects on the library -- can you add it and mark it as complete?

libcxx/include/__ranges/access.h

111

__t is "an lvalue that denotes the reified object for E", and that's why we don't want to use std::forward -- right?

[• Quuxplusone]

Mark P0849 as "Complete," which means replacing the remaining __decay_copys e.g. in <thread> with _LIBCPP_AUTO_CAST. I believe these diffs end up being no-ops. Then, there are no __decay_copys left anywhere in the codebase, so just remove the helper entirely.

Now, P0849 goes out of its way to not remove the uses of decay-copy in http://eel.is/c++draft/range.all.general#2.1 and http://eel.is/c++draft/range.take#overview-2.1 , but that's just a specification hack. decay-copy(E) is the same thing as auto(forward<T>(t)) whenever E is of reference type T&&, and this hack is basically just saying "yes, LWG understands that for this particular usage there's going to be a perfect-forwarding."

[• Quuxplusone]

libcxx/include/__ranges/access.h

111

Correct.

Re adding a status-page entry for P0849: Done! Of course, to mark it "complete," I had to expand the scope of this patch a tiny bit... :)

[• Quuxplusone]

Now that C++11 future uses _LIBCPP_AUTO_CAST, that macro needs to stop using decay_t and use decay<T>::type instead.

[ldionne]

Is there really no other place that uses decay-copy in the standard? If so, they forgot to remove it from http://eel.is/c++draft/expos.only.func#2.

[• Quuxplusone]

In D115686#3205591, @ldionne wrote:

Is there really no other place that uses decay-copy in the standard? If so, they forgot to remove it from http://eel.is/c++draft/expos.only.func#2.

It's still used as a specification tool in a few places — notably even within Ranges, e.g. http://eel.is/c++draft/range.take#overview-2.1 "If T is a specialization of ranges​::​empty_view, then views​::​take(E, F) is expression-equivalent to ((void) F, decay-copy(E)), except that the evaluations of E and F are indeterminately sequenced." The Standard can't literally say it's expression-equivalent to ((void) F, (E)), because then if E were a prvalue then the return object of views::take(E, F) would have to work out to the exact same prvalue object as the function argument E... and that's physically impossible. So they specify it in terms of decay-copy. Also, they have to say "indeterminately sequenced" because E and F are really function arguments, and function arguments are indeterminately sequenced.

Basically, decay-copy(X) is now purely a specification tool. When LWG means return func(X), LWG can say "expression-equivalent to func(X)"; but when LWG means literally return X, then LWG must say "expression-equivalent to decay-copy(X)." However, as shown in D115686, my interpretation is that the library implementor never wants to use __decay_copy(X); when the standard says "expression-equivalent to decay-copy(X)", the library implementor should generally reverse-translate that into simply return X.

[• Quuxplusone]

Change D112214's XFAIL to UNSUPPORTED, since it passes now (for some reason).

@mstorsjo writes:

I think it was technically undefined whether it fails or succeeds, so yeah it’s plausible that a random change could make it work again (it depended on which order the linker included some section pieces).

libcxx/include/CMakeLists.txt

set(files
   __support/xlocale/__posix_l_fallback.h
   __support/xlocale/__strtonum_fallback.h
   __thread/poll_with_backoff.h
   __threading_support
   __tree
   __tuple
   __undef_macros
   __utility/as_const.h
+  __utility/auto_cast.h
   __utility/cmp.h
   __utility/decay_copy.h
   __utility/declval.h
   __utility/exchange.h
   __utility/forward.h
   __utility/in_place.h
   __utility/integer_sequence.h
   __utility/move.h

libcxx/include/__ranges/access.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #ifndef _LIBCPP___RANGES_ACCESS_H
 #define _LIBCPP___RANGES_ACCESS_H
 
 #include <__config>
 #include <__iterator/concepts.h>
 #include <__iterator/readable_traits.h>
 #include <__ranges/enable_borrowed_range.h>
 #include <__utility/as_const.h>
-#include <__utility/decay_copy.h>
-#include <__utility/forward.h>
+#include <__utility/auto_cast.h>
 #include <concepts>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD

 } // namespace ranges
 
 // [range.access.begin]
 namespace ranges::__begin {
   template <class _Tp>
   concept __member_begin =
     __can_borrow<_Tp> &&
     requires(_Tp&& __t) {
-      { _VSTD::__decay_copy(__t.begin()) } -> input_or_output_iterator;
+      { _LIBCPP_AUTO_CAST(__t.begin()) } -> input_or_output_iterator;
     };
 
   void begin(auto&) = delete;
   void begin(const auto&) = delete;
 
   template <class _Tp>
   concept __unqualified_begin =
     !__member_begin<_Tp> &&
     __can_borrow<_Tp> &&
     __class_or_enum<remove_cvref_t<_Tp> > &&
     requires(_Tp && __t) {
-      { _VSTD::__decay_copy(begin(__t)) } -> input_or_output_iterator;
+      { _LIBCPP_AUTO_CAST(begin(__t)) } -> input_or_output_iterator;
     };
 
   struct __fn {
     template <class _Tp>
     requires is_array_v<remove_cv_t<_Tp>>
     [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp& __t) const noexcept {
       constexpr bool __complete = __is_complete<iter_value_t<_Tp> >;
       if constexpr (__complete) { // used to disable cryptic diagnostic
         return __t + 0;
       }
       else {
         static_assert(__complete, "`std::ranges::begin` is SFINAE-unfriendly on arrays of an incomplete type.");
       }
     }
 
     template <class _Tp>
     requires __member_begin<_Tp>
     [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
-    noexcept(noexcept(_VSTD::__decay_copy(__t.begin())))
+    noexcept(noexcept(_LIBCPP_AUTO_CAST(__t.begin())))
     {
-      return __t.begin();
+      return _LIBCPP_AUTO_CAST(__t.begin());
     }
 
     template <class _Tp>
     requires __unqualified_begin<_Tp>
     [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
-    noexcept(noexcept(_VSTD::__decay_copy(begin(__t))))
+    noexcept(noexcept(_LIBCPP_AUTO_CAST(begin(__t))))
     {
-      return begin(__t);
+      return _LIBCPP_AUTO_CAST(begin(__t));
     }
 
     void operator()(auto&&) const = delete;
   };
 } // namespace ranges::__begin
 
 namespace ranges {
   inline namespace __cpo {
     inline constexpr auto begin = __begin::__fn{};
   } // namespace __cpo
 
   template <class _Tp>
   using iterator_t = decltype(ranges::begin(declval<_Tp&>()));
 } // namespace ranges
 
 // [range.access.end]
 namespace ranges::__end {
   template <class _Tp>
   concept __member_end =
     __can_borrow<_Tp> &&
     requires(_Tp&& __t) {
       typename iterator_t<_Tp>;
-      { _VSTD::__decay_copy(_VSTD::forward<_Tp>(__t).end()) } -> sentinel_for<iterator_t<_Tp> >;
+      { _LIBCPP_AUTO_CAST(__t.end()) } -> sentinel_for<iterator_t<_Tp> >;
     };
 
   void end(auto&) = delete;
   void end(const auto&) = delete;
 
   template <class _Tp>
   concept __unqualified_end =
     !__member_end<_Tp> &&
     __can_borrow<_Tp> &&
     __class_or_enum<remove_cvref_t<_Tp> > &&
     requires(_Tp && __t) {
       typename iterator_t<_Tp>;
-      { _VSTD::__decay_copy(end(_VSTD::forward<_Tp>(__t))) } -> sentinel_for<iterator_t<_Tp> >;
+      { _LIBCPP_AUTO_CAST(end(__t)) } -> sentinel_for<iterator_t<_Tp> >;
     };
 
   class __fn {
   public:
     template <class _Tp, size_t _Np>
     [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp (&__t)[_Np]) const noexcept {
       constexpr bool __complete = __is_complete<remove_cv_t<_Tp> >;
       if constexpr (__complete) { // used to disable cryptic diagnostic
         return __t + _Np;
       }
       else {
         static_assert(__complete, "`std::ranges::end` is SFINAE-unfriendly on arrays of an incomplete type.");
       }
     }
 
     template <class _Tp>
     requires __member_end<_Tp>
     [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
-    noexcept(noexcept(_VSTD::__decay_copy(__t.end())))
+    noexcept(noexcept(_LIBCPP_AUTO_CAST(__t.end())))
     {
-      return _VSTD::forward<_Tp>(__t).end();
+      return _LIBCPP_AUTO_CAST(__t.end());
     }
 
     template <class _Tp>
     requires __unqualified_end<_Tp>
     [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
-    noexcept(noexcept(_VSTD::__decay_copy(end(__t))))
+    noexcept(noexcept(_LIBCPP_AUTO_CAST(end(__t))))
     {
-      return end(__t);
+      return _LIBCPP_AUTO_CAST(end(__t));
     }
 
     void operator()(auto&&) const = delete;
   };
 } // namespace ranges::__end
 
 namespace ranges::inline __cpo {
   inline constexpr auto end = __end::__fn{};

libcxx/include/__ranges/size.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #ifndef _LIBCPP___RANGES_SIZE_H
 #define _LIBCPP___RANGES_SIZE_H
 
 #include <__config>
 #include <__iterator/concepts.h>
 #include <__iterator/iterator_traits.h>
 #include <__ranges/access.h>
-#include <__utility/decay_copy.h>
-#include <__utility/forward.h>
+#include <__utility/auto_cast.h>
 #include <concepts>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if !defined(_LIBCPP_HAS_NO_RANGES)
 
-// clang-format off
 namespace ranges {
 template<class>
 inline constexpr bool disable_sized_range = false;
 
 // [range.prim.size]
 namespace __size {
   void size(auto&) = delete;
   void size(const auto&) = delete;
 
   template <class _Tp>
   concept __size_enabled = !disable_sized_range<remove_cvref_t<_Tp>>;
 
   template <class _Tp>
   concept __member_size = __size_enabled<_Tp> && requires(_Tp&& __t) {
-    { _VSTD::__decay_copy(_VSTD::forward<_Tp>(__t).size()) } -> __integer_like;
+    { _LIBCPP_AUTO_CAST(__t.size()) } -> __integer_like;
   };
 
   template <class _Tp>
   concept __unqualified_size =
     __size_enabled<_Tp> &&
     !__member_size<_Tp> &&
     __class_or_enum<remove_cvref_t<_Tp>> &&
     requires(_Tp&& __t) {
-      { _VSTD::__decay_copy(size(_VSTD::forward<_Tp>(__t))) } -> __integer_like;
+      { _LIBCPP_AUTO_CAST(size(__t)) } -> __integer_like;
     };
 
   template <class _Tp>
   concept __difference =
     !__member_size<_Tp> &&
     !__unqualified_size<_Tp> &&
     __class_or_enum<remove_cvref_t<_Tp>> &&
     requires(_Tp&& __t) {
struct __fn {
 
     template <class _Tp, size_t _Sz>
     [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr size_t operator()(_Tp (&)[_Sz]) const noexcept {
       return _Sz;
     }
 
     template <__member_size _Tp>
     [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr __integer_like auto operator()(_Tp&& __t) const
-        noexcept(noexcept(_VSTD::forward<_Tp>(__t).size())) {
-      return _VSTD::forward<_Tp>(__t).size();
+        noexcept(noexcept(_LIBCPP_AUTO_CAST(__t.size()))) {
+      return _LIBCPP_AUTO_CAST(__t.size());
     }
 
     template <__unqualified_size _Tp>
     [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr __integer_like auto operator()(_Tp&& __t) const
-        noexcept(noexcept(size(_VSTD::forward<_Tp>(__t)))) {
-      return size(_VSTD::forward<_Tp>(__t));
+        noexcept(noexcept(_LIBCPP_AUTO_CAST(size(__t)))) {
+      return _LIBCPP_AUTO_CAST(size(__t));
     }
 
     template<__difference _Tp>
     [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr __integer_like auto operator()(_Tp&& __t) const
         noexcept(noexcept(ranges::end(__t) - ranges::begin(__t))) {
       return _VSTD::__to_unsigned_like(ranges::end(__t) - ranges::begin(__t));
     }
   };
namespace __ssize {
   };
 }
 
 inline namespace __cpo {
   inline constexpr auto ssize = __ssize::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
-// clang-format off
-
 #endif // !defined(_LIBCPP_HAS_NO_RANGES)
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___RANGES_SIZE_H

libcxx/include/__utility/auto_cast.h

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___UTILITY_AUTO_CAST_H
+#define _LIBCPP___UTILITY_AUTO_CAST_H
+
+#include <__config>
+#include <type_traits>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+#define _LIBCPP_AUTO_CAST(expr) static_cast<decay_t<decltype((expr))>>(expr)
+
+#endif // _LIBCPP___UTILITY_AUTO_CAST_H

libcxx/include/module.modulemap

module std [system] {
   }
   module utility {
     header "utility"
     export initializer_list
     export *
 
     module __utility {
       module as_const            { private header "__utility/as_const.h" }
+      module auto_cast           { private header "__utility/auto_cast.h" }
       module cmp                 { private header "__utility/cmp.h" }
       module decay_copy          { private header "__utility/decay_copy.h" }
       module declval             { private header "__utility/declval.h" }
       module exchange            { private header "__utility/exchange.h" }
       module forward             { private header "__utility/forward.h" }
       module in_place            { private header "__utility/in_place.h" }
       module integer_sequence    { private header "__utility/integer_sequence.h" }
       module move                { private header "__utility/move.h" }

libcxx/include/utility

 }  // std
 
 */
 
 #include <__config>
 #include <__debug>
 #include <__tuple>
 #include <__utility/as_const.h>
+#include <__utility/auto_cast.h>
 #include <__utility/cmp.h>
+#include <__utility/decay_copy.h>
 #include <__utility/declval.h>
 #include <__utility/exchange.h>
 #include <__utility/forward.h>
 #include <__utility/in_place.h>
 #include <__utility/integer_sequence.h>
 #include <__utility/move.h>
 #include <__utility/pair.h>
 #include <__utility/piecewise_construct.h>

libcxx/test/std/ranges/range.access/range.access.begin/begin.pass.cpp

constexpr bool testBeginFunction() {
 
   return true;
 }
 
 
 ASSERT_NOEXCEPT(std::ranges::begin(std::declval<int (&)[10]>()));
 ASSERT_NOEXCEPT(std::ranges::cbegin(std::declval<int (&)[10]>()));
 
-template<class T>
 struct NoThrowMemberBegin {
-  T begin() const noexcept;
-};
-ASSERT_NOEXCEPT(std::ranges::begin(std::declval<NoThrowMemberBegin<int*>&>()));
-ASSERT_NOEXCEPT(std::ranges::cbegin(std::declval<NoThrowMemberBegin<int*>&>()));
-ASSERT_NOT_NOEXCEPT(std::ranges::begin(std::declval<NoThrowMemberBegin<ThrowingIterator<int>>&>()));
-ASSERT_NOT_NOEXCEPT(std::ranges::cbegin(std::declval<NoThrowMemberBegin<ThrowingIterator<int>>&>()));
+  ThrowingIterator<int> begin() const noexcept; // auto(t.begin()) doesn't throw
+} ntmb;
+static_assert(noexcept(std::ranges::begin(ntmb)));
+static_assert(noexcept(std::ranges::cbegin(ntmb)));
 
-template<class T>
 struct NoThrowADLBegin {
-  friend T begin(NoThrowADLBegin&) noexcept { return T{}; }
-  friend T begin(NoThrowADLBegin const&) noexcept { return T{}; }
-};
-ASSERT_NOEXCEPT(std::ranges::begin(std::declval<NoThrowADLBegin<int*>&>()));
-ASSERT_NOEXCEPT(std::ranges::cbegin(std::declval<NoThrowADLBegin<int*>&>()));
-ASSERT_NOT_NOEXCEPT(std::ranges::begin(std::declval<NoThrowADLBegin<ThrowingIterator<int>>&>()));
-ASSERT_NOT_NOEXCEPT(std::ranges::cbegin(std::declval<NoThrowADLBegin<ThrowingIterator<int>>&>()));
+  friend ThrowingIterator<int> begin(NoThrowADLBegin&) noexcept;  // auto(begin(t)) doesn't throw
+  friend ThrowingIterator<int> begin(const NoThrowADLBegin&) noexcept;
+} ntab;
+static_assert(noexcept(std::ranges::begin(ntab)));
+static_assert(noexcept(std::ranges::cbegin(ntab)));
+
+struct NoThrowMemberBeginReturnsRef {
+  ThrowingIterator<int>& begin() const noexcept; // auto(t.begin()) may throw
+} ntmbrr;
+static_assert(!noexcept(std::ranges::begin(ntmbrr)));
+static_assert(!noexcept(std::ranges::cbegin(ntmbrr)));
 
 struct BeginReturnsArrayRef {
     auto begin() const noexcept -> int(&)[10];
-    auto end() const noexcept -> int(&)[10];
 } brar;
 static_assert(noexcept(std::ranges::begin(brar)));
 static_assert(noexcept(std::ranges::cbegin(brar)));
 
 
 int main(int, char**) {
   testArray();
   static_assert(testArray());

libcxx/test/std/ranges/range.access/range.access.end/end.pass.cpp

constexpr bool testEndFunction() {
 
   return true;
 }
 
 
 ASSERT_NOEXCEPT(std::ranges::end(std::declval<int (&)[10]>()));
 ASSERT_NOEXCEPT(std::ranges::cend(std::declval<int (&)[10]>()));
 
-template<class T>
 struct NoThrowMemberEnd {
-  T begin() const;
-  T end() const noexcept;
-};
-ASSERT_NOEXCEPT(std::ranges::end(std::declval<NoThrowMemberEnd<int*>&>()));
-ASSERT_NOEXCEPT(std::ranges::cend(std::declval<NoThrowMemberEnd<int*>&>()));
-ASSERT_NOT_NOEXCEPT(std::ranges::end(std::declval<NoThrowMemberEnd<ThrowingIterator<int>>&>()));
-ASSERT_NOT_NOEXCEPT(std::ranges::cend(std::declval<NoThrowMemberEnd<ThrowingIterator<int>>&>()));
+  ThrowingIterator<int> begin() const;
+  ThrowingIterator<int> end() const noexcept; // auto(t.end()) doesn't throw
+} ntme;
+static_assert(noexcept(std::ranges::end(ntme)));
+static_assert(noexcept(std::ranges::cend(ntme)));
 
-template<class T>
 struct NoThrowADLEnd {
-  T begin() const;
-  friend T end(NoThrowADLEnd&) noexcept { return T{}; }
-  friend T end(NoThrowADLEnd const&) noexcept { return T{}; }
-};
-ASSERT_NOEXCEPT(std::ranges::end(std::declval<NoThrowADLEnd<int*>&>()));
-ASSERT_NOEXCEPT(std::ranges::cend(std::declval<NoThrowADLEnd<int*>&>()));
-ASSERT_NOT_NOEXCEPT(std::ranges::end(std::declval<NoThrowADLEnd<ThrowingIterator<int>>&>()));
-ASSERT_NOT_NOEXCEPT(std::ranges::cend(std::declval<NoThrowADLEnd<ThrowingIterator<int>>&>()));
+  ThrowingIterator<int> begin() const;
+  friend ThrowingIterator<int> end(NoThrowADLEnd&) noexcept;  // auto(end(t)) doesn't throw
+  friend ThrowingIterator<int> end(const NoThrowADLEnd&) noexcept;
+} ntae;
+static_assert(noexcept(std::ranges::end(ntae)));
+static_assert(noexcept(std::ranges::cend(ntae)));
+
+struct NoThrowMemberEndReturnsRef {
+  ThrowingIterator<int> begin() const;
+  ThrowingIterator<int>& end() const noexcept; // auto(t.end()) may throw
+} ntmerr;
+static_assert(!noexcept(std::ranges::end(ntmerr)));
+static_assert(!noexcept(std::ranges::cend(ntmerr)));
 
-struct BeginReturnsArrayRef {
+struct EndReturnsArrayRef {
     auto begin() const noexcept -> int(&)[10];
     auto end() const noexcept -> int(&)[10];
-} brar;
-static_assert(noexcept(std::ranges::end(brar)));
-static_assert(noexcept(std::ranges::cend(brar)));
-
+} erar;
+static_assert(noexcept(std::ranges::end(erar)));
+static_assert(noexcept(std::ranges::cend(erar)));
 
 int main(int, char**) {
   testArray();
   static_assert(testArray());
 
   testEndMember();
   static_assert(testEndMember());
 
   testEndFunction();
   static_assert(testEndFunction());
 
   return 0;
 }

libcxx/test/std/ranges/range.access/range.prim/size.pass.cpp

 
 struct SizeFunctionSigned {
   friend constexpr long size(SizeFunctionSigned) { return 42; }
 };
 
 bool constexpr testHasSizeFunction() {
   assert(std::ranges::size(SizeFunction()) == 42);
   ASSERT_SAME_TYPE(decltype(std::ranges::size(SizeFunction())), size_t);
-  assert(std::ranges::size(MoveOnlySizeFunction()) == 42);
+  static_assert(!std::is_invocable_v<RangeSizeT, MoveOnlySizeFunction>);
   assert(std::ranges::size(EnumSizeFunction()) == 42);
   assert(std::ranges::size(SizeFunctionConst()) == 42);
 
   SizeFunctionRef a;
   assert(std::ranges::size(a) == 42);
 
   const SizeFunctionConstRef b;
   assert(std::ranges::size(b) == 42);