[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

23

Rvalue array?

[cjdb]

libcxx/include/__ranges/concepts.h

14

🤷

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

23

That's int[5].

[• Quuxplusone]

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

23

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

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

23

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

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

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

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

49

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

[• Quuxplusone]

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

31

@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

10

Will do.

14

Oh, because of transitive includes.

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

49

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

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

31

@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/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
 
 #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

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.range/enable_borrowed_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
 
 // <ranges>
 
 // template<class>
 //  inline constexpr bool enable_borrowed_range = false;
 
 #include <ranges>
 #include <array>
 #include <deque>
 #include <forward_list>
 #include <list>
 #include <map>
 #include <queue>
 #include <set>
 #include <stack>
 #include <unordered_map>
 #include <unordered_set>
 #include <vector>
 
 #include "test_macros.h"
 
 struct S {};
 
 void test() {
   using std::ranges::enable_borrowed_range;
   static_assert(!enable_borrowed_range<char>);
   static_assert(!enable_borrowed_range<int>);
   static_assert(!enable_borrowed_range<double>);
   static_assert(!enable_borrowed_range<S>);
 
   // Sequence containers
   static_assert(!enable_borrowed_range<std::array<int, 0> >);
   static_assert(!enable_borrowed_range<std::array<int, 42> >);
   static_assert(!enable_borrowed_range<std::deque<int> >);
   static_assert(!enable_borrowed_range<std::forward_list<int> >);
   static_assert(!enable_borrowed_range<std::list<int> >);
   static_assert(!enable_borrowed_range<std::vector<int> >);
 
   // Associative containers
   static_assert(!enable_borrowed_range<std::set<int> >);
   static_assert(!enable_borrowed_range<std::map<int, int> >);
   static_assert(!enable_borrowed_range<std::multiset<int> >);
   static_assert(!enable_borrowed_range<std::multimap<int, int> >);
 
   // Unordered associative containers
   static_assert(!enable_borrowed_range<std::unordered_set<int> >);
   static_assert(!enable_borrowed_range<std::unordered_map<int, int> >);
   static_assert(!enable_borrowed_range<std::unordered_multiset<int> >);
   static_assert(!enable_borrowed_range<std::unordered_multimap<int, int> >);
 
   // Container adaptors
   static_assert(!enable_borrowed_range<std::stack<int> >);
   static_assert(!enable_borrowed_range<std::queue<int> >);
   static_assert(!enable_borrowed_range<std::priority_queue<int> >);
 
   // Both std::span and std::string_view have their own test.
 }

libcxx/test/std/ranges/range.req/range.range/helper_aliases.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<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>>;
 
 #include <ranges>
 
 #include <concepts>
 
 #include "test_iterators.h"
 #include "test_range.h"
 
 namespace stdr = std::ranges;
 
 static_assert(std::same_as<stdr::range_difference_t<test_range<cpp20_input_iterator> >, std::iter_difference_t<int*> >);
 static_assert(std::same_as<stdr::range_value_t<test_range<cpp20_input_iterator> >, std::iter_value_t<int*> >);
 static_assert(std::same_as<stdr::range_reference_t<test_range<cpp20_input_iterator> >, std::iter_reference_t<int*> >);
 static_assert(std::same_as<stdr::range_rvalue_reference_t<test_range<cpp20_input_iterator> >, std::iter_rvalue_reference_t<int*> >);

libcxx/test/std/ranges/range.req/range.range/iterator_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<class T>
 // using iterator_t = decltype(ranges::begin(declval<T&>()));
 
 #include <ranges>
 
 #include <concepts>
 
 #include "test_range.h"
 
 namespace stdr = std::ranges;
 
 static_assert(std::same_as<stdr::iterator_t<test_range<cpp17_input_iterator> >, cpp17_input_iterator<int*> >);
 static_assert(std::same_as<stdr::iterator_t<test_range<cpp17_input_iterator> const>, cpp17_input_iterator<int const*> >);
 
 static_assert(std::same_as<stdr::iterator_t<test_non_const_range<cpp17_input_iterator> >, cpp17_input_iterator<int*> >);
 
 static_assert(std::same_as<stdr::iterator_t<test_common_range<cpp17_input_iterator> >, cpp17_input_iterator<int*> >);
 static_assert(std::same_as<stdr::iterator_t<test_common_range<cpp17_input_iterator> const>, cpp17_input_iterator<int const*> >);
 
 static_assert(std::same_as<stdr::iterator_t<test_non_const_common_range<cpp17_input_iterator> >, cpp17_input_iterator<int*> >);

libcxx/test/std/ranges/range.req/range.range/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 range;
 
 #include <ranges>
 
 #include <vector>
 
 #include "test_range.h"
 
 namespace stdr = std::ranges;
 
 static_assert(stdr::range<test_range<cpp20_input_iterator> >);
 
 struct incompatible_iterators {
   int* begin();
   long* end();
 };
 static_assert(!stdr::range<incompatible_iterators>);
 
 struct int_begin_int_end {
   int begin();
   int end();
 };
 static_assert(!stdr::range<int_begin_int_end>);
 
 struct iterator_begin_int_end {
   int* begin();
   int end();
 };
 static_assert(!stdr::range<iterator_begin_int_end>);
 
 struct int_begin_iterator_end {
   int begin();
   int* end();
 };
 static_assert(!stdr::range<int_begin_iterator_end>);

libcxx/test/std/ranges/range.req/range.range/sentinel_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<range _Rp>
 // using sentinel_t = decltype(ranges::end(declval<_Rp&>()));
 
 #include <ranges>
 
 #include <concepts>
 
 #include "test_iterators.h"
 #include "test_range.h"
 
 namespace stdr = std::ranges;
 
 static_assert(std::same_as<stdr::sentinel_t<test_range<cpp20_input_iterator> >, sentinel>);
 static_assert(std::same_as<stdr::sentinel_t<test_range<cpp20_input_iterator> const>, sentinel>);
 static_assert(std::same_as<stdr::sentinel_t<test_non_const_range<cpp20_input_iterator> >, sentinel>);
 static_assert(std::same_as<stdr::sentinel_t<test_common_range<cpp17_input_iterator> >, cpp17_input_iterator<int*> >);
 static_assert(std::same_as<stdr::sentinel_t<test_common_range<cpp17_input_iterator> const>, cpp17_input_iterator<int const*> >);
 static_assert(std::same_as<stdr::sentinel_t<test_non_const_common_range<cpp17_input_iterator> >, cpp17_input_iterator<int*> >);

libcxx/test/std/ranges/range.req/range.refinements/bidirectional_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<range _Rp>
 // concept bidirectional_range;
 
 #include <ranges>
 
 #include "test_range.h"
 
 namespace stdr = std::ranges;
 
 template <template <class...> class I>
 constexpr bool check_bidirectional_range() {
   constexpr bool result = stdr::bidirectional_range<test_range<I> >;
   static_assert(stdr::bidirectional_range<test_range<I> const> == result);
   static_assert(stdr::bidirectional_range<test_non_const_common_range<I> > == result);
   static_assert(stdr::bidirectional_range<test_non_const_range<I> > == result);
   static_assert(stdr::bidirectional_range<test_common_range<I> > == result);
   static_assert(stdr::bidirectional_range<test_common_range<I> const> == result);
   static_assert(!stdr::bidirectional_range<test_non_const_common_range<I> const>);
   static_assert(!stdr::bidirectional_range<test_non_const_range<I> const>);
   return result;
 }
 
 static_assert(!check_bidirectional_range<cpp17_input_iterator>());
 static_assert(!check_bidirectional_range<cpp20_input_iterator>());
 static_assert(!check_bidirectional_range<forward_iterator>());
 static_assert(check_bidirectional_range<bidirectional_iterator>());
 static_assert(check_bidirectional_range<random_access_iterator>());
 static_assert(check_bidirectional_range<contiguous_iterator>());

libcxx/test/std/ranges/range.req/range.refinements/common_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
 
 // template<class T>
 // concept common_range;
 
 #include <ranges>
 
 #include "test_iterators.h"
 #include "test_range.h"
 
 namespace stdr = std::ranges;
 
 static_assert(!stdr::common_range<test_range<cpp17_input_iterator> >);
 static_assert(!stdr::common_range<test_range<cpp17_input_iterator> const>);
 
 static_assert(!stdr::common_range<test_non_const_range<cpp17_input_iterator> >);
 static_assert(!stdr::common_range<test_non_const_range<cpp17_input_iterator> const>);
 
 static_assert(stdr::common_range<test_common_range<cpp17_input_iterator> >);
 static_assert(stdr::common_range<test_common_range<cpp17_input_iterator> const>);
 
 static_assert(stdr::common_range<test_non_const_common_range<cpp17_input_iterator> >);
 static_assert(!stdr::common_range<test_non_const_common_range<cpp17_input_iterator> const>);
 
 struct subtly_not_common {
   int* begin() const;
   int const* end() const;
 };
 static_assert(stdr::range<subtly_not_common> && !stdr::common_range<subtly_not_common>);
 static_assert(stdr::range<subtly_not_common const> && !stdr::common_range<subtly_not_common const>);
 
 struct common_range_non_const_only {
   int* begin() const;
   int* end();
   int const* end() const;
 };
 static_assert(stdr::range<common_range_non_const_only>&& stdr::common_range<common_range_non_const_only>);
 static_assert(stdr::range<common_range_non_const_only const> && !stdr::common_range<common_range_non_const_only const>);
 
 struct common_range_const_only {
   int* begin();
   int const* begin() const;
   int const* end() const;
 };
 static_assert(stdr::range<common_range_const_only> && !stdr::common_range<common_range_const_only>);
 static_assert(stdr::range<common_range_const_only const>&& stdr::common_range<common_range_const_only const>);

libcxx/test/std/ranges/range.req/range.refinements/forward_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
 
 // std::ranges::forward_range;
 
 #include <ranges>
 
 #include "test_iterators.h"
 #include "test_range.h"
 
 namespace stdr = std::ranges;
 
 template <template <class...> class I>
 constexpr bool check_forward_range() {
   constexpr bool result = stdr::forward_range<test_range<I> >;
   static_assert(stdr::forward_range<test_range<I> const> == result);
   static_assert(stdr::forward_range<test_non_const_common_range<I> > == result);
   static_assert(stdr::forward_range<test_non_const_range<I> > == result);
   static_assert(stdr::forward_range<test_common_range<I> > == result);
   static_assert(stdr::forward_range<test_common_range<I> const> == result);
   static_assert(!stdr::forward_range<test_non_const_common_range<I> const>);
   static_assert(!stdr::forward_range<test_non_const_range<I> const>);
   return result;
 }
 
 static_assert(!check_forward_range<cpp17_input_iterator>());
 static_assert(!check_forward_range<cpp20_input_iterator>());
 static_assert(check_forward_range<forward_iterator>());
 static_assert(check_forward_range<bidirectional_iterator>());
 static_assert(check_forward_range<random_access_iterator>());
 static_assert(check_forward_range<contiguous_iterator>());

libcxx/test/std/ranges/range.req/range.refinements/input_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<range _Rp>
 // concept input_range;
 
 #include <ranges>
 
 #include "test_iterators.h"
 #include "test_range.h"
 
 namespace stdr = std::ranges;
 
 static_assert(stdr::input_range<test_range<cpp17_input_iterator> >);
 static_assert(stdr::input_range<test_range<cpp17_input_iterator> const>);
 
 static_assert(stdr::input_range<test_range<cpp20_input_iterator> >);
 static_assert(stdr::input_range<test_range<cpp20_input_iterator> const>);
 
 static_assert(stdr::input_range<test_non_const_range<cpp17_input_iterator> >);
 static_assert(stdr::input_range<test_non_const_range<cpp20_input_iterator> >);
 
 static_assert(!stdr::input_range<test_non_const_range<cpp17_input_iterator> const>);
 static_assert(!stdr::input_range<test_non_const_range<cpp20_input_iterator> const>);
 
 static_assert(stdr::input_range<test_common_range<cpp17_input_iterator> >);
 static_assert(!stdr::input_range<test_common_range<cpp20_input_iterator> >);
 
 static_assert(stdr::input_range<test_common_range<cpp17_input_iterator> const>);
 static_assert(!stdr::input_range<test_common_range<cpp20_input_iterator> const>);
 
 static_assert(stdr::input_range<test_non_const_common_range<cpp17_input_iterator> >);
 static_assert(!stdr::input_range<test_non_const_common_range<cpp20_input_iterator> >);
 
 static_assert(!stdr::input_range<test_non_const_common_range<cpp17_input_iterator> const>);
 static_assert(!stdr::input_range<test_non_const_common_range<cpp20_input_iterator> const>);

libcxx/test/std/ranges/range.req/range.refinements/random_access_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<range _Rp>
 // concept random_access_range;
 
 #include <ranges>
 
 #include "test_range.h"
 #include "test_iterators.h"
 
 namespace ranges = std::ranges;
 
 template <template <class...> class I>
 constexpr bool check_range() {
   constexpr bool result = ranges::random_access_range<test_range<I> >;
   static_assert(ranges::random_access_range<test_range<I> const> == result);
   static_assert(ranges::random_access_range<test_non_const_common_range<I> > == result);
   static_assert(ranges::random_access_range<test_non_const_range<I> > == result);
   static_assert(ranges::random_access_range<test_common_range<I> > == result);
   static_assert(ranges::random_access_range<test_common_range<I> const> == result);
   static_assert(!ranges::random_access_range<test_non_const_common_range<I> const>);
   static_assert(!ranges::random_access_range<test_non_const_range<I> const>);
   return result;
 }
 
 static_assert(!check_range<cpp20_input_iterator>());
 static_assert(!check_range<forward_iterator>());
 static_assert(!check_range<bidirectional_iterator>());
 static_assert(check_range<random_access_iterator>());
 static_assert(check_range<contiguous_iterator>());

libcxx/test/std/ranges/range.req/range.refinements/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
 
 // template<class T>
 // concept input_iterator;
 
 // std::ranges::forward_range
 
 #include <ranges>
 
 #include <iterator>
 
 struct range {
   int* begin();
   int* end();
 };
 
 // clang-format off
 template<std::ranges::range R>
 requires std::input_iterator<std::ranges::iterator_t<R> >
 [[nodiscard]] constexpr bool check_input_range_subsumption() {
   return false;
 }
 
 template<std::ranges::input_range>
 requires true
 [[nodiscard]] constexpr bool check_input_range_subsumption() {
   return true;
 }
 // clang-format on
 
 static_assert(check_input_range_subsumption<range>());
 
 // clang-format off
 template<std::ranges::input_range R>
 requires std::forward_iterator<std::ranges::iterator_t<R> >
 [[nodiscard]] constexpr bool check_forward_range_subsumption() {
   return false;
 }
 
 template<std::ranges::forward_range>
 requires true
 [[nodiscard]] constexpr bool check_forward_range_subsumption() {
   return true;
 }
 // clang-format on
 
 static_assert(check_forward_range_subsumption<range>());
 
 // clang-format off
 template<std::ranges::forward_range R>
 requires std::bidirectional_iterator<std::ranges::iterator_t<R> >
 [[nodiscard]] constexpr bool check_bidirectional_range_subsumption() {
   return false;
 }
 
 template<std::ranges::bidirectional_range>
 requires true
 [[nodiscard]] constexpr bool check_bidirectional_range_subsumption() {
   return true;
 }
 // clang-format on
 
 static_assert(check_bidirectional_range_subsumption<range>());
 
 template<std::ranges::bidirectional_range R>
 requires std::random_access_iterator<std::ranges::iterator_t<R> >
 constexpr bool check_random_access_range_subsumption() {
   return false;
 }
 
 template<std::ranges::random_access_range>
 requires true
 constexpr bool check_random_access_range_subsumption() {
   return true;
 }
 
 static_assert(check_random_access_range_subsumption<range>());

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/ranges/range.req/range.view/enable_view.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
 
 // <ranges>
 
 // template<class T>
 // inline constexpr bool enable_view = ...;
 
 #include <ranges>
 
 #include "test_macros.h"
 
 // Doesn't derive from view_base
 struct Empty { };
 static_assert(!std::ranges::enable_view<Empty>);
 
 // Derives from view_base, but privately
 struct PrivateViewBase : private std::ranges::view_base { };
 static_assert(!std::ranges::enable_view<PrivateViewBase>);
 
 // Derives from view_base, but specializes enable_view to false
 struct EnableViewFalse : std::ranges::view_base { };
 namespace std::ranges { template <> constexpr bool enable_view<EnableViewFalse> = false; }
 static_assert(!std::ranges::enable_view<EnableViewFalse>);
 
 
 // Derives from view_base
 struct PublicViewBase : std::ranges::view_base { };
 static_assert(std::ranges::enable_view<PublicViewBase>);
 
 // Does not derive from view_base, but specializes enable_view to true
 struct EnableViewTrue { };
 namespace std::ranges { template <> constexpr bool enable_view<EnableViewTrue> = true; }
 static_assert(std::ranges::enable_view<EnableViewTrue>);
 
 
 // Make sure that enable_view is a bool, not some other contextually-convertible-to-bool type.
 ASSERT_SAME_TYPE(decltype(std::ranges::enable_view<Empty>), const bool);
 ASSERT_SAME_TYPE(decltype(std::ranges::enable_view<PublicViewBase>), const bool);

libcxx/test/std/ranges/range.req/range.view/view.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
 
 // <ranges>
 
 // template<class T>
 // concept view = ...;
 
 #include <ranges>
 
 #include "test_macros.h"
 
 // The type would be a view, but it's not moveable.
 struct NotMoveable : std::ranges::view_base {
   NotMoveable() = default;
   NotMoveable(NotMoveable&&) = delete;
   NotMoveable& operator=(NotMoveable&&) = delete;
   friend int* begin(NotMoveable&);
   friend int* begin(NotMoveable const&);
   friend int* end(NotMoveable&);
   friend int* end(NotMoveable const&);
 };
 static_assert(std::ranges::range<NotMoveable>);
 static_assert(!std::movable<NotMoveable>);
 static_assert(std::default_initializable<NotMoveable>);
 static_assert(std::ranges::enable_view<NotMoveable>);
 static_assert(!std::ranges::view<NotMoveable>);
 
 // The type would be a view, but it's not default initializable
 struct NotDefaultInit : std::ranges::view_base {
   NotDefaultInit() = delete;
   friend int* begin(NotDefaultInit&);
   friend int* begin(NotDefaultInit const&);
   friend int* end(NotDefaultInit&);
   friend int* end(NotDefaultInit const&);
 };
 static_assert(std::ranges::range<NotDefaultInit>);
 static_assert(std::movable<NotDefaultInit>);
 static_assert(!std::default_initializable<NotDefaultInit>);
 static_assert(std::ranges::enable_view<NotDefaultInit>);
 static_assert(!std::ranges::view<NotDefaultInit>);
 
 // The type would be a view, but it doesn't enable it with enable_view
 struct NotExplicitlyEnabled {
   NotExplicitlyEnabled() = default;
   NotExplicitlyEnabled(NotExplicitlyEnabled&&) = default;
   NotExplicitlyEnabled& operator=(NotExplicitlyEnabled&&) = default;
   friend int* begin(NotExplicitlyEnabled&);
   friend int* begin(NotExplicitlyEnabled const&);
   friend int* end(NotExplicitlyEnabled&);
   friend int* end(NotExplicitlyEnabled const&);
 };
 static_assert(std::ranges::range<NotExplicitlyEnabled>);
 static_assert(std::movable<NotExplicitlyEnabled>);
 static_assert(std::default_initializable<NotExplicitlyEnabled>);
 static_assert(!std::ranges::enable_view<NotExplicitlyEnabled>);
 static_assert(!std::ranges::view<NotExplicitlyEnabled>);
 
 // The type has everything else, but it's not a range
 struct NotARange : std::ranges::view_base {
   NotARange() = default;
   NotARange(NotARange&&) = default;
   NotARange& operator=(NotARange&&) = default;
 };
 static_assert(!std::ranges::range<NotARange>);
 static_assert(std::movable<NotARange>);
 static_assert(std::default_initializable<NotARange>);
 static_assert(std::ranges::enable_view<NotARange>);
 static_assert(!std::ranges::view<NotARange>);
 
 // The type satisfies all requirements
 struct View : std::ranges::view_base {
   View() = default;
   View(View&&) = default;
   View& operator=(View&&) = default;
   friend int* begin(View&);
   friend int* begin(View const&);
   friend int* end(View&);
   friend int* end(View const&);
 };
 static_assert(std::ranges::range<View>);
 static_assert(std::movable<View>);
 static_assert(std::default_initializable<View>);
 static_assert(std::ranges::enable_view<View>);
 static_assert(std::ranges::view<View>);

libcxx/test/std/ranges/range.req/range.view/view.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
 
 // <ranges>
 
 // template<class T>
 // concept view = ...;
 
 #include <ranges>
 
 #include "test_macros.h"
 
 struct View : std::ranges::view_base {
   View() = default;
   View(View&&) = default;
   View& operator=(View&&) = default;
   friend int* begin(View&);
   friend int* begin(View const&);
   friend int* end(View&);
   friend int* end(View const&);
 };
 
 namespace subsume_range {
   template <std::ranges::view>
   constexpr bool test() { return true; }
   template <std::ranges::range>
   constexpr bool test() { return false; }
   static_assert(test<View>());
 }
 
 namespace subsume_movable {
   template <std::ranges::view>
   constexpr bool test() { return true; }
   template <std::movable>
   constexpr bool test() { return false; }
   static_assert(test<View>());
 }
 
 namespace subsume_default_initializable {
   template <std::ranges::view>
   constexpr bool test() { return true; }
   template <std::default_initializable>
   constexpr bool test() { return false; }
   static_assert(test<View>());
 }

libcxx/test/std/ranges/range.req/range.view/view_base.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
 
 // <ranges>
 
 // struct view_base { };
 
 #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>);
 
 // 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 { };

libcxx/test/std/ranges/range.view/view_base.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
-
-// <ranges>
-
-// struct view_base { };
-
-#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>);
-
-// 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 { };

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::sized_range<std::string_view const>);