[libcxx][ranges] adds `ranges::range`, `ranges::common_range`, and range aliases

[cjdb]

Summary

• std::ranges::range
• std::ranges::sentinel_t
• std::ranges::range_difference_t
• std::ranges::range_value_t
• std::ranges::range_reference_t
• std::ranges::range_rvalue_reference_t
• std::ranges::common_range

range_size_t depends on sized_range and will be added alongside it.

Implements parts of:

• P0896R4 The One Ranges Proposal`

Depends on D100255.

[cjdb]

rebases to activate CI

[cjdb]

rebases to activate CI

[miscco]

libcxx/include/ranges

12–15

Is there some duplication here?

[cjdb]

uploading so @EricWF can take a look

[cjdb]

rebases to activate CI

[Mordante]

In general looks good. Some minor remarks, but would like to see it pass the CI.

libcxx/include/CMakeLists.txt

157

This seems unintentional.

libcxx/include/__ranges/concepts.h

30

Is the synopsis in the <ranges> header?

42

Please _Uglify. Note more to _Uglify below.

44

Shouldn't

template<sized_­range R>
    using range_size_t = decltype(ranges::size(declval<R&>()));

be included here? Or is it somewhere else? If it's somewhere else can you add a comment like you did for iterator_t?

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

20

Why no non-const version?

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

23

Can you also test std::basic_string with other character types, wchar_t, char8_t, char16_t, and char32_t?

[cjdb]

• adds std::ranges::common_range
• adds conformance tests
• adds missing content to synopsis
• _Uglifies names

libcxx/include/CMakeLists.txt

157

Oops.

libcxx/include/__ranges/concepts.h

44

Please see the commit message.

libcxx/include/ranges

12–15

Where?

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

23

I'm not convinced those will yield anything useful since they're aliases, not specialisations.

[cjdb]

fixes Windows build failure

[Mordante]

libcxx/include/__ranges/concepts.h

44

I see, missed that during the original review.

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

12

Not too fond of this, see my post-commit comments for D101205.

[ldionne]

Overall LGTM, but I think it makes more sense for iterator_t to live in __ranges/concepts.h if possible.

libcxx/include/__ranges/concepts.h

39

That's kinda weird, would it be possible to define it here instead?

[cjdb]

libcxx/include/__ranges/concepts.h

39

Your options are:

• it lives here exclusively, __ranges/access.h (__ranges/end.h in current D100255) needs to use decltype(ranges::begin(declval<_Rp&>())) wherever it currently uses iterator_t
• it lives in __ranges/access.h exclusively, comment remains
• it lives in both

[• Quuxplusone]

libcxx/include/__ranges/concepts.h

39

FWIW, I'd look at the definitions on cppreference:

• iterator_t is the type of ranges::begin, so it belongs next to begin
• sentinel_t is the type of ranges::end, so it belongs next to end
• range_size_tis the type of ranges::size, so it belongs next to size

The other four typedefs probably might as well go into <ranges> until we have a reason to move them elsewhere.

libcxx/include/ranges

34–35

This is listed twice.

[cjdb]

libcxx/include/__ranges/concepts.h

39

FWIW, I'd look at the definitions on cppreference:

Having written a fair chunk of the ranges section of cppreference, I can confidently say it's designed for consumers of C++, not for implementers, so different groupings make sense.

• iterator_t is the type of ranges::begin, so it belongs next to begin
• sentinel_t is the type of ranges::end, so it belongs next to end
• range_size_tis the type of ranges::size, so it belongs next to size

This is a good suggestion (even though cppreference doesn't group them like this), but I'd prefer to group them as per the standard's synopsis.

The other four typedefs probably might as well go into <ranges> until we have a reason to move them elsewhere.

That would make using them in <ranges/*> very awkward.

[ldionne]

libcxx/include/__ranges/concepts.h

39

Hmm, I think I buy Arthur's argument. Either do that or leave as-is, non blocking as far as I'm concerned. Thanks for explaining why I can't just have what I asked for in the first place, though.

[cjdb]

rebases to activate CI

libcxx/include/CMakeLists.txt

set(files
   __memory/uninitialized_algorithms.h
   __memory/unique_ptr.h
   __mutex_base
   __node_handle
   __nullptr
   __ranges/begin.h
   __ranges/cbegin.h
   __ranges/cend.h
+  __ranges/concepts.h
   __ranges/end.h
   __ranges/enable_borrowed_range.h
   __split_buffer
   __sso_allocator
   __std_stream
   __string
   __threading_support
   __tree
set(files
   numeric
   optional
   ostream
   queue
   random
   ranges
   ratio
   ranges
-  regex
   scoped_allocator
   semaphore
   set
   setjmp.h
   shared_mutex
   span
   sstream
   stack

libcxx/include/__ranges/concepts.h

+// -*- C++ -*-
+//===-------------------------- concepts ----------------------------------===//
+//
+// 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 <__ranges/begin.h>
+#include <__ranges/end.h>
+#include <type_traits>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if !defined(_LIBCPP_HAS_NO_RANGES)
+
+namespace ranges {
+// [range.range]
+template <class _Tp>
+concept range = requires(_Tp& __t) {
+  ranges::begin(__t); // sometimes equality-preserving
+  ranges::end(__t);
+};
+
+// `iterator_t` defined in <__ranges/begin.h>
+
+template <range _Rp>
+using sentinel_t = decltype(ranges::end(declval<_Rp&>()));
+
+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> >;
+} // namespace ranges
+
+#endif // !defined(_LIBCPP_HAS_NO_RANGES)
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP_RANGES_CONCEPTS_H

libcxx/include/ranges

 // -*- C++ -*-
 //===--------------------------- ranges -----------------------------------===//
 //
 // 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
 #define _LIBCPP_RANGES
 
 /*
 
 #include <compare>              // see [compare.syn]
 #include <initializer_list>     // see [initializer.list.syn]
 #include <iterator>             // see [iterator.synopsis]
 
 namespace std::ranges {
   inline namespace unspecified {
     // [range.access], range access
     inline constexpr unspecified begin = unspecified;
     inline constexpr unspecified end = unspecified;
     inline constexpr unspecified cbegin = unspecified;
     inline constexpr unspecified cend = unspecified;
   }
 
   // [range.range], ranges
   template<class T>
     inline constexpr bool enable_borrowed_range = false;
 
   template<class T>
     using iterator_t = decltype(ranges::begin(declval<T&>()));
+  template<class T>
+    using iterator_t = decltype(ranges::begin(declval<T&>()));
+  template<range R>
+    using sentinel_t = decltype(ranges::end(declval<R&>()));
+  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 <__config>
 #include <__ranges/begin.h>
 #include <__ranges/cbegin.h>
 #include <__ranges/cend.h>
+#include <__ranges/concepts.h>
 #include <__ranges/end.h>
 #include <__ranges/enable_borrowed_range.h>
 #include <compare>          // Required by the standard.
 #include <initializer_list> // Required by the standard.
 #include <iterator>         // Required by the standard.
 #include <type_traits>
 #include <version>
 

libcxx/test/std/containers/associative/map/range_concept_conformance.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
+
+// map
+
+#include <map>
+
+#include <ranges>
+
+static_assert(std::ranges::range<std::map<int, int>>);
+static_assert(std::ranges::range<std::map<int, int> const>);

libcxx/test/std/containers/associative/multimap/range_concept_conformance.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
+
+// multimap
+
+#include <map>
+
+#include <ranges>
+
+static_assert(std::ranges::range<std::multimap<int, int>>);
+static_assert(std::ranges::range<std::multimap<int, int> const>);

libcxx/test/std/containers/associative/multiset/range_concept_conformance.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
+
+// multiset
+
+#include <set>
+
+#include <ranges>
+
+static_assert(std::ranges::range<std::multiset<int>>);
+static_assert(std::ranges::range<std::multiset<int> const>);

libcxx/test/std/containers/associative/set/range_concept.conformance.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
+
+// set
+
+#include <set>
+
+#include <ranges>
+
+static_assert(std::ranges::range<std::set<int>>);
+static_assert(std::ranges::range<std::set<int> const>);

libcxx/test/std/containers/sequences/array/range_concept_conformance.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
+
+// array
+
+#include <array>
+
+#include <ranges>
+
+static_assert(std::ranges::range<std::array<int, 10>>);
+static_assert(std::ranges::range<std::array<int, 10> const>);

libcxx/test/std/containers/sequences/deque/range_concept_conformance.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
+
+// deque
+
+#include <deque>
+
+#include <ranges>
+
+static_assert(std::ranges::range<std::deque<int>>);
+static_assert(std::ranges::range<std::deque<int> const>);

libcxx/test/std/containers/sequences/forwardlist/range_concept_conformance.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
+
+// forward_list
+
+#include <forward_list>
+
+#include <ranges>
+
+static_assert(std::ranges::range<std::forward_list<int>>);
+static_assert(std::ranges::range<std::forward_list<int> const>);

libcxx/test/std/containers/sequences/list/range_concept_conformance.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
+
+// list
+
+#include <list>
+
+#include <ranges>
+
+static_assert(std::ranges::range<std::list<int>>);
+static_assert(std::ranges::range<std::list<int> const>);

libcxx/test/std/containers/sequences/vector.bool/range_concept_conformance.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
+
+// vector
+
+#include <vector>
+
+#include <ranges>
+
+static_assert(std::ranges::range<std::vector<bool>>);
+static_assert(std::ranges::range<std::vector<bool> const>);

libcxx/test/std/containers/sequences/vector/range_concept_conformance.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
+
+// vector
+
+#include <vector>
+
+#include <ranges>
+
+static_assert(std::ranges::range<std::vector<int>>);
+static_assert(std::ranges::range<std::vector<int> const>);

libcxx/test/std/containers/unord/unord.map/range_concept_conformance.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
+
+// unordered_map
+
+#include <unordered_map>
+
+#include <ranges>
+
+static_assert(std::ranges::range<std::unordered_map<int, int>>);
+static_assert(std::ranges::range<std::unordered_map<int, int> const>);

libcxx/test/std/containers/unord/unord.multimap/range_concept_conformance.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
+
+// unordered_multimap
+
+#include <unordered_map>
+
+#include <ranges>
+
+static_assert(std::ranges::range<std::unordered_multimap<int, int> const>);

libcxx/test/std/containers/unord/unord.multiset/range_concept_conformance.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
+
+// unordered_multiset
+
+#include <unordered_set>
+
+#include <ranges>
+
+static_assert(std::ranges::range<std::unordered_multiset<int>>);
+static_assert(std::ranges::range<std::unordered_multiset<int> const>);

libcxx/test/std/containers/unord/unord.set/range_concept_conformance.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
+
+// unordered_set
+
+#include <unordered_set>
+
+#include <ranges>
+
+static_assert(std::ranges::range<std::unordered_set<int>>);
+static_assert(std::ranges::range<std::unordered_set<int> const>);

libcxx/test/std/containers/views/range_concept_conformance.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
+
+// span
+
+#include <span>
+
+#include <ranges>
+
+static_assert(std::ranges::range<std::span<int>>);
+static_assert(std::ranges::range<std::span<int const>>);
+static_assert(std::ranges::range<std::span<int> const>);

libcxx/test/std/input.output/filesystems/class.directory_iterator/range_concept_conformance.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
+
+// directory_iterator, recursive_directory_iterator
+
+#include "filesystem_include.h"
+
+#include <ranges>
+
+static_assert(std::ranges::range<fs::directory_iterator>);
+static_assert(std::ranges::range<fs::directory_iterator const>);
+
+static_assert(std::ranges::range<fs::recursive_directory_iterator>);
+static_assert(std::ranges::range<fs::recursive_directory_iterator const>);

libcxx/test/std/input.output/filesystems/class.path/range_concept_conformance.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
+
+// path
+
+#include "filesystem_include.h"
+
+#include <ranges>
+
+static_assert(std::ranges::range<fs::path>);
+static_assert(std::ranges::range<fs::path const>);

libcxx/test/std/ranges/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_range.h"
+
+namespace stdr = std::ranges;
+
+static_assert(std::same_as<stdr::range_difference_t<test_range>, std::iter_difference_t<int*>>);
+static_assert(std::same_as<stdr::range_value_t<test_range>, std::iter_value_t<int*>>);
+static_assert(std::same_as<stdr::range_reference_t<test_range>, std::iter_reference_t<int*>>);
+static_assert(std::same_as<stdr::range_rvalue_reference_t<test_range>, std::iter_rvalue_reference_t<int*>>);

libcxx/test/std/ranges/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>);
+
+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.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_range.h"
+
+namespace stdr = std::ranges;
+
+static_assert(std::same_as<stdr::sentinel_t<test_range>, sentinel>);

libcxx/test/std/re/re.results/range_concept_conformance.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
+
+// match_results
+
+#include <regex>
+
+#include <ranges>
+
+#include "test_allocator.h"
+
+static_assert(std::ranges::range<std::cmatch>);
+static_assert(std::ranges::range<std::cmatch const>);

libcxx/test/std/strings/basic.string/range_concept_conformance.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
+
+// string
+
+#include <string>
+
+#include <ranges>
+
+#include "test_allocator.h"
+
+static_assert(std::ranges::range<std::string>);
+static_assert(std::ranges::range<std::string const>);

libcxx/test/std/strings/string.view/range_concept_conformance.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
+
+// string_view
+
+#include <string_view>
+
+#include <ranges>
+
+#include "test_allocator.h"
+
+static_assert(std::ranges::range<std::string_view>);
+static_assert(std::ranges::range<std::string_view const>);

libcxx/test/support/test_range.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 LIBCXX_TEST_SUPPORT_TEST_RANGE_H
+#define LIBCXX_TEST_SUPPORT_TEST_RANGE_H
+
+#include <ranges>
+
+#ifdef _LIBCPP_HAS_NO_RANGES
+#error "test/suppoort/test_range.h" can only be included in builds supporting ranges
+#endif
+
+struct sentinel {
+  bool operator==(std::input_or_output_iterator auto) const;
+};
+
+struct test_range {
+  int* begin();
+  int const* begin() const;
+  sentinel end();
+  sentinel end() const;
+};
+
+#endif // LIBCXX_TEST_SUPPORT_TEST_RANGE_H