libstdc++: Implement ranges::safe_range for C++20 (P1870R1)

This change replaces the __forwarding_range implementation detail with
the ranges::safe_range concept and adds the ranges::enable_safe_range
variable template for opt-in in to the concept.

It also adjusts the begin/end/rbegin/rend customization point objects to
match the new rules for accessing rvalue ranges only when safe to do so.

	* include/bits/range_access.h (ranges::enable_safe_range): Define.
	(ranges::begin, ranges::end, ranges::rbegin, ranges::rend): Constrain
	to only accept types satisfying safe_range and treat argument as an
	lvalue when calling a member of performing ADL.
	(ranges::__detail::__range_impl, ranges::__detail::__forwarding_range):
	Remove.
	(ranges::range): Adjust definition.
	(ranges::safe_range): Define.
	(ranges::iterator_t, ranges::range_difference_t): Reorder definitions
	to match the synopsis in the working draft.
	(ranges::disable_sized_range): Remove duplicate definition.
	* include/experimental/string_view (ranges::enable_safe_range): Add
	partial specialization for std::experimental::basic_string_view.
	* include/std/ranges (ranges::viewable_range, ranges::subrange)
	(ranges::empty_view, ranges::iota_view): Use safe_range. Specialize
	enable_safe_range.
	(ranges::safe_iterator_t, ranges::safe_subrange_t): Define.
	* include/std/span (ranges::enable_safe_range): Add partial
	specialization for std::span.
	* include/std/string_view (ranges::enable_safe_range): Likewise for
	std::basic_string_view.
	* testsuite/std/ranges/access/begin.cc: Adjust expected results.
	* testsuite/std/ranges/access/cbegin.cc: Likewise.
	* testsuite/std/ranges/access/cdata.cc: Likewise.
	* testsuite/std/ranges/access/cend.cc: Likewise.
	* testsuite/std/ranges/access/crbegin.cc: Likewise.
	* testsuite/std/ranges/access/crend.cc: Likewise.
	* testsuite/std/ranges/access/data.cc: Likewise.
	* testsuite/std/ranges/access/end.cc: Likewise.
	* testsuite/std/ranges/access/rbegin.cc: Likewise.
	* testsuite/std/ranges/access/rend.cc: Likewise.
	* testsuite/std/ranges/empty_view.cc: Test ranges::begin and
	ranges::end instead of unqualified calls to begin and end.
	* testsuite/std/ranges/safe_range.cc: New test.
	* testsuite/std/ranges/safe_range_types.cc: New test.
	* testsuite/util/testsuite_iterators.h: Add comment about safe_range.

From-SVN: r279135

3 files changed, 48 insertions, 25 deletions

diff --git a/libstdc++-v3/include/std/ranges b/libstdc++-v3/include/std/ranges
index e1bf6ee..c256781 100644
--- a/libstdc++-v3/include/std/ranges
+++ b/libstdc++-v3/include/std/ranges
@@ -89,9 +89,10 @@ namespace ranges
       = range<_Tp> && movable<_Tp> && default_initializable<_Tp>
 	&& enable_view<_Tp>;
 
+  /// A range which can be safely converted to a view.
   template<typename _Tp>
     concept viewable_range = range<_Tp>
-      && (__detail::__forwarding_range<_Tp> || view<decay_t<_Tp>>);
+      && (safe_range<_Tp> || view<decay_t<_Tp>>);
 
   namespace __detail
   {
@@ -295,7 +296,7 @@ namespace ranges
       }
 
       template<__detail::__not_same_as<subrange> _Rng>
-	requires __detail::__forwarding_range<_Rng>
+	requires safe_range<_Rng>
 	  && convertible_to<iterator_t<_Rng>, _It>
 	  && convertible_to<sentinel_t<_Rng>, _Sent>
 	constexpr
@@ -306,7 +307,7 @@ namespace ranges
 	    _M_size._M_size = ranges::size(__r);
 	}
 
-      template<__detail::__forwarding_range _Rng>
+      template<safe_range _Rng>
 	requires convertible_to<iterator_t<_Rng>, _It>
 	  && convertible_to<sentinel_t<_Rng>, _Sent>
 	constexpr
@@ -401,12 +402,6 @@ namespace ranges
 	  ranges::advance(_M_begin, __n, _M_end);
 	return *this;
       }
-
-      friend constexpr _It
-      begin(subrange&& __r) { return __r.begin(); }
-
-      friend constexpr _Sent
-      end(subrange&& __r) { return __r.end(); }
     };
 
   template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
@@ -424,14 +419,14 @@ namespace ranges
       -> subrange<tuple_element_t<0, _Pr>, tuple_element_t<1, _Pr>,
 		  subrange_kind::sized>;
 
-  template<__detail::__forwarding_range _Rng>
+  template<safe_range _Rng>
     subrange(_Rng&&)
       -> subrange<iterator_t<_Rng>, sentinel_t<_Rng>,
 		 (sized_range<_Rng>
 		  || sized_sentinel_for<sentinel_t<_Rng>, iterator_t<_Rng>>)
 		 ? subrange_kind::sized : subrange_kind::unsized>;
 
-  template<__detail::__forwarding_range _Rng>
+  template<safe_range _Rng>
     subrange(_Rng&&,
 	     __detail::__make_unsigned_like_t<range_difference_t<_Rng>>)
       -> subrange<iterator_t<_Rng>, sentinel_t<_Rng>, subrange_kind::sized>;
@@ -457,6 +452,12 @@ namespace ranges
       else
 	return __r.end();
     }
+
+  template<input_or_output_iterator _It, sentinel_for<_It> _Sent,
+	   subrange_kind _Kind>
+    inline constexpr bool
+      enable_safe_range<subrange<_It, _Sent, _Kind>> = true;
+
 } // namespace ranges
 
   using ranges::get;
@@ -471,8 +472,19 @@ namespace ranges
       constexpr dangling(_Args&&...) noexcept { }
   };
 
+  template<range _Range>
+    using safe_iterator_t = conditional_t<safe_range<_Range>,
+					  iterator_t<_Range>,
+					  dangling>;
+
+  template<range _Range>
+    using safe_subrange_t = conditional_t<safe_range<_Range>,
+					  subrange<iterator_t<_Range>>,
+					  dangling>;
+
   template<typename _Tp> requires is_object_v<_Tp>
-    class empty_view : public view_interface<empty_view<_Tp>>
+    class empty_view
+    : public view_interface<empty_view<_Tp>>
     {
     public:
       static constexpr _Tp* begin() noexcept { return nullptr; }
@@ -480,11 +492,11 @@ namespace ranges
       static constexpr _Tp* data() noexcept { return nullptr; }
       static constexpr size_t size() noexcept { return 0; }
       static constexpr bool empty() noexcept { return true; }
-
-      friend constexpr _Tp* begin(empty_view) noexcept { return nullptr; }
-      friend constexpr _Tp* end(empty_view) noexcept { return nullptr; }
     };
 
+  template<typename _Tp>
+    inline constexpr bool enable_safe_range<empty_view<_Tp>> = true;
+
   namespace __detail
   {
     template<copy_constructible _Tp> requires is_object_v<_Tp>
@@ -899,6 +911,9 @@ namespace ranges
 	    == __detail::__is_signed_integer_like<_Bound>))
     iota_view(_Winc, _Bound) -> iota_view<_Winc, _Bound>;
 
+  template<weakly_incrementable _Winc, semiregular _Bound>
+    inline constexpr bool enable_safe_range<iota_view<_Winc, _Bound>> = true;
+
 namespace views
 {
   template<typename _Tp>
diff --git a/libstdc++-v3/include/std/span b/libstdc++-v3/include/std/span
index c71f8bc..f215dec 100644
--- a/libstdc++-v3/include/std/span
+++ b/libstdc++-v3/include/std/span
@@ -399,16 +399,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	return {this->data() + __offset, __count};
       }
 
-      // observers: range helpers
-
-      friend constexpr iterator
-      begin(span __sp) noexcept
-      { return __sp.begin(); }
-
-      friend constexpr iterator
-      end(span __sp) noexcept
-      { return __sp.end(); }
-
     private:
       [[no_unique_address]] __detail::__extent_storage<extent> _M_extent;
       pointer _M_ptr;
@@ -478,6 +468,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       using type = _Type;
     };
 
+  namespace ranges
+  {
+    template<typename> extern inline const bool enable_safe_range;
+    // Opt-in to safe_range concept
+    template<typename _ElementType, size_t _Extent>
+      inline constexpr bool
+	enable_safe_range<span<_ElementType, _Extent>> = true;
+  }
 _GLIBCXX_END_NAMESPACE_VERSION
 } // namespace std
 #endif // concepts
diff --git a/libstdc++-v3/include/std/string_view b/libstdc++-v3/include/std/string_view
index 9d2a8e8..add432b 100644
--- a/libstdc++-v3/include/std/string_view
+++ b/libstdc++-v3/include/std/string_view
@@ -724,6 +724,16 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   } // namespace string_literals
   } // namespace literals
 
+#if __cpp_lib_concepts
+  namespace ranges
+  {
+    template<typename> extern inline const bool enable_safe_range;
+    // Opt-in to safe_range concept
+    template<typename _CharT, typename _Traits>
+      inline constexpr bool
+	enable_safe_range<basic_string_view<_CharT, _Traits>> = true;
+  }
+#endif
 _GLIBCXX_END_NAMESPACE_VERSION
 } // namespace std