Using the CRTP idiom for this base class avoids bloating the size of a
pipeline when adding distinct empty range adaptor closure objects to it,
as detailed in section 4.1 of P2387R3.

But it means we can no longer define its operator| overloads as hidden
friends, since each instantiation of _RangeAdaptorClosure would then
introduce its own logically different hidden friends.  So for example
during overload resolution for the outer pipe operator in

 :x | (views::reverse | views::join)

we'd have to consider 6 different hidden operator| friends:

  2 from _RangeAdaptorClosure<_Reverse>
  2 from _RangeAdaptorClosure<_Join>
  2 from _RangeAdaptorClosure<_Pipe<_Reverse, _Join>>

which is wasteful and can even cause hard errors in some cases.  So we
instead define the operator| overloads at namespace scope in an isolated
namespace.

        PR libstdc++/108827

libstdc++-v3/ChangeLog:

        * include/std/ranges (__adaptor::_RangeAdaptorClosure): Move ...
        (__adaptor::__closure::_RangeAdaptorClosure): ... here and turn
        it into a CRTP class template.  Move hidden operator| friends
        into namespace scope and adjust their constraints.  Add a
        using-declaration for this at __adaptor::_RangeAdaptorClosure.
        (__closure::__is_range_adaptor_closure_fn): Define.
        (__closure::__is_range_adaptor_closure): Define.
        (__adaptor::_Partial): Adjust use of _RangeAdaptorClosure.
        (__adaptor::_Pipe): Likewise.
        (views::_All): Likewise.
        (views::_Join): Likewise.
        (views::_Common): Likewise.
        (views::_Reverse): Likewise.
        (views::_Elements): Likewise.
        (views::_Adjacent): Likewise.
        (views::_AsRvalue): Likewise.
        (views::_Enumerate): Likewise.
        (views::_AsConst): Likewise.
        * testsuite/std/ranges/adaptors/all.cc: Reintroduce
        static_assert expecting that adding empty range adaptor
        closure objects to a pipeline doesn't increase the size of a
        pipeline.
---
 libstdc++-v3/include/std/ranges               | 69 +++++++++++--------
 .../testsuite/std/ranges/adaptors/all.cc      |  7 --
 2 files changed, 42 insertions(+), 34 deletions(-)

diff --git a/libstdc++-v3/include/std/ranges b/libstdc++-v3/include/std/ranges
index 283d757faa4..531ec6f68b3 100644
--- a/libstdc++-v3/include/std/ranges
+++ b/libstdc++-v3/include/std/ranges
@@ -872,30 +872,45 @@ namespace views::__adaptor
   template<typename _Lhs, typename _Rhs>
     struct _Pipe;
 
-  // The base class of every range adaptor closure.
-  //
-  // The derived class should define the optional static data member
-  // _S_has_simple_call_op to true if the behavior of this adaptor is
-  // independent of the constness/value category of the adaptor object.
-  struct _RangeAdaptorClosure
+  namespace __closure
   {
+    // The base class of every range adaptor closure.
+    //
+    // The derived class should define the optional static data member
+    // _S_has_simple_call_op to true if the behavior of this adaptor is
+    // independent of the constness/value category of the adaptor object.
+    template<typename _Derived>
+      struct _RangeAdaptorClosure
+      { };
+
+    template<typename _Tp, typename _Up>
+      requires (!same_as<_Tp, _RangeAdaptorClosure<_Up>>)
+      void __is_range_adaptor_closure_fn
+       (const _Tp&, const _RangeAdaptorClosure<_Up>&); // not defined
+
+    template<typename _Tp>
+      concept __is_range_adaptor_closure
+       = requires (_Tp __t) { __closure::__is_range_adaptor_closure_fn(__t, 
__t); };
+
     // range | adaptor is equivalent to adaptor(range).
     template<typename _Self, typename _Range>
-      requires derived_from<remove_cvref_t<_Self>, _RangeAdaptorClosure>
+      requires __is_range_adaptor_closure<_Self>
        && __adaptor_invocable<_Self, _Range>
-      friend constexpr auto
+      constexpr auto
       operator|(_Range&& __r, _Self&& __self)
       { return std::forward<_Self>(__self)(std::forward<_Range>(__r)); }
 
     // Compose the adaptors __lhs and __rhs into a pipeline, returning
     // another range adaptor closure object.
     template<typename _Lhs, typename _Rhs>
-      requires derived_from<_Lhs, _RangeAdaptorClosure>
-       && derived_from<_Rhs, _RangeAdaptorClosure>
-      friend constexpr auto
+      requires __is_range_adaptor_closure<_Lhs>
+       && __is_range_adaptor_closure<_Rhs>
+      constexpr auto
       operator|(_Lhs __lhs, _Rhs __rhs)
       { return _Pipe<_Lhs, _Rhs>{std::move(__lhs), std::move(__rhs)}; }
-  };
+  } // namespace __closure
+
+  using __closure::_RangeAdaptorClosure;
 
   // The base class of every range adaptor non-closure.
   //
@@ -937,7 +952,7 @@ namespace views::__adaptor
   // A range adaptor closure that represents partial application of
   // the range adaptor _Adaptor with arguments _Args.
   template<typename _Adaptor, typename... _Args>
-    struct _Partial : _RangeAdaptorClosure
+    struct _Partial : _RangeAdaptorClosure<_Partial<_Adaptor, _Args...>>
     {
       tuple<_Args...> _M_args;
 
@@ -978,7 +993,7 @@ namespace views::__adaptor
   // A lightweight specialization of the above primary template for
   // the common case where _Adaptor accepts a single extra argument.
   template<typename _Adaptor, typename _Arg>
-    struct _Partial<_Adaptor, _Arg> : _RangeAdaptorClosure
+    struct _Partial<_Adaptor, _Arg> : _RangeAdaptorClosure<_Partial<_Adaptor, 
_Arg>>
     {
       _Arg _M_arg;
 
@@ -1011,7 +1026,7 @@ namespace views::__adaptor
   template<typename _Adaptor, typename... _Args>
     requires __adaptor_has_simple_extra_args<_Adaptor, _Args...>
       && (is_trivially_copyable_v<_Args> && ...)
-    struct _Partial<_Adaptor, _Args...> : _RangeAdaptorClosure
+    struct _Partial<_Adaptor, _Args...> : 
_RangeAdaptorClosure<_Partial<_Adaptor, _Args...>>
     {
       tuple<_Args...> _M_args;
 
@@ -1041,7 +1056,7 @@ namespace views::__adaptor
   template<typename _Adaptor, typename _Arg>
     requires __adaptor_has_simple_extra_args<_Adaptor, _Arg>
       && is_trivially_copyable_v<_Arg>
-    struct _Partial<_Adaptor, _Arg> : _RangeAdaptorClosure
+    struct _Partial<_Adaptor, _Arg> : _RangeAdaptorClosure<_Partial<_Adaptor, 
_Arg>>
     {
       _Arg _M_arg;
 
@@ -1066,7 +1081,7 @@ namespace views::__adaptor
   // A range adaptor closure that represents composition of the range
   // adaptor closures _Lhs and _Rhs.
   template<typename _Lhs, typename _Rhs>
-    struct _Pipe : _RangeAdaptorClosure
+    struct _Pipe : _RangeAdaptorClosure<_Pipe<_Lhs, _Rhs>>
     {
       [[no_unique_address]] _Lhs _M_lhs;
       [[no_unique_address]] _Rhs _M_rhs;
@@ -1102,7 +1117,7 @@ namespace views::__adaptor
   template<typename _Lhs, typename _Rhs>
     requires __closure_has_simple_call_op<_Lhs>
       && __closure_has_simple_call_op<_Rhs>
-    struct _Pipe<_Lhs, _Rhs> : _RangeAdaptorClosure
+    struct _Pipe<_Lhs, _Rhs> : _RangeAdaptorClosure<_Pipe<_Lhs, _Rhs>>
     {
       [[no_unique_address]] _Lhs _M_lhs;
       [[no_unique_address]] _Rhs _M_rhs;
@@ -1264,7 +1279,7 @@ namespace views::__adaptor
        concept __can_owning_view = requires { 
owning_view{std::declval<_Range>()}; };
     } // namespace __detail
 
-    struct _All : __adaptor::_RangeAdaptorClosure
+    struct _All : __adaptor::_RangeAdaptorClosure<_All>
     {
       template<typename _Range>
        static constexpr bool
@@ -3048,7 +3063,7 @@ namespace views::__adaptor
          = requires { join_view<all_t<_Range>>{std::declval<_Range>()}; };
     } // namespace __detail
 
-    struct _Join : __adaptor::_RangeAdaptorClosure
+    struct _Join : __adaptor::_RangeAdaptorClosure<_Join>
     {
       template<viewable_range _Range>
        requires __detail::__can_join_view<_Range>
@@ -3842,7 +3857,7 @@ namespace views::__adaptor
          = requires { common_view{std::declval<_Range>()}; };
     } // namespace __detail
 
-    struct _Common : __adaptor::_RangeAdaptorClosure
+    struct _Common : __adaptor::_RangeAdaptorClosure<_Common>
     {
       template<viewable_range _Range>
        requires __detail::__already_common<_Range>
@@ -3963,7 +3978,7 @@ namespace views::__adaptor
          = requires { reverse_view{std::declval<_Range>()}; };
     } // namespace __detail
 
-    struct _Reverse : __adaptor::_RangeAdaptorClosure
+    struct _Reverse : __adaptor::_RangeAdaptorClosure<_Reverse>
     {
       template<viewable_range _Range>
        requires __detail::__is_reverse_view<remove_cvref_t<_Range>>
@@ -4363,7 +4378,7 @@ namespace views::__adaptor
     } // namespace __detail
 
     template<size_t _Nm>
-      struct _Elements : __adaptor::_RangeAdaptorClosure
+      struct _Elements : __adaptor::_RangeAdaptorClosure<_Elements<_Nm>>
       {
        template<viewable_range _Range>
          requires __detail::__can_elements_view<_Nm, _Range>
@@ -5484,7 +5499,7 @@ namespace views::__adaptor
     }
 
     template<size_t _Nm>
-      struct _Adjacent : __adaptor::_RangeAdaptorClosure
+      struct _Adjacent : __adaptor::_RangeAdaptorClosure<_Adjacent<_Nm>>
       {
        template<viewable_range _Range>
          requires (_Nm == 0) || __detail::__can_adjacent_view<_Nm, _Range>
@@ -8609,7 +8624,7 @@ namespace views::__adaptor
        concept __can_as_rvalue_view = requires { 
as_rvalue_view(std::declval<_Tp>()); };
     }
 
-    struct _AsRvalue : __adaptor::_RangeAdaptorClosure
+    struct _AsRvalue : __adaptor::_RangeAdaptorClosure<_AsRvalue>
     {
       template<viewable_range _Range>
        requires __detail::__can_as_rvalue_view<_Range>
@@ -8918,7 +8933,7 @@ namespace views::__adaptor
          = requires { enumerate_view<all_t<_Tp>>(std::declval<_Tp>()); };
     }
 
-    struct _Enumerate : __adaptor::_RangeAdaptorClosure
+    struct _Enumerate : __adaptor::_RangeAdaptorClosure<_Enumerate>
     {
       template<viewable_range _Range>
        requires __detail::__can_enumerate_view<_Range>
@@ -9004,7 +9019,7 @@ namespace views::__adaptor
        concept __can_as_const_view = requires { 
as_const_view(std::declval<_Range>()); };
     }
 
-    struct _AsConst : __adaptor::_RangeAdaptorClosure
+    struct _AsConst : __adaptor::_RangeAdaptorClosure<_AsConst>
     {
       template<viewable_range _Range>
       constexpr auto
diff --git a/libstdc++-v3/testsuite/std/ranges/adaptors/all.cc 
b/libstdc++-v3/testsuite/std/ranges/adaptors/all.cc
index 57cb542174b..6bbaf73a20a 100644
--- a/libstdc++-v3/testsuite/std/ranges/adaptors/all.cc
+++ b/libstdc++-v3/testsuite/std/ranges/adaptors/all.cc
@@ -105,12 +105,6 @@ static_assert(std::is_empty_v<decltype(views::common
                                       | views::common
                                       | views::keys
                                       | views::reverse)>);
-#if 0
-// Adding empty range adaptor closure objects to a pipeline used to not
-// increase the size of the pipeline, but now that our range adaptor closure
-// objects derive from a common empty base class, [[no_unique_address]] can no
-// longer make two empty adjacent range adaptor closure objects occupy the same
-// data member address.
 static_assert(sizeof(decltype(views::take(5) | views::drop(5)))
              == sizeof(decltype(views::take(5)
                                 | views::join
@@ -119,7 +113,6 @@ static_assert(sizeof(decltype(views::take(5) | 
views::drop(5)))
                                 | views::keys
                                 | views::drop(5)
                                 | views::reverse)));
-#endif
 
 template<auto all = views::all>
 void
-- 
2.40.0.335.g9857273be0

Reply via email to