[libcxx][ranges] adds concept `sized_range` and cleans up `ranges::size`

[cjdb]

Summary

• adds sized_range and conformance tests
• moves disable_sized_range into namespace std::ranges
• removes explicit type parameter

Implements part of P0896 'The One Ranges Proposal'.

[zoecarver]

LGTM.

libcxx/include/__ranges/concepts.h

14

How was this working before?

libcxx/test/std/ranges/range.req/range.sized/sized_range.compile.pass.cpp

24

Rvalue array?

[cjdb]

libcxx/include/__ranges/concepts.h

14

🤷

libcxx/test/std/ranges/range.req/range.sized/sized_range.compile.pass.cpp

24

That's int[5].

[• Quuxplusone]

libcxx/test/std/ranges/range.req/range.sized/sized_range.compile.pass.cpp

24

I assume Zoe was asking for xvalue (rvalue-reference) to array: int (&&)[5] and int (&&)[].

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

31–32

Unrelated to this PR, but it strikes me as odd that string_view is not a std::ranges::view.
Should you perhaps be asserting stdr::view<std::string_view&> instead?

[cjdb]

libcxx/test/std/ranges/range.req/range.sized/sized_range.compile.pass.cpp

24

This test checks that an lvalue array is a sized range and that an rvalue array is too. I'm not sure what adding a test to check an rvalue reference to an array is going to add overall that int[5] doesn't already do.

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

31–32

That would be because we haven't enabled string_view as a view yet.

[zoecarver]

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

31–32

Hmm. I think we should at least have a comment saying that this test is wrong. I'd even say we should comment out the static_assert too (and make it positive).

[Mordante]

LGTM!

libcxx/include/__ranges/concepts.h

9–10

Not part of your changes, but can you use a triple underscore? _LIBCPP_RANGES_CONCEPTS_H -> _LIBCPP___RANGES_CONCEPTS_H

libcxx/test/std/ranges/range.req/range.sized/sized_range.compile.pass.cpp

50

Why is this the only one to check stdr::range?

[• Quuxplusone]

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

31–32

@zoecarver: If we comment out the assert, we'll have to set some kind of watchdog to remind us to comment it back in, in the PR that enables string_view-as-a-view. Which will definitely fail to remind us, and then tech debt.
By keeping this "wrong" assert enabled, it serves as a regression test: it serves as its own infallible watchdog. When string_view becomes a view, buildkite will point directly at this test file, telling us that we need to flip the sense of the assert as part of the same PR. That's excellent. (And also excellent to see in the git history later, when we're wondering which commit caused string_view to become a view.)
I wouldn't mind seeing a // TODO: string_view is nonconforming comment at the end of this line, though.

A possible alternative approach (but I assume we won't block D102434 on this): first land a PR that makes string_view-a-view; then land this PR with the assert already passing.

[cjdb]

libcxx/include/__ranges/concepts.h

9–10

Will do.

14

Oh, because of transitive includes.

libcxx/test/std/ranges/range.req/range.sized/sized_range.compile.pass.cpp

50

Confirming it's a range, but not a sized range.

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

31–32

@zoecarver: If we comment out the assert, we'll have to set some kind of watchdog to remind us to comment it back in, in the PR that enables string_view-as-a-view. Which will definitely fail to remind us, and then tech debt.
By keeping this "wrong" assert enabled, it serves as a regression test: it serves as its own infallible watchdog. When string_view becomes a view, buildkite will point directly at this test file, telling us that we need to flip the sense of the assert as part of the same PR. That's excellent. (And also excellent to see in the git history later, when we're wondering which commit caused string_view to become a view.)

+1

I wouldn't mind seeing a // TODO: string_view is nonconforming comment at the end of this line, though.

A possible alternative approach (but I assume we won't block D102434 on this): first land a PR that makes string_view-a-view; then land this PR with the assert already passing.

Sure, I can add that TODO before merging (it won't appear on Phab though).

libcxx/docs/OneRangesProposalStatus.csv

 [default.sentinels],The empty std::default_sentinel_t.,,,,
 [counted.iterator],,"[iterator.concepts], [iterator.cust.swap], [iterator.cust.move], [default.sentinels]",,,
 [stream.iterators],,[default.sentinels],,,
 [ranges.syn]: pt. 1,All the stuff not specified elsewhere. ,"[range.access], [iterator.concepts], [range.all], [range.subrange], unreachable, [range.empty]",,,
 [ranges.syn]: pt. 2,"iterator_t, sentinel_t, and safe_iterator_t",[range.access],Christopher Di Bella,"`D100255 <https://llvm.org/D100255>`_, `D100269 <https://llvm.org/D100269>`_",
 [range.access],"ranges::begin, end, cbegin, cend, rbegin, rend, crbegin, and crend",[iterator.concepts],Christopher Di Bella,`D100255 <https://llvm.org/D100255>`_,
 [ranges.primitives],"size, empty, data, and cdata",[iterator.concepts],Zoe Carver,,
 [range.range],,[range.access],,,
-[range.sized],"ranges::sized_range","[range.primitives], [range.range]",Christopher Di Bella,"`D102434 <https://llvm.org/D102434>`_",
+[range.sized],"ranges::sized_range","[range.primitives], [range.range]",Christopher Di Bella,"`D102434 <https://llvm.org/D102434>`_",✅
 [range.view],View and enable_view,[range.range],Louis Dionne,https://reviews.llvm.org/D101547,✅
 [range.refinements],"OutputRange, InputRange, ForwardRange, BidirectionalRange, RandomAccessRange, ContiguousRange, CommonRange, ViewableRange","[ranges.syn]: pt. 2, [range.range]",Christopher Di Bella,"input_range: `D100271 <https://llvm.org/D100271>`_
 forward_range: `D100275 <https://llvm.org/D100275>`_
 bidirectional_range: `D100278 <https://llvm.org/D100278>`_",
 [view.interface],[range.utility.helpers] and view_interface,"[ranges.syn]: pt. 2, [range.view], [range.iterator.operations.prev], [range.refinements]",Zoe Carver,`D101737 <https://llvm.org/D101737>`_,
 [range.subrange],,[view.interface],Zoe Carver,`D102006 <https://llvm.org/D102006>`_,
 [range.all],view::all,"[range.subrange], [range.view.ref]",Zoe Carver,`D102028 <https://llvm.org/D102028>`_,
 [range.view.ref],ref-view,[view.interface],Zoe Carver,`D102020 <https://llvm.org/D102020>`_,

libcxx/include/__ranges/concepts.h

 // -*- C++ -*-
 //===--------------------- __ranges/concepts.h ----------------------------===//
 //
 // 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_CONCEPTS_H
-#define _LIBCPP_RANGES_CONCEPTS_H
+#ifndef _LIBCPP___RANGES_CONCEPTS_H
+#define _LIBCPP___RANGES_CONCEPTS_H
 
 #include <__config>
+#include <__iterator/concepts.h>
+#include <__ranges/access.h>
+#include <__ranges/size.h>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
namespace ranges {
   using range_value_t = iter_value_t<iterator_t<_Rp> >;
 
   template <range _Rp>
   using range_reference_t = iter_reference_t<iterator_t<_Rp> >;
 
   template <range _Rp>
   using range_rvalue_reference_t = iter_rvalue_reference_t<iterator_t<_Rp> >;
 
+  // [range.sized]
+  template <class _Tp>
+  concept sized_range = range<_Tp> && requires(_Tp& __t) { ranges::size(__t); };
+
+  // `disable_sized_range` defined in `<__ranges/size.h>`
+
   // [range.refinements], other range refinements
   template <class _Tp>
   concept input_range = range<_Tp> && input_iterator<iterator_t<_Tp> >;
 
   template <class _Tp>
   concept forward_range = input_range<_Tp> && forward_iterator<iterator_t<_Tp> >;
 
   template <class _Tp>
   concept bidirectional_range = forward_range<_Tp> && bidirectional_iterator<iterator_t<_Tp> >;
 
   template <class _Tp>
-  concept common_range = range<_Tp> && same_as<iterator_t<_Tp>, sentinel_t<_Tp> >;
-
-  template <class _Tp>
   concept random_access_range =
       bidirectional_range<_Tp> && random_access_iterator<iterator_t<_Tp> >;
+
+  template <class _Tp>
+  concept common_range = range<_Tp> && same_as<iterator_t<_Tp>, sentinel_t<_Tp> >;
 } // namespace ranges
 
 #endif // !defined(_LIBCPP_HAS_NO_RANGES)
 
 // clang-format on
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
-#endif // _LIBCPP_RANGES_CONCEPTS_H
+#endif // _LIBCPP___RANGES_CONCEPTS_H

libcxx/include/__ranges/size.h

 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if !defined(_LIBCPP_HAS_NO_RANGES)
 
+// clang-format off
+namespace ranges {
 template<class>
 inline constexpr bool disable_sized_range = false;
 
-// clang-format off
-namespace ranges {
 // [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>>;
 
struct __fn {
     [[nodiscard]] constexpr __integer_like auto operator()(_Tp&& __t) const
         noexcept(noexcept(size(_VSTD::forward<_Tp>(__t)))) {
       return size(_VSTD::forward<_Tp>(__t));
     }
 
     template<__difference _Tp>
     [[nodiscard]] constexpr __integer_like auto operator()(_Tp&& __t) const
         noexcept(noexcept(ranges::end(__t) - ranges::begin(__t))) {
-      return _VSTD::__to_unsigned_like<range_difference_t<remove_cvref_t<_Tp>>>(
-          ranges::end(__t) - ranges::begin(__t));
+      return _VSTD::__to_unsigned_like(ranges::end(__t) - ranges::begin(__t));
     }
   };
 } // end namespace __size
 
 inline namespace __cpo {
   inline constexpr auto size = __size::__fn{};
 } // namespace __cpo
 

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]
+  template<class>
+    inline constexpr bool disable_sized_range = false;
+
+  template<class T>
+    concept sized_range = ...;
+
   // [range.view], views
   template<class T>
     inline constexpr bool enable_view = ...;
 
   struct view_base { };
 
   template<class T>
     concept view = ...;

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

 using range = std::map<int, int>;
 namespace stdr = std::ranges;
 
 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(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>);

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

 using range = std::multimap<int, int>;
 namespace stdr = std::ranges;
 
 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(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>);

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

 using range = std::multiset<int>;
 namespace stdr = std::ranges;
 
 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(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>);

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

 namespace stdr = std::ranges;
 
 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(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>);

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

 
 using range = std::array<int, 10>;
 namespace stdr = std::ranges;
 
 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::sized_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::sized_range<range const>);

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

 
 using range = std::deque<int>;
 namespace stdr = std::ranges;
 
 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::view<range>);
+static_assert(stdr::sized_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::view<range const>);
+static_assert(stdr::sized_range<range const>);

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

 using range = std::forward_list<int>;
 namespace stdr = std::ranges;
 
 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(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>);

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

 using range = std::list<int>;
 namespace stdr = std::ranges;
 
 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(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>);

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

 
 using range = std::vector<bool>;
 namespace stdr = std::ranges;
 
 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::view<range>);
+static_assert(stdr::sized_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::view<range const>);
+static_assert(stdr::sized_range<range const>);

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

 
 using range = std::vector<int>;
 namespace stdr = std::ranges;
 
 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::view<range>);
+static_assert(stdr::sized_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::view<range const>);
+static_assert(stdr::sized_range<range const>);

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

 using range = std::unordered_map<int, int>;
 namespace stdr = std::ranges;
 
 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(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>);

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

 using range = std::unordered_multimap<int, int>;
 namespace stdr = std::ranges;
 
 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(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>);

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

 using range = std::unordered_multiset<int>;
 namespace stdr = std::ranges;
 
 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(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>);

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

 using range = std::unordered_set<int>;
 namespace stdr = std::ranges;
 
 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(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>);

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

 
 using range = std::span<int>;
 namespace stdr = std::ranges;
 
 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::view<range>);
+static_assert(stdr::sized_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::view<range const>);
+static_assert(stdr::sized_range<range const>);

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

 #include <ranges>
 
 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(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(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(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>);

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

 
 namespace stdr = std::ranges;
 
 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(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>);

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

 // size is disabled here, and it isn't sized_sentinel_for, so we have to compare begin
 // and end again.
 struct DisabledSizeRangeWithBeginEnd {
   friend constexpr forward_iterator<int*> begin(DisabledSizeRangeWithBeginEnd) { return {}; }
   friend constexpr sentinel end(DisabledSizeRangeWithBeginEnd) { return {}; }
   constexpr size_t size() const { return 1; }
 };
 
-template<>
-inline constexpr bool std::disable_sized_range<DisabledSizeRangeWithBeginEnd> = true;
+template <>
+inline constexpr bool std::ranges::disable_sized_range<DisabledSizeRangeWithBeginEnd> = true;
 static_assert(!std::is_invocable_v<RangeSizeT, DisabledSizeRangeWithBeginEnd&>);
 
 struct BeginEndAndEmpty {
   int* begin();
   int* end();
   constexpr bool empty() { return true; }
 };
 

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

 static_assert(!std::is_invocable_v<RangeSizeT, ConvertibleReturnTypeFunction>);
 static_assert(!std::is_invocable_v<RangeSizeT, BoolReturnTypeMember const&>);
 static_assert(!std::is_invocable_v<RangeSizeT, BoolReturnTypeFunction const&>);
 
 struct SizeMemberDisabled {
   size_t size() { return 42; }
 };
 
-template<>
-inline constexpr bool std::disable_sized_range<SizeMemberDisabled> = true;
+template <>
+inline constexpr bool std::ranges::disable_sized_range<SizeMemberDisabled> = true;
 
 struct ImproperlyDisabledMember {
   size_t size() const { return 42; }
 };
 
 // Intentionally disabling "const ConstSizeMemberDisabled". This doesn't disable anything
 // because T is always uncvrefed before being checked.
-template<>
-inline constexpr bool std::disable_sized_range<const ImproperlyDisabledMember> = true;
+template <>
+inline constexpr bool std::ranges::disable_sized_range<const ImproperlyDisabledMember> = true;
 
 struct SizeFunctionDisabled {
   friend size_t size(SizeFunctionDisabled) { return 42; }
 };
 
-template<>
-inline constexpr bool std::disable_sized_range<SizeFunctionDisabled> = true;
+template <>
+inline constexpr bool std::ranges::disable_sized_range<SizeFunctionDisabled> = true;
 
 struct ImproperlyDisabledFunction {
   friend size_t size(ImproperlyDisabledFunction const&) { return 42; }
 };
 
-template<>
-inline constexpr bool std::disable_sized_range<const ImproperlyDisabledFunction> = true;
+template <>
+inline constexpr bool std::ranges::disable_sized_range<const ImproperlyDisabledFunction> = true;
 
 static_assert( std::is_invocable_v<RangeSizeT, ImproperlyDisabledMember&>);
 static_assert( std::is_invocable_v<RangeSizeT, const ImproperlyDisabledMember&>);
 static_assert(!std::is_invocable_v<RangeSizeT, ImproperlyDisabledFunction&>);
 static_assert( std::is_invocable_v<RangeSizeT, const ImproperlyDisabledFunction&>);
 
 // No begin end.
 struct HasMinusOperator {

 
 struct DisabledSizeRangeWithBeginEnd {
   int buff[8];
   constexpr int* begin() { return buff; }
   constexpr int* end() { return buff + 8; }
   constexpr size_t size() { return 1; }
 };
 
-template<>
-inline constexpr bool std::disable_sized_range<DisabledSizeRangeWithBeginEnd> = true;
+template <>
+inline constexpr bool std::ranges::disable_sized_range<DisabledSizeRangeWithBeginEnd> = true;
 
 struct SizeBeginAndEndMembers {
   int buff[8];
   constexpr int* begin() { return buff; }
   constexpr int* end() { return buff + 8; }
   constexpr size_t size() { return 1; }
 };
 

libcxx/test/std/ranges/range.req/range.sized/sized_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 T>
+// concept sized_range;
+
+#include <ranges>
+
+#include "test_iterators.h"
+
+namespace stdr = std::ranges;
+
+static_assert(stdr::sized_range<int[5]>);
+static_assert(stdr::sized_range<int (&)[5]>);
+static_assert(!stdr::sized_range<int (&)[]>);
+static_assert(!stdr::sized_range<int[]>);
+
+struct range_has_size {
+  bidirectional_iterator<int*> begin();
+  bidirectional_iterator<int*> end();
+  int size();
+};
+static_assert(stdr::sized_range<range_has_size>);
+static_assert(!stdr::sized_range<range_has_size const>);
+
+struct range_has_const_size {
+  bidirectional_iterator<int*> begin();
+  bidirectional_iterator<int*> end();
+  int size() const;
+};
+static_assert(stdr::sized_range<range_has_const_size>);
+static_assert(!stdr::sized_range<range_has_const_size const>);
+
+struct const_range_has_size {
+  bidirectional_iterator<int*> begin() const;
+  bidirectional_iterator<int*> end() const;
+  int size();
+};
+static_assert(stdr::sized_range<const_range_has_size>);
+static_assert(stdr::range<const_range_has_size const>);
+static_assert(!stdr::sized_range<const_range_has_size const>);
+
+struct const_range_has_const_size {
+  bidirectional_iterator<int*> begin() const;
+  bidirectional_iterator<int*> end() const;
+  int size() const;
+};
+static_assert(stdr::sized_range<const_range_has_const_size>);
+static_assert(stdr::sized_range<const_range_has_const_size const>);
+
+struct sized_sentinel_range_has_size {
+  int* begin();
+  int* end();
+};
+static_assert(stdr::sized_range<sized_sentinel_range_has_size>);
+static_assert(!stdr::sized_range<sized_sentinel_range_has_size const>);
+
+struct const_sized_sentinel_range_has_size {
+  int* begin() const;
+  int* end() const;
+};
+static_assert(stdr::sized_range<const_sized_sentinel_range_has_size>);
+static_assert(stdr::sized_range<const_sized_sentinel_range_has_size const>);
+
+struct non_range_has_size {
+  int size() const;
+};
+static_assert(requires(non_range_has_size const x) { stdr::size(x); });
+static_assert(!stdr::sized_range<non_range_has_size>);
+static_assert(!stdr::sized_range<non_range_has_size const>);

libcxx/test/std/ranges/range.req/range.sized/subsumption.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
 
-// <ranges>
-
-// struct view_base { };
+// template<class T>
+// concept sized_range;
 
 #include <ranges>
-#include <type_traits>
 
-static_assert(std::is_empty_v<std::ranges::view_base>);
-static_assert(std::is_trivial_v<std::ranges::view_base>);
+template <std::ranges::range R>
+consteval bool check_subsumption() {
+  return false;
+}
+
+template <std::ranges::sized_range R>
+consteval bool check_subsumption() {
+  return true;
+}
 
-// Make sure we can inherit from it, as it's intended (that wouldn't be the
-// case if e.g. it was marked as final).
-struct View : std::ranges::view_base { };
+static_assert(check_subsumption<int[5]>());

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

 #include <ranges>
 
 namespace stdr = std::ranges;
 
 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::view<std::cmatch>);
+static_assert(stdr::sized_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::view<std::cmatch const>);
+static_assert(stdr::sized_range<std::cmatch const>);

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

 #include <ranges>
 
 namespace stdr = std::ranges;
 
 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::view<std::string>);
+static_assert(stdr::sized_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::view<std::string const>);
+static_assert(stdr::sized_range<std::string const>);

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

 #include <ranges>
 
 namespace stdr = std::ranges;
 
 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::view<std::string_view>);
+static_assert(stdr::sized_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::view<std::string_view const>);
+static_assert(!stdr::view<std::string_view const>); // FIXME: string_view needs to be patched so this is true
+static_assert(stdr::sized_range<std::string_view const>);