[libc++] Implement views::all_t and ranges::viewable_range

[• Quuxplusone]

LGTM % comments.

libcxx/test/std/ranges/range.adaptors/range.all/all_t.compile.pass.cpp

35–36

I'd test BorrowableRange& and BorrowableRange const& right here, as well.

libcxx/test/std/ranges/range.req/range.refinements/viewable_range.compile.pass.cpp

109

s/T7/T7&/ here

115

struct T8 : test_range<cpp20_input_iterator> {
  T8(T8 const&) = delete;
};
static_assert(std::ranges::range<T8>);
static_assert(!std::ranges::view<T8>);
static_assert(!std::constructible_from<T8, T8>);
static_assert(!std::ranges::borrowed_range<T8>);

static_assert(!std::ranges::viewable_range<T8>);

120

Maybe test int[] and int[10] as well?

[ldionne]

libcxx/test/std/ranges/range.req/range.refinements/viewable_range.compile.pass.cpp

109

Hmm, are you sure about that? In all those places, I'm checking whether ranges::view<remove_cvref_t<T>> is satisfied. Here, remove_cvref_t<T> is T7, not T7&.

115

Indeed 😅. I guess I got thinking too hard and missed the obvious.

[ldionne]

Address Arthur's comments.

[• Quuxplusone]

libcxx/test/std/ranges/range.req/range.refinements/viewable_range.compile.pass.cpp

109

Ah, okay, I see what you're doing now. This is subtler than I'd like. I started to suggest that you might like to rewrite all 8 test cases in the form

{
  struct Tn { ... };
  using X = Tn;  // or Tn& as appropriate
  static_assert([! ]std::ranges::range<X>);
  static_assert([! ]std::ranges::view<std::remove_cvref_t<X>>);
  static_assert([! ]std::constructible_from<std::remove_cvref_t<X>, X>>);
  static_assert([! ]std::borrowed_range<X>>);
  static_assert([! ]std::viewable_range<X>>);
}

However, this is troublesome for the types like T2 and T2 that need to specialize std::enable_borrowed_range; you can't do that with a function-local struct type. So I have no great suggestion here.

Btw, does at least one of these tests fail when you go into <__ranges/concepts.h> and change each instance of remove_cvref_t to remove_reference_t? How about decay_t?

[ldionne]

libcxx/test/std/ranges/range.req/range.refinements/viewable_range.compile.pass.cpp

109

Ah, okay, I see what you're doing now. This is subtler than I'd like.

I agree. I thought about doing something like what you suggest, but I encountered issues with needing to specialize borrowed_range that made the whole thing difficult to digest.

Btw, does at least one of these tests fail when you go into <__ranges/concepts.h> and change each instance of remove_cvref_t to remove_reference_t?

Yes, except for the constructible_from requirement, where changing from remove_cvref_t to remove_reference_t doesn't make a difference.

How about decay_t?

No, nothing fails. However, decay differs from remove_cvref_t in that it turns arrays into pointers, and functions into pointers-to-functions. In both cases, the original types (before decay_t) won't satisfy viewable_range, and wouldn't satisfy viewable_range after decay_t. So I don't think it's observable -- we could use decay_t in the implementation and we'd still be conforming. LMK if you think I'm mistaken.

[ldionne]

Try to mitigate Arthur's concerns

[ldionne]

Rebase onto main for CI.

[ldionne]

Rebase onto main for CI.

libcxx/docs/Status/RangesPaper.csv

 | `ranges::view_base <https://llvm.org/D101547>`_
 | `ranges::view <https://llvm.org/D101547>`_",[range.range],Louis Dionne,✅
 `[range.refinements] <http://wg21.link/range.refinements>`_,"| ranges::output_range
 | `ranges::input_range <https://llvm.org/D100271>`_
 | `ranges::forward_range: `D100275 <https://llvm.org/D100275>`_
 | `ranges::bidirectional_range <https://llvm.org/D100278>`_
 | `ranges::random_access_range <https://llvm.org/D101316>`_
 | ranges::contiguous_range
-| `ranges::common_range <https://llvm.org/D100269>`_
-| ranges::viewable_range",[range.range],Christopher Di Bella,In progress
+| `ranges::common_range <https://llvm.org/D100269>`_",[range.range],Christopher Di Bella,✅
+`[range.refinements]`_,`ranges::viewable_range <https://reviews.llvm.org/D105816>`_,[range.range],Louis Dionne,✅
 `[range.utility.helpers] <http://wg21.link/range.utility.helpers>`_,"| *simple-view*
 | *has-arrow*
 | *not-same-as*","| [range.range]
 | [iterator.concept.input]",Zoe Carver,✅
 `[view.interface] <http://wg21.link/view.interface>`_,"`ranges::view_interface <https://llvm.org/D101737>`_","| [ranges.range]
 | [range.view]
 | [range.iterator.op.prev]
 | [range.refinements]",Zoe Carver,✅

libcxx/include/__ranges/all.h

 #include <__config>
 #include <__iterator/concepts.h>
 #include <__iterator/iterator_traits.h>
 #include <__ranges/access.h>
 #include <__ranges/concepts.h>
 #include <__ranges/ref_view.h>
 #include <__ranges/subrange.h>
 #include <__utility/__decay_copy.h>
+#include <__utility/declval.h>
 #include <__utility/forward.h>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
struct __fn {
     }
   };
 }
 
 inline namespace __cpo {
   inline constexpr auto all = __all::__fn{};
 } // namespace __cpo
 
+template<ranges::viewable_range _Range>
+using all_t = decltype(views::all(declval<_Range>()));
+
 } // namespace views
 
 #endif // !defined(_LIBCPP_HAS_NO_RANGES)
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP___RANGES_ALL_H

libcxx/include/__ranges/concepts.h

concept contiguous_range =
     random_access_range<_Tp> &&
     contiguous_iterator<iterator_t<_Tp>> &&
     requires(_Tp& __t) {
       { ranges::data(__t) } -> same_as<add_pointer_t<range_reference_t<_Tp>>>;
     };
 
   template <class _Tp>
   concept common_range = range<_Tp> && same_as<iterator_t<_Tp>, sentinel_t<_Tp> >;
+
+  template<class _Tp>
+  concept viewable_range =
+    range<_Tp> && (
+      (view<remove_cvref_t<_Tp>> && constructible_from<remove_cvref_t<_Tp>, _Tp>) ||
+      (!view<remove_cvref_t<_Tp>> && borrowed_range<_Tp>)
+    );
 } // namespace ranges
 
 #endif // !defined(_LIBCPP_HAS_NO_RANGES)
 
 // clang-format on
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP___RANGES_CONCEPTS_H

libcxx/include/__ranges/drop_view.h

public:
     { return __size(*this); }
 
     constexpr auto size() const
       requires sized_range<const _View>
     { return __size(*this); }
   };
 
   template<class _Range>
-  drop_view(_Range&&, range_difference_t<_Range>)
-  // TODO: this is just recreating all_t.
-    -> drop_view<decltype(views::all(std::declval<_Range>()))>;
+  drop_view(_Range&&, range_difference_t<_Range>) -> drop_view<views::all_t<_Range>>;
 
   template<class _Tp>
   inline constexpr bool enable_borrowed_range<drop_view<_Tp>> = enable_borrowed_range<_Tp>;
 
 } // namespace ranges
 
 #endif // !defined(_LIBCPP_HAS_NO_RANGES)
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP___RANGES_DROP_VIEW_H

libcxx/include/__ranges/transform_view.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_TRANSFORM_VIEW_H
 #define _LIBCPP___RANGES_TRANSFORM_VIEW_H
 
 #include <__config>
-#include <__iterator/iterator_traits.h>
 #include <__iterator/concepts.h>
 #include <__iterator/iter_swap.h>
+#include <__iterator/iterator_traits.h>
 #include <__ranges/access.h>
+#include <__ranges/all.h>
 #include <__ranges/concepts.h>
 #include <__ranges/copyable_box.h>
 #include <__ranges/empty.h>
 #include <__ranges/view_interface.h>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
public:
   {
     return __iterator<true>(*this, ranges::end(__base_));
   }
 
   constexpr auto size() requires sized_range<_View> { return ranges::size(__base_); }
   constexpr auto size() const requires sized_range<const _View> { return ranges::size(__base_); }
 };
 
-// TODO: replace the decltype with all_t when that's implemented.
 template<class _Range, class _Fn>
-transform_view(_Range&&, _Fn)
-  -> transform_view<decltype(views::all(std::declval<_Range>())), _Fn>;
+transform_view(_Range&&, _Fn) -> transform_view<views::all_t<_Range>, _Fn>;
 
 template<class _View>
 struct __transform_view_iterator_concept { using type = input_iterator_tag; };
 
 template<random_access_range _View>
 struct __transform_view_iterator_concept<_View> { using type = random_access_iterator_tag; };
 
 template<bidirectional_range _View>

libcxx/include/ranges

template<range R>
     using range_difference_t = iter_difference_t<iterator_t<R>>;
   template<range R>
     using range_value_t = iter_value_t<iterator_t<R>>;
   template<range R>
     using range_reference_t = iter_reference_t<iterator_t<R>>;
   template<range R>
     using range_rvalue_reference_t = iter_rvalue_reference_t<iterator_t<R>>;
 
-  // [range.sized]
+  // [range.sized], sized ranges
   template<class>
     inline constexpr bool disable_sized_range = false;
 
   template<class T>
     concept sized_range = ...;
 
   // [range.view], views
   template<class T>
namespace std::ranges {
   concept random_access_range = see below;
 
   template<class T>
   concept contiguous_range = see below;
 
   template <class _Tp>
     concept common_range = see below;
 
+  template<class T>
+  concept viewable_range = see below;
+
   // [view.interface], class template view_interface
   template<class D>
     requires is_class_v<D> && same_as<D, remove_cv_t<D>>
   class view_interface;
 
   // [range.empty], empty view
   template<class T>
     requires is_object_v<T>
   class empty_view;
 
+  // [range.all], all view
+  namespace views {
+    inline constexpr unspecified all = unspecified;
+
+    template<viewable_range R>
+      using all_t = decltype(all(declval<R>()));
+  }
+
+  template<range R>
+    requires is_object_v<R>
+  class ref_view;
+
+  template<class T>
+    inline constexpr bool enable_borrowed_range<ref_view<T>> = true;
+
   // [range.drop], drop view
   template<view V>
     class drop_view;
 
   template<class T>
     inline constexpr bool enable_borrowed_range<drop_view<T>> = enable_borrowed_range<T>;
 
   // [range.transform], transform view

libcxx/test/std/containers/associative/map/range_concept_conformance.compile.pass.cpp

 
 static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
 static_assert(stdr::common_range<range>);
 static_assert(stdr::bidirectional_range<range>);
 static_assert(!stdr::view<range>);
 static_assert(!stdr::random_access_range<range>);
 static_assert(stdr::sized_range<range>);
 static_assert(!stdr::borrowed_range<range>);
+static_assert(!stdr::viewable_range<range>);
 
 static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
 static_assert(stdr::common_range<range const>);
 static_assert(stdr::bidirectional_range<range const>);
 static_assert(!stdr::view<range const>);
 static_assert(!stdr::random_access_range<range const>);
 static_assert(stdr::sized_range<range const>);
 static_assert(!stdr::borrowed_range<range const>);
+static_assert(!stdr::viewable_range<range const>);

libcxx/test/std/containers/associative/multimap/range_concept_conformance.compile.pass.cpp

 
 static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
 static_assert(stdr::common_range<range>);
 static_assert(stdr::bidirectional_range<range>);
 static_assert(!stdr::view<range>);
 static_assert(!stdr::random_access_range<range>);
 static_assert(stdr::sized_range<range>);
 static_assert(!stdr::borrowed_range<range>);
+static_assert(!stdr::viewable_range<range>);
 
 static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
 static_assert(stdr::common_range<range const>);
 static_assert(stdr::bidirectional_range<range const>);
 static_assert(!stdr::view<range const>);
 static_assert(!stdr::random_access_range<range const>);
 static_assert(stdr::sized_range<range const>);
 static_assert(!stdr::borrowed_range<range const>);
+static_assert(!stdr::viewable_range<range const>);

libcxx/test/std/containers/associative/multiset/range_concept_conformance.compile.pass.cpp

 
 static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
 static_assert(stdr::common_range<range>);
 static_assert(stdr::bidirectional_range<range>);
 static_assert(!stdr::view<range>);
 static_assert(!stdr::random_access_range<range>);
 static_assert(stdr::sized_range<range>);
 static_assert(!stdr::borrowed_range<range>);
+static_assert(!stdr::viewable_range<range>);
 
 static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
 static_assert(stdr::common_range<range const>);
 static_assert(stdr::bidirectional_range<range const>);
 static_assert(!stdr::view<range const>);
 static_assert(!stdr::random_access_range<range const>);
 static_assert(stdr::sized_range<range const>);
 static_assert(!stdr::borrowed_range<range const>);
+static_assert(!stdr::viewable_range<range const>);

libcxx/test/std/containers/associative/set/range_concept_conformance.compile.pass.cpp

 static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
 static_assert(stdr::bidirectional_range<range>);
 static_assert(!stdr::random_access_range<range>);
 static_assert(stdr::common_range<range>);
 static_assert(stdr::input_range<range>);
 static_assert(!stdr::view<range>);
 static_assert(stdr::sized_range<range>);
 static_assert(!stdr::borrowed_range<range>);
+static_assert(!stdr::viewable_range<range>);
 
 static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
 static_assert(stdr::bidirectional_range<range const>);
 static_assert(!stdr::random_access_range<range const>);
 static_assert(stdr::common_range<range const>);
 static_assert(stdr::input_range<range>);
 static_assert(!stdr::view<range const>);
 static_assert(stdr::sized_range<range const>);
 static_assert(!stdr::borrowed_range<range const>);
+static_assert(!stdr::viewable_range<range const>);

libcxx/test/std/containers/sequences/array/range_concept_conformance.compile.pass.cpp

 
 static_assert(!stdr::view<range>);
 static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
 static_assert(stdr::common_range<range>);
 static_assert(stdr::random_access_range<range>);
 static_assert(stdr::contiguous_range<range>);
 static_assert(stdr::sized_range<range>);
 static_assert(!stdr::borrowed_range<range>);
+static_assert(!stdr::viewable_range<range>);
 
 static_assert(!stdr::view<range const>);
 static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
 static_assert(stdr::common_range<range const>);
 static_assert(stdr::random_access_range<range const>);
 static_assert(stdr::contiguous_range<range const>);
 static_assert(stdr::sized_range<range const>);
 static_assert(!stdr::borrowed_range<range const>);
+static_assert(!stdr::viewable_range<range const>);

libcxx/test/std/containers/sequences/deque/range_concept_conformance.compile.pass.cpp

 
 static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
 static_assert(stdr::common_range<range>);
 static_assert(stdr::random_access_range<range>);
 static_assert(!stdr::contiguous_range<range>);
 static_assert(!stdr::view<range>);
 static_assert(stdr::sized_range<range>);
 static_assert(!stdr::borrowed_range<range>);
+static_assert(!stdr::viewable_range<range>);
 
 static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
 static_assert(stdr::common_range<range const>);
 static_assert(stdr::random_access_range<range const>);
 static_assert(!stdr::contiguous_range<range const>);
 static_assert(!stdr::view<range const>);
 static_assert(stdr::sized_range<range const>);
 static_assert(!stdr::borrowed_range<range const>);
+static_assert(!stdr::viewable_range<range const>);

libcxx/test/std/containers/sequences/forwardlist/range_concept_conformance.compile.pass.cpp

 
 static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
 static_assert(stdr::common_range<range>);
 static_assert(stdr::forward_range<range>);
 static_assert(!stdr::bidirectional_range<range>);
 static_assert(!stdr::view<range>);
 static_assert(!stdr::sized_range<range>);
 static_assert(!stdr::borrowed_range<range>);
+static_assert(!stdr::viewable_range<range>);
 
 static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
 static_assert(stdr::common_range<range const>);
 static_assert(stdr::forward_range<range const>);
 static_assert(!stdr::bidirectional_range<range const>);
 static_assert(!stdr::view<range const>);
 static_assert(!stdr::sized_range<range const>);
 static_assert(!stdr::borrowed_range<range const>);
+static_assert(!stdr::viewable_range<range const>);

libcxx/test/std/containers/sequences/list/range_concept_conformance.compile.pass.cpp

 
 static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
 static_assert(stdr::common_range<range>);
 static_assert(stdr::bidirectional_range<range>);
 static_assert(!stdr::view<range>);
 static_assert(!stdr::random_access_range<range>);
 static_assert(stdr::sized_range<range>);
 static_assert(!stdr::borrowed_range<range>);
+static_assert(!stdr::viewable_range<range>);
 
 static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
 static_assert(stdr::common_range<range const>);
 static_assert(stdr::bidirectional_range<range const>);
 static_assert(!stdr::view<range const>);
 static_assert(!stdr::random_access_range<range const>);
 static_assert(stdr::sized_range<range const>);
 static_assert(!stdr::borrowed_range<range const>);
+static_assert(!stdr::viewable_range<range const>);

libcxx/test/std/containers/sequences/vector.bool/range_concept_conformance.compile.pass.cpp

 
 static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
 static_assert(stdr::common_range<range>);
 static_assert(stdr::random_access_range<range>);
 static_assert(!stdr::contiguous_range<range>);
 static_assert(!stdr::view<range>);
 static_assert(stdr::sized_range<range>);
 static_assert(!stdr::borrowed_range<range>);
+static_assert(!stdr::viewable_range<range>);
 
 static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
 static_assert(stdr::common_range<range const>);
 static_assert(stdr::random_access_range<range const>);
 static_assert(!stdr::contiguous_range<range const>);
 static_assert(!stdr::view<range const>);
 static_assert(stdr::sized_range<range const>);
 static_assert(!stdr::borrowed_range<range const>);
+static_assert(!stdr::viewable_range<range const>);

libcxx/test/std/containers/sequences/vector/range_concept_conformance.compile.pass.cpp

 
 static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
 static_assert(stdr::common_range<range>);
 static_assert(stdr::random_access_range<range>);
 static_assert(stdr::contiguous_range<range>);
 static_assert(!stdr::view<range>);
 static_assert(stdr::sized_range<range>);
 static_assert(!stdr::borrowed_range<range>);
+static_assert(!stdr::viewable_range<range>);
 
 static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
 static_assert(stdr::common_range<range const>);
 static_assert(stdr::random_access_range<range const>);
 static_assert(stdr::contiguous_range<range const>);
 static_assert(!stdr::view<range const>);
 static_assert(stdr::sized_range<range const>);
 static_assert(!stdr::borrowed_range<range const>);
+static_assert(!stdr::viewable_range<range const>);

libcxx/test/std/containers/unord/unord.map/range_concept_conformance.compile.pass.cpp

 
 static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
 static_assert(stdr::common_range<range>);
 static_assert(stdr::forward_range<range>);
 static_assert(!stdr::bidirectional_range<range>);
 static_assert(!stdr::view<range>);
 static_assert(stdr::sized_range<range>);
 static_assert(!stdr::borrowed_range<range>);
+static_assert(!stdr::viewable_range<range>);
 
 static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
 static_assert(stdr::common_range<range const>);
 static_assert(stdr::forward_range<range const>);
 static_assert(!stdr::bidirectional_range<range const>);
 static_assert(!stdr::view<range const>);
 static_assert(stdr::sized_range<range const>);
 static_assert(!stdr::borrowed_range<range const>);
+static_assert(!stdr::viewable_range<range const>);

libcxx/test/std/containers/unord/unord.multimap/range_concept_conformance.compile.pass.cpp

 
 static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
 static_assert(stdr::common_range<range>);
 static_assert(stdr::forward_range<range>);
 static_assert(!stdr::bidirectional_range<range>);
 static_assert(!stdr::view<range>);
 static_assert(stdr::sized_range<range>);
 static_assert(!stdr::borrowed_range<range>);
+static_assert(!stdr::viewable_range<range>);
 
 static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
 static_assert(stdr::common_range<range const>);
 static_assert(stdr::forward_range<range const>);
 static_assert(!stdr::bidirectional_range<range const>);
 static_assert(!stdr::view<range const>);
 static_assert(stdr::sized_range<range const>);
 static_assert(!stdr::borrowed_range<range const>);
+static_assert(!stdr::viewable_range<range const>);

libcxx/test/std/containers/unord/unord.multiset/range_concept_conformance.compile.pass.cpp

 
 static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
 static_assert(stdr::common_range<range>);
 static_assert(stdr::forward_range<range>);
 static_assert(!stdr::bidirectional_range<range>);
 static_assert(!stdr::view<range>);
 static_assert(stdr::sized_range<range>);
 static_assert(!stdr::borrowed_range<range>);
+static_assert(!stdr::viewable_range<range>);
 
 static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
 static_assert(stdr::common_range<range const>);
 static_assert(stdr::forward_range<range const>);
 static_assert(!stdr::bidirectional_range<range const>);
 static_assert(!stdr::view<range const>);
 static_assert(stdr::sized_range<range const>);
 static_assert(!stdr::borrowed_range<range const>);
+static_assert(!stdr::viewable_range<range const>);

libcxx/test/std/containers/unord/unord.set/range_concept_conformance.compile.pass.cpp

 
 static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
 static_assert(stdr::common_range<range>);
 static_assert(stdr::forward_range<range>);
 static_assert(!stdr::bidirectional_range<range>);
 static_assert(!stdr::view<range>);
 static_assert(stdr::sized_range<range>);
 static_assert(!stdr::borrowed_range<range>);
+static_assert(!stdr::viewable_range<range>);
 
 static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
 static_assert(stdr::common_range<range const>);
 static_assert(stdr::forward_range<range const>);
 static_assert(!stdr::bidirectional_range<range const>);
 static_assert(!stdr::view<range const>);
 static_assert(stdr::sized_range<range const>);
 static_assert(!stdr::borrowed_range<range const>);
+static_assert(!stdr::viewable_range<range const>);

libcxx/test/std/containers/views/range_concept_conformance.compile.pass.cpp

 
 static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
 static_assert(stdr::common_range<range>);
 static_assert(stdr::random_access_range<range>);
 static_assert(stdr::contiguous_range<range>);
 static_assert(stdr::view<range> && stdr::enable_view<range>);
 static_assert(stdr::sized_range<range>);
 static_assert(stdr::borrowed_range<range>);
+static_assert(stdr::viewable_range<range>);
 
 static_assert(std::same_as<stdr::iterator_t<range const>, range::iterator>);
 static_assert(stdr::common_range<range const>);
 static_assert(stdr::random_access_range<range const>);
 static_assert(stdr::contiguous_range<range const>);
 static_assert(!stdr::view<range const> && !stdr::enable_view<range const>);
 static_assert(stdr::sized_range<range const>);
 static_assert(stdr::borrowed_range<range const>);
+static_assert(stdr::viewable_range<range const>);

libcxx/test/std/input.output/filesystems/class.directory_iterator/range_concept_conformance.compile.pass.cpp

 namespace stdr = std::ranges;
 
 static_assert(std::same_as<stdr::iterator_t<fs::directory_iterator>, fs::directory_iterator>);
 static_assert(stdr::common_range<fs::directory_iterator>);
 static_assert(stdr::input_range<fs::directory_iterator>);
 static_assert(!stdr::view<fs::directory_iterator>);
 static_assert(!stdr::sized_range<fs::directory_iterator>);
 static_assert(!stdr::borrowed_range<fs::directory_iterator>);
+static_assert(!stdr::viewable_range<fs::directory_iterator>);
 
 static_assert(std::same_as<stdr::iterator_t<fs::directory_iterator const>, fs::directory_iterator>);
 static_assert(stdr::common_range<fs::directory_iterator const>);
 static_assert(stdr::input_range<fs::directory_iterator const>);
 static_assert(!stdr::view<fs::directory_iterator const>);
 static_assert(!stdr::sized_range<fs::directory_iterator const>);
 static_assert(!stdr::borrowed_range<fs::directory_iterator const>);
+static_assert(!stdr::viewable_range<fs::directory_iterator const>);
 
 static_assert(std::same_as<stdr::iterator_t<fs::recursive_directory_iterator>, fs::recursive_directory_iterator>);
 static_assert(stdr::common_range<fs::recursive_directory_iterator>);
 static_assert(stdr::input_range<fs::recursive_directory_iterator>);
 static_assert(!stdr::view<fs::recursive_directory_iterator>);
 static_assert(!stdr::sized_range<fs::recursive_directory_iterator>);
 static_assert(!stdr::borrowed_range<fs::recursive_directory_iterator>);
+static_assert(!stdr::viewable_range<fs::recursive_directory_iterator>);
 
 static_assert(std::same_as<stdr::iterator_t<fs::recursive_directory_iterator const>, fs::recursive_directory_iterator>);
 static_assert(stdr::common_range<fs::recursive_directory_iterator const>);
 static_assert(stdr::input_range<fs::recursive_directory_iterator const>);
 static_assert(!stdr::view<fs::recursive_directory_iterator const>);
 static_assert(!stdr::sized_range<fs::recursive_directory_iterator const>);
 static_assert(!stdr::borrowed_range<fs::recursive_directory_iterator const>);
+static_assert(!stdr::viewable_range<fs::recursive_directory_iterator const>);

libcxx/test/std/input.output/filesystems/class.path/range_concept_conformance.compile.pass.cpp

 
 static_assert(std::same_as<stdr::iterator_t<fs::path>, fs::path::iterator>);
 static_assert(stdr::common_range<fs::path>);
 static_assert(stdr::bidirectional_range<fs::path>);
 static_assert(!stdr::view<fs::path>);
 static_assert(!stdr::random_access_range<fs::path>);
 static_assert(!stdr::sized_range<fs::path>);
 static_assert(!stdr::borrowed_range<fs::path>);
+static_assert(!stdr::viewable_range<fs::path>);
 
 static_assert(std::same_as<stdr::iterator_t<fs::path const>, fs::path::const_iterator>);
 static_assert(stdr::common_range<fs::path const>);
 static_assert(stdr::bidirectional_range<fs::path const>);
 static_assert(!stdr::view<fs::path const>);
 static_assert(!stdr::random_access_range<fs::path const>);
 static_assert(!stdr::sized_range<fs::path const>);
 static_assert(!stdr::borrowed_range<fs::path const>);
+static_assert(!stdr::viewable_range<fs::path const>);

libcxx/test/std/ranges/range.adaptors/range.all/all.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-no-concepts
 // UNSUPPORTED: gcc-10
 
 // std::views::all;
 
 #include <ranges>
 
 #include <cassert>
 #include "test_macros.h"
 #include "test_iterators.h"
 
 int globalBuff[8];
 
 template<bool IsNoexcept>
 struct View : std::ranges::view_base {
   int start_ = 0;
   explicit View() noexcept(IsNoexcept) = default;
   constexpr explicit View(int start) : start_(start) {}
   View(View&&) noexcept(IsNoexcept) = default;
   View& operator=(View&&) noexcept(IsNoexcept) = default;
   constexpr friend int* begin(View& view) { return globalBuff + view.start_; }
   constexpr friend int* begin(View const& view) { return globalBuff + view.start_; }
   constexpr friend int* end(View&) { return globalBuff + 8; }
   constexpr friend int* end(View const&) { return globalBuff + 8; }
 };
 static_assert(std::ranges::view<View<true>>);
 static_assert(std::ranges::view<View<false>>);
 
 template<bool IsNoexcept>
 struct CopyableView : std::ranges::view_base {
   int start_ = 0;
   explicit CopyableView() noexcept(IsNoexcept) = default;
   CopyableView(CopyableView const&) noexcept(IsNoexcept) = default;
   CopyableView& operator=(CopyableView const&) noexcept(IsNoexcept) = default;
   constexpr explicit CopyableView(int start) noexcept : start_(start) {}
   constexpr friend int* begin(CopyableView& view) { return globalBuff + view.start_; }
   constexpr friend int* begin(CopyableView const& view) { return globalBuff + view.start_; }
   constexpr friend int* end(CopyableView&) { return globalBuff + 8; }
   constexpr friend int* end(CopyableView const&) { return globalBuff + 8; }
 };
 static_assert(std::ranges::view<CopyableView<true>>);
 static_assert(std::ranges::view<CopyableView<false>>);
 
 struct Range {
   int start_;
   constexpr explicit Range(int start) noexcept : start_(start) {}
   constexpr friend int* begin(Range const& range) { return globalBuff + range.start_; }
   constexpr friend int* begin(Range& range) { return globalBuff + range.start_; }
   constexpr friend int* end(Range const&) { return globalBuff + 8; }
   constexpr friend int* end(Range&) { return globalBuff + 8; }
 };
 
 struct BorrowableRange {
   int start_;
   constexpr explicit BorrowableRange(int start) noexcept : start_(start) {}
   constexpr friend int* begin(BorrowableRange const& range) { return globalBuff + range.start_; }
   constexpr friend int* begin(BorrowableRange& range) { return globalBuff + range.start_; }
   constexpr friend int* end(BorrowableRange const&) { return globalBuff + 8; }
   constexpr friend int* end(BorrowableRange&) { return globalBuff + 8; }
 };
 template<>
 inline constexpr bool std::ranges::enable_borrowed_range<BorrowableRange> = true;
 
 struct RandomAccessRange {
   struct sentinel {
     friend constexpr bool operator==(sentinel, const random_access_iterator<int*> rai) { return rai.base() == globalBuff + 8; }
     friend constexpr std::ptrdiff_t operator-(sentinel, random_access_iterator<int*>) { return -8; }
     friend constexpr std::ptrdiff_t operator-(random_access_iterator<int*>, sentinel) { return 8; }
   };
 
   constexpr random_access_iterator<int*> begin() { return random_access_iterator<int*>{globalBuff}; }
   constexpr sentinel end() { return {}; }
 };
 template<>
 inline constexpr bool std::ranges::enable_borrowed_range<RandomAccessRange> = true;
 
 constexpr bool test() {
   {
     ASSERT_SAME_TYPE(decltype(std::views::all(View<true>())), View<true>);
     static_assert(noexcept(std::views::all(View<true>())));
     static_assert(!noexcept(std::views::all(View<false>())));
 
     auto viewCopy = std::views::all(View<true>(2));
     ASSERT_SAME_TYPE(decltype(viewCopy), View<true>);
     assert(std::ranges::begin(viewCopy) == globalBuff + 2);
     assert(std::ranges::end(viewCopy) == globalBuff + 8);
   }
 
   {
     ASSERT_SAME_TYPE(decltype(std::views::all(std::declval<const CopyableView<true>&>())), CopyableView<true>);
     static_assert(noexcept(std::views::all(CopyableView<true>())));
     static_assert(!noexcept(std::views::all(CopyableView<false>())));
 
     CopyableView<true> view(2);
     auto viewCopy = std::views::all(view);
     ASSERT_SAME_TYPE(decltype(viewCopy), CopyableView<true>);
     assert(std::ranges::begin(viewCopy) == globalBuff + 2);
     assert(std::ranges::end(viewCopy) == globalBuff + 8);
   }
 
   {
     Range range(2);
     auto ref = std::views::all(range);
     ASSERT_SAME_TYPE(decltype(ref), std::ranges::ref_view<Range>);
     assert(std::ranges::begin(ref) == globalBuff + 2);
     assert(std::ranges::end(ref) == globalBuff + 8);
 
     static_assert(!std::is_invocable_v<decltype(std::views::all), Range>);
   }
 
   {
     const Range range(2);
     auto ref = std::views::all(range);
     static_assert(!noexcept(std::views::all(range)));
     ASSERT_SAME_TYPE(decltype(ref), std::ranges::ref_view<const Range>);
     assert(std::ranges::begin(ref) == globalBuff + 2);
     assert(std::ranges::end(ref) == globalBuff + 8);
   }
 
   {
     auto subrange = std::views::all(BorrowableRange(2));
     static_assert(!noexcept(std::views::all(BorrowableRange(2))));
     ASSERT_SAME_TYPE(decltype(subrange), std::ranges::subrange<int*>);
     assert(std::ranges::begin(subrange) == globalBuff + 2);
     assert(std::ranges::end(subrange) == globalBuff + 8);
   }
 
   {
     auto subrange = std::views::all(RandomAccessRange());
     ASSERT_SAME_TYPE(decltype(subrange),
                      std::ranges::subrange<random_access_iterator<int*>, RandomAccessRange::sentinel>);
     assert(std::ranges::begin(subrange).base() == globalBuff);
     assert(std::ranges::end(subrange) == std::ranges::begin(subrange) + 8);
   }
 
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

libcxx/test/std/ranges/range.adaptors/range.all/all_t.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// template<viewable_range R>
+// using all_t = decltype(views::all(declval<R>()));
+
+#include <ranges>
+
+#include "test_iterators.h"
+#include "test_range.h"
+
+struct View : test_range<cpp20_input_iterator>, std::ranges::view_base { };
+struct Range : test_range<cpp20_input_iterator> { };
+struct BorrowableRange : test_range<forward_iterator> { };
+template<>
+inline constexpr bool std::ranges::enable_borrowed_range<BorrowableRange> = true;
+
+// When T is a view, returns decay-copy(T)
+ASSERT_SAME_TYPE(std::views::all_t<View>, View);
+ASSERT_SAME_TYPE(std::views::all_t<View&>, View);
+ASSERT_SAME_TYPE(std::views::all_t<View const>, View);
+ASSERT_SAME_TYPE(std::views::all_t<View const&>, View);
+
+// Otherwise, when T is a reference to a range, returns ref_view<T>
+ASSERT_SAME_TYPE(std::views::all_t<Range&>, std::ranges::ref_view<Range>);
+ASSERT_SAME_TYPE(std::views::all_t<Range const&>, std::ranges::ref_view<Range const>);
+ASSERT_SAME_TYPE(std::views::all_t<BorrowableRange&>, std::ranges::ref_view<BorrowableRange>);
+ASSERT_SAME_TYPE(std::views::all_t<BorrowableRange const&>, std::ranges::ref_view<BorrowableRange const>);
+
+// Otherwise, returns subrange<iterator_t<T>, sentinel_t<R>>
+ASSERT_SAME_TYPE(std::views::all_t<BorrowableRange>, std::ranges::subrange<forward_iterator<int*>, sentinel>);
+ASSERT_SAME_TYPE(std::views::all_t<BorrowableRange const>, std::ranges::subrange<forward_iterator<int const*>, sentinel>);

libcxx/test/std/ranges/range.adaptors/range.ref.view.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-no-concepts
 // UNSUPPORTED: gcc-10
 
-// std::ranges::ref_view
+// template<range R>
+//  requires is_object_v<R>
+// class ref_view;
 
 #include <ranges>
 
 #include <cassert>
 #include "test_macros.h"
 #include "test_iterators.h"
 
 int globalBuff[8];

libcxx/test/std/ranges/range.req/range.refinements/viewable_range.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// template<class R>
+// concept viewable_range;
+
+#include <ranges>
+
+#include "test_iterators.h"
+#include "test_range.h"
+
+// The constraints we have in viewable_range are:
+//  range<T>
+//  view<remove_cvref_t<T>>
+//  constructible_from<remove_cvref_t<T>, T>
+//  borrowed_range<T>
+//
+// We test all the relevant combinations of satisfying/not satisfying those constraints.
+
+// viewable_range<T> is not satisfied for (range=false, view=*, constructible_from=*, borrowed_range=*)
+struct T1 { };
+static_assert(!std::ranges::range<T1>);
+
+static_assert(!std::ranges::viewable_range<T1>);
+static_assert(!std::ranges::viewable_range<T1&>);
+static_assert(!std::ranges::viewable_range<T1 const>);
+static_assert(!std::ranges::viewable_range<T1 const&>);
+
+// viewable_range<T> is satisfied for (range=true, view=true, constructible_from=true, borrowed_range=true)
+struct T2 : test_range<cpp20_input_iterator>, std::ranges::view_base {
+  T2(T2 const&) = default;
+};
+template<> constexpr bool std::ranges::enable_borrowed_range<T2> = true;
+static_assert(std::ranges::range<T2>);
+static_assert(std::ranges::view<T2>);
+static_assert(std::constructible_from<T2, T2>);
+static_assert(std::ranges::borrowed_range<T2>);
+
+static_assert(std::ranges::viewable_range<T2>);
+static_assert(std::ranges::viewable_range<T2&>);
+static_assert(std::ranges::viewable_range<T2 const>);
+static_assert(std::ranges::viewable_range<T2 const&>);
+
+// viewable_range<T> is satisfied for (range=true, view=true, constructible_from=true, borrowed_range=false)
+struct T3 : test_range<cpp20_input_iterator>, std::ranges::view_base {
+  T3(T3 const&) = default;
+};
+template<> constexpr bool std::ranges::enable_borrowed_range<T3> = false;
+static_assert(std::ranges::range<T3>);
+static_assert(std::ranges::view<T3>);
+static_assert(std::constructible_from<T3, T3>);
+static_assert(!std::ranges::borrowed_range<T3>);
+
+static_assert(std::ranges::viewable_range<T3>);
+static_assert(std::ranges::viewable_range<T3&>);
+static_assert(std::ranges::viewable_range<T3 const>);
+static_assert(std::ranges::viewable_range<T3 const&>);
+
+// viewable_range<T> is not satisfied for (range=true, view=true, constructible_from=false, borrowed_range=true)
+struct T4 : test_range<cpp20_input_iterator>, std::ranges::view_base {
+  T4(T4 const&) = delete;
+  T4(T4&&) = default;             // necessary to model view
+  T4& operator=(T4&&) = default;  // necessary to model view
+};
+static_assert(std::ranges::range<T4 const&>);
+static_assert(std::ranges::view<T4>);
+static_assert(!std::constructible_from<T4, T4 const&>);
+static_assert(std::ranges::borrowed_range<T4 const&>);
+
+static_assert(!std::ranges::viewable_range<T4 const&>);
+
+// A type that satisfies (range=true, view=true, constructible_from=false, borrowed_range=false) can't be formed
+
+// viewable_range<T> is satisfied for (range=true, view=false, constructible_from=true, borrowed_range=true)
+struct T5 : test_range<cpp20_input_iterator> { };
+template<> constexpr bool std::ranges::enable_borrowed_range<T5> = true;
+static_assert(std::ranges::range<T5>);
+static_assert(!std::ranges::view<T5>);
+static_assert(std::constructible_from<T5, T5>);
+static_assert(std::ranges::borrowed_range<T5>);
+
+static_assert(std::ranges::viewable_range<T5>);
+
+// viewable_range<T> is not satisfied for (range=true, view=false, constructible_from=true, borrowed_range=false)
+struct T6 : test_range<cpp20_input_iterator> { };
+template<> constexpr bool std::ranges::enable_borrowed_range<T6> = false;
+static_assert(std::ranges::range<T6>);
+static_assert(!std::ranges::view<T6>);
+static_assert(std::constructible_from<T6, T6>);
+static_assert(!std::ranges::borrowed_range<T6>);
+
+static_assert(!std::ranges::viewable_range<T6>);
+
+// viewable_range<T> is satisfied for (range=true, view=false, constructible_from=false, borrowed_range=true)
+struct T7 : test_range<cpp20_input_iterator> {
+  T7(T7 const&) = delete;
+};
+static_assert(std::ranges::range<T7&>);
+static_assert(!std::ranges::view<T7>);
+static_assert(!std::constructible_from<T7, T7&>);
+static_assert(std::ranges::borrowed_range<T7&>);
+
+static_assert(std::ranges::viewable_range<T7&>);
+
+// A type that satisfies (range=true, view=false, constructible_from=false, borrowed_range=false) can't be formed
+struct T8 : test_range<cpp20_input_iterator> {
+  T8(T8 const&) = delete;
+};
+static_assert(std::ranges::range<T8>);
+static_assert(!std::ranges::view<T8>);
+static_assert(!std::constructible_from<T8, T8>);
+static_assert(!std::ranges::borrowed_range<T8>);
+
+static_assert(!std::ranges::viewable_range<T8>);
+
+// Test with a few degenerate types
+static_assert(!std::ranges::viewable_range<void>);
+static_assert(!std::ranges::viewable_range<int>);
+static_assert(!std::ranges::viewable_range<int (*)(char)>);
+static_assert(!std::ranges::viewable_range<int[]>);
+static_assert(!std::ranges::viewable_range<int[10]>);
+static_assert(!std::ranges::viewable_range<int(&)[]>); // unbounded array is not a range
+static_assert( std::ranges::viewable_range<int(&)[10]>);

libcxx/test/std/re/re.results/range_concept_conformance.compile.pass.cpp

 
 static_assert(std::same_as<stdr::iterator_t<std::cmatch>, std::cmatch::iterator>);
 static_assert(stdr::common_range<std::cmatch>);
 static_assert(stdr::random_access_range<std::cmatch>);
 static_assert(stdr::contiguous_range<std::cmatch>);
 static_assert(!stdr::view<std::cmatch>);
 static_assert(stdr::sized_range<std::cmatch>);
 static_assert(!stdr::borrowed_range<std::cmatch>);
+static_assert(!stdr::viewable_range<std::cmatch>);
 
 static_assert(std::same_as<stdr::iterator_t<std::cmatch const>, std::cmatch::const_iterator>);
 static_assert(stdr::common_range<std::cmatch const>);
 static_assert(stdr::random_access_range<std::cmatch const>);
 static_assert(stdr::contiguous_range<std::cmatch const>);
 static_assert(!stdr::view<std::cmatch const>);
 static_assert(stdr::sized_range<std::cmatch const>);
 static_assert(!stdr::borrowed_range<std::cmatch const>);
+static_assert(!stdr::viewable_range<std::cmatch const>);

libcxx/test/std/strings/basic.string/range_concept_conformance.compile.pass.cpp

 
 static_assert(std::same_as<stdr::iterator_t<std::string>, std::string::iterator>);
 static_assert(stdr::common_range<std::string>);
 static_assert(stdr::random_access_range<std::string>);
 static_assert(stdr::contiguous_range<std::string>);
 static_assert(!stdr::view<std::string>);
 static_assert(stdr::sized_range<std::string>);
 static_assert(!stdr::borrowed_range<std::string>);
+static_assert(!stdr::viewable_range<std::string>);
 
 static_assert(std::same_as<stdr::iterator_t<std::string const>, std::string::const_iterator>);
 static_assert(stdr::common_range<std::string const>);
 static_assert(stdr::random_access_range<std::string const>);
 static_assert(stdr::contiguous_range<std::string const>);
 static_assert(!stdr::view<std::string const>);
 static_assert(stdr::sized_range<std::string const>);
 static_assert(!stdr::borrowed_range<std::string const>);
+static_assert(!stdr::viewable_range<std::string const>);

libcxx/test/std/strings/string.view/range_concept_conformance.compile.pass.cpp

 
 static_assert(std::same_as<stdr::iterator_t<std::string_view>, std::string_view::iterator>);
 static_assert(stdr::common_range<std::string_view>);
 static_assert(stdr::random_access_range<std::string_view>);
 static_assert(stdr::contiguous_range<std::string_view>);
 static_assert(stdr::view<std::string_view> && stdr::enable_view<std::string_view>);
 static_assert(stdr::sized_range<std::string_view>);
 static_assert(stdr::borrowed_range<std::string_view>);
+static_assert(stdr::viewable_range<std::string_view>);
 
 static_assert(std::same_as<stdr::iterator_t<std::string_view const>, std::string_view::const_iterator>);
 static_assert(stdr::common_range<std::string_view const>);
 static_assert(stdr::random_access_range<std::string_view const>);
 static_assert(stdr::contiguous_range<std::string_view const>);
 static_assert(!stdr::view<std::string_view const> && !stdr::enable_view<std::string_view const>);
 static_assert(stdr::sized_range<std::string_view const>);
 static_assert(stdr::borrowed_range<std::string_view const>);
+static_assert(stdr::viewable_range<std::string_view const>);