[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

155

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

19

Why no non-const version?

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

22

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

155

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

22

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

37–38

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/shared_ptr.h
   __memory/temporary_buffer.h
   __memory/uninitialized_algorithms.h
   __memory/unique_ptr.h
   __mutex_base
   __node_handle
   __nullptr
   __ranges/access.h
+  __ranges/concepts.h
   __ranges/enable_borrowed_range.h
   __split_buffer
   __sso_allocator
   __std_stream
   __string
   __threading_support
   __tree
   __tuple
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++ -*-
+//===--------------------- __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 <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
+
+// clang-format off
+
+#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 _Rp>
+  using range_difference_t = iter_difference_t<iterator_t<_Rp> >;
+
+  template <range _Rp>
+  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.refinements], other range refinements
+  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

 // -*- 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>
+    concept range = see below;
+
+  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>>;
+
+  // [range.refinements], other range refinements
+  template <class _Tp>
+    concept common_range = see below;
 }
 
 */
 
 #include <__config>
 #include <__ranges/access.h>
+#include <__ranges/concepts.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>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)

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
 // XFAIL: msvc && clang
 
 // map
 
 #include <map>
 
 #include <concepts>
 #include <ranges>
 
 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(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
+static_assert(stdr::common_range<range const>);

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

 
 #include <concepts>
 #include <ranges>
 
 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(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
+static_assert(stdr::common_range<range const>);

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

 
 #include <concepts>
 #include <ranges>
 
 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(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
+static_assert(stdr::common_range<range const>);

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

 
 #include <concepts>
 #include <ranges>
 
 using range = std::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(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
+static_assert(stdr::common_range<range const>);

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

 
 #include <concepts>
 #include <ranges>
 
 using range = std::array<int, 10>;
 namespace stdr = std::ranges;
 
 static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
+static_assert(stdr::common_range<range>);
+
 static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
+static_assert(stdr::common_range<range const>);

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

 
 #include <concepts>
 #include <ranges>
 
 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(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
+static_assert(stdr::common_range<range const>);

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

 
 #include <concepts>
 #include <ranges>
 
 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(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
+static_assert(stdr::common_range<range const>);

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

 
 #include <concepts>
 #include <ranges>
 
 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(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
+static_assert(stdr::common_range<range const>);

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

 
 #include <concepts>
 #include <ranges>
 
 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(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
+static_assert(stdr::common_range<range const>);

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

 
 #include <concepts>
 #include <ranges>
 
 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(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
+static_assert(stdr::common_range<range const>);

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

 
 #include <concepts>
 #include <ranges>
 
 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(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
+static_assert(stdr::common_range<range const>);

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

 // UNSUPPORTED: gcc-10
 // XFAIL: msvc && clang
 
 // unordered_multimap
 
 #include <unordered_map>
 
 #include <concepts>
 #include <ranges>
 
 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(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
+static_assert(stdr::common_range<range const>);

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

 
 #include <concepts>
 #include <ranges>
 
 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(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
+static_assert(stdr::common_range<range const>);

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

 
 #include <concepts>
 #include <ranges>
 
 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(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
+static_assert(stdr::common_range<range const>);

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

 
 #include <concepts>
 #include <ranges>
 
 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(std::same_as<stdr::iterator_t<range const>, range::iterator>);
+static_assert(stdr::common_range<range 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
-// XFAIL: msvc && clang
+// XFAIL: *
 
 // directory_iterator, recursive_directory_iterator
 
 #include "filesystem_include.h"
 
 #include <concepts>
 #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(std::same_as<stdr::iterator_t<fs::directory_iterator const>, fs::directory_iterator>);
+static_assert(stdr::common_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(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>);

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

 #include "filesystem_include.h"
 
 #include <concepts>
 #include <ranges>
 
 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(std::same_as<stdr::iterator_t<fs::path const>, fs::path::const_iterator>);
+static_assert(stdr::common_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
+// XFAIL: msvc && clang
+
+// 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
+// XFAIL: msvc && clang
+
+// 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
+// XFAIL: msvc && clang
+
+// 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<> >, sentinel>);
+static_assert(std::same_as<stdr::sentinel_t<test_range<> const>, sentinel>);
+static_assert(std::same_as<stdr::sentinel_t<test_non_const_range<> >, sentinel>);
+static_assert(std::same_as<stdr::sentinel_t<test_common_range<> >, input_iterator<int*> >);
+static_assert(std::same_as<stdr::sentinel_t<test_common_range<> const>, input_iterator<int const*> >);
+static_assert(std::same_as<stdr::sentinel_t<test_non_const_common_range<> >, input_iterator<int*> >);

libcxx/test/std/ranges/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
+// XFAIL: msvc && clang
+
+// 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<input_iterator> >);
+static_assert(!stdr::common_range<test_range<input_iterator> const>);
+
+static_assert(!stdr::common_range<test_non_const_range<input_iterator> >);
+static_assert(!stdr::common_range<test_non_const_range<input_iterator> const>);
+
+static_assert(stdr::common_range<test_common_range<input_iterator> >);
+static_assert(stdr::common_range<test_common_range<input_iterator> const>);
+
+static_assert(stdr::common_range<test_non_const_common_range<input_iterator> >);
+static_assert(!stdr::common_range<test_non_const_common_range<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/re/re.results/range_concept_conformance.compile.pass.cpp

 #include <regex>
 
 #include <concepts>
 #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(std::same_as<stdr::iterator_t<std::cmatch const>, std::cmatch::const_iterator>);
+static_assert(stdr::common_range<std::cmatch const>);

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

 // string
 
 #include <string>
 
 #include <concepts>
 #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(std::same_as<stdr::iterator_t<std::string const>, std::string::const_iterator>);
+static_assert(stdr::common_range<std::string const>);

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

 #include <string_view>
 
 #include <concepts>
 #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(std::same_as<stdr::iterator_t<std::string_view const>, std::string_view::const_iterator>);
+static_assert(stdr::common_range<std::string_view const>);

libcxx/test/support/test_range.h

 #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;
 };
 
 // clang-format off
-template <template <class...> class I>
+template <template <class...> class I = input_iterator>
 requires std::input_or_output_iterator<I<int*> >
 struct test_range {
   I<int*> begin();
   I<int const*> begin() const;
   sentinel end();
   sentinel end() const;
 };
 
-template <template <class...> class I>
+template <template <class...> class I = input_iterator>
 requires std::input_or_output_iterator<I<int*> >
 struct test_non_const_range {
   I<int*> begin();
   sentinel end();
 };
 
-template <template <class...> class I>
+template <template <class...> class I = input_iterator>
 requires std::input_or_output_iterator<I<int*> >
 struct test_common_range {
   I<int*> begin();
   I<int const*> begin() const;
   I<int*> end();
-  I<int*> end() const;
+  I<int const*> end() const;
 };
 
-template <template <class...> class I>
+template <template <class...> class I = input_iterator>
 requires std::input_or_output_iterator<I<int*> >
 struct test_non_const_common_range {
   I<int*> begin();
   I<int*> end();
 };
 
 // clang-format on
 
 #endif // LIBCXX_TEST_SUPPORT_TEST_RANGE_H