[libcxx][ranges] Add `ranges::common_view`.

[zoecarver]

• Update module map.
• Update synopsis.
• Add correct enable_borrowed_range.

[• Quuxplusone]

libcxx/include/__ranges/common_view.h

15–16

a-z plz (and throughout, if I missed any)

85

Nit: lose the _VSTD on declval, for consistency with other libc++ headers. (It's ADL-proof by virtue of taking no arguments.)
But also, why is this not

template<class _Range>
common_view(_Range&&)
  -> common_view<views::all_t<_Range>>;

as in the standard's reference implementation? If we have all, we must have all_t, right?

libcxx/include/ranges

126

Also update the modulemap.

libcxx/test/std/ranges/range.adaptors/range.common.view/base.pass.cpp

29

Style nit throughout (not a blocker): friend constexpr
https://quuxplusone.github.io/blog/2021/04/03/static-constexpr-whittling-knife/#friendness-to-befriend-an-entity

73

I suggest adding above line 72:

static_assert(!has_lvalue_qualified_base(common));

which could be implemented as

constexpr bool has_lvalue_qualified_base(auto&& view) {
    return requires { view.base(); };
}

This replaces your BaseEnabled, but puts the test in the salient place — right where we would expect to see the test for common.base(), you'd show the reason it's not tested. (This eliminates lines 59-63.)

libcxx/test/std/ranges/range.adaptors/range.common.view/begin.pass.cpp

81

/Randomc/Random/

94–99

I'd prefer to see these as hidden friends of RandomAccessIter, or know the technical reason why they can't be. Ditto lines 72-77 above.

116

Why do we need this if? What piece is not constexpr-friendly here?

libcxx/test/std/ranges/range.adaptors/range.common.view/ctad.compile.pass.cpp

37

I'd call this BorrowedRange. AIUI, the salient thing about a borrowed-range type is that it is borrowed, e.g. string_view. It's not merely borrow-able (like, I guess, string might be considered borrow-able).

47–56

Consider named variables, and test both lvalues and rvalues.

void test_ctad() {
    View v;
    Range r;
    BorrowedRange br;
    static_assert(std::same_as<
        decltype(std::ranges::common_view(v)),
        std::ranges::common_view<View>
    >);
    static_assert(std::same_as<
        decltype(std::ranges::common_view(r)),
        std::ranges::common_view<std::ranges::ref_view<Range>>
    >);
    // std::ranges::common_view(std::move(r)) is ill-formed
    static_assert(std::same_as<
        decltype(std::ranges::common_view(br)),
        std::ranges::common_view<std::ranges::ref_view<BorrowedRange>>
    >);
    static_assert(std::same_as<
        decltype(std::ranges::common_view(std::move(br))),
        std::ranges::common_view<std::views::all_t<BorrowedRange>>
    >);
}

[zoecarver]

libcxx/test/std/ranges/range.adaptors/range.common.view/begin.pass.cpp

94–99

RandomAccessIter is a type alias to random_access_iterator. I think we both agree we shouldn't add these as hidden friends to random_access_iterator.

116

Basically none of common_iterator is constexpr. Sigh.

[• Quuxplusone]

libcxx/test/std/ranges/range.adaptors/range.common.view/begin.pass.cpp

94–99

Yes, although also it's not great to see them just hanging out in some random test file.
The next most stylish thing to do would be to make SizedRandomcAccessView [sic] have a nested type struct sentinel, and then make these hidden friends of SizedRandomcAccessView::sentinel. (I'm still rather unclear on why we have this generic "sentinel wrapper" type; it never seems to be quite what we want for testing.) But anyway, that's clearly too big a change for this PR, so I'm OK with leaving this hack for now.

116

I see. Ugh. The constructor and accessors of common_view are constexpr, but common_iterator isn't. OK.

[zoecarver]

libcxx/include/__ranges/common_view.h

85

We don't have all_t, it's on my list of things todo.

libcxx/include/ranges

126

It's already updated.

[zoecarver]

Apply Arthur's comments.

[ldionne]

Per OTS review.

libcxx/test/std/ranges/range.adaptors/range.common.view/base.pass.cpp

59

Could you store the result of .base() in a variable just so we get an explicit assertion of what the return type of the function is?

libcxx/test/std/ranges/range.adaptors/range.common.view/begin.pass.cpp

72–77

Are those only for convenience? If so, they should be removed, otherwise, can you please add a one-liner comment about why they are needed? (same below)

113

We should not be testing begin() by dereferencing the resulting iterator. Instead, we should compare the iterator itself. Is that possible or am I missing something?

116

Instead of doing this if (!is_constant_evaluated()), I would make the test non-constexpr and add a simpler constexpr test that only calls begin() (const and non-const) in a constexpr context.

Then, when we go back and make common_iterator constexpr-friendly, we'll only have to remove that tiny test and make the whole test constexpr.

libcxx/test/std/ranges/range.adaptors/range.common.view/borrowing.compile.pass.cpp

19

Not needed. (might apply elsewhere too)

libcxx/test/std/ranges/range.adaptors/range.common.view/ctad.compile.pass.cpp

58

Is it ill-formed, or should it SFINAE away? I think it's the latter, right? If so, we can use a requires to check it.

libcxx/test/std/ranges/range.adaptors/range.common.view/ctor.pass.cpp

13–14

I would like to split this into ctor.default.pass.cpp and ctor.view.pass.cpp for consistency w/ the rest of the test suite.

libcxx/test/support/test_iterators.h

927

constexpr I const& base() const?

[zoecarver]

Apply Louis' comments.

[zoecarver]

• Global constexpr friend -> friend constexpr.

[zoecarver]

Rebase.

[ldionne]

Please make sure you go through https://libcxx.llvm.org/Contributing.html (I think you've got everything except the visibility macros, which I added recently to the list, but it might be worth double-checking).

This basically LGTM. You can update this and ping me again, but it should be a no-brainer.

libcxx/include/__ranges/common_view.h

40

Missing _LIBCPP_HIDE_FROM_ABI everywhere. Also missing from common_iterator.h, sorry for not noticing earlier.

Note: Yes, that's a pain. If someone wants to work on solving this a better way, let me know, I've got some ideas with inline namespaces that might be worth exploring.

libcxx/test/std/ranges/range.adaptors/range.common.view/ctor.view.pass.cpp

54 ↗

(On Diff #360189)

Same comment as above with std::is_constant_evaluated().

[zoecarver]

Apply review comments.

libcxx/include/CMakeLists.txt

set(files
   __memory/unique_ptr.h
   __memory/uses_allocator.h
   __mutex_base
   __node_handle
   __nullptr
   __random/uniform_int_distribution.h
   __ranges/access.h
   __ranges/all.h
+  __ranges/common_view.h
   __ranges/concepts.h
   __ranges/copyable_box.h
   __ranges/data.h
   __ranges/drop_view.h
   __ranges/empty_view.h
   __ranges/empty.h
   __ranges/enable_borrowed_range.h
   __ranges/enable_view.h

libcxx/include/__ranges/common_view.h

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+#ifndef _LIBCPP___RANGES_COMMON_VIEW_H
+#define _LIBCPP___RANGES_COMMON_VIEW_H
+
+#include <__config>
+#include <__iterator/common_iterator.h>
+#include <__ranges/concepts.h>
+#include <__ranges/view_interface.h>
+#include <concepts>
+#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 {
+
+template<view _View>
+  requires (!common_range<_View> && copyable<iterator_t<_View>>)
+class common_view : public view_interface<common_view<_View>> {
+  _View __base_ = _View();
+
+public:
+  common_view() requires default_initializable<_View> = default;
+
+  constexpr explicit common_view(_View __v) : __base_(_VSTD::move(__v)) { }
+
+  constexpr _View base() const& requires copy_constructible<_View> { return __base_; }
+  constexpr _View base() && { return _VSTD::move(__base_); }
+
+  constexpr auto begin() {
+    if constexpr (random_access_range<_View> && sized_range<_View>)
+      return ranges::begin(__base_);
+    else
+      return common_iterator<iterator_t<_View>, sentinel_t<_View>>(ranges::begin(__base_));
+  }
+
+  constexpr auto begin() const requires range<const _View> {
+    if constexpr (random_access_range<const _View> && sized_range<const _View>)
+      return ranges::begin(__base_);
+    else
+      return common_iterator<iterator_t<const _View>, sentinel_t<const _View>>(ranges::begin(__base_));
+  }
+
+  constexpr auto end() {
+    if constexpr (random_access_range<_View> && sized_range<_View>)
+      return ranges::begin(__base_) + ranges::size(__base_);
+    else
+      return common_iterator<iterator_t<_View>, sentinel_t<_View>>(ranges::end(__base_));
+  }
+
+  constexpr auto end() const requires range<const _View> {
+    if constexpr (random_access_range<const _View> && sized_range<const _View>)
+      return ranges::begin(__base_) + ranges::size(__base_);
+    else
+      return common_iterator<iterator_t<const _View>, sentinel_t<const _View>>(ranges::end(__base_));
+  }
+
+  constexpr auto size() requires sized_range<_View> {
+    return ranges::size(__base_);
+  }
+
+  constexpr auto size() const requires sized_range<const _View> {
+    return ranges::size(__base_);
+  }
+};
+
+// TODO: use all_t here when it's implemented.
+template<class _Range>
+common_view(_Range&&)
+  -> common_view<decltype(views::all(declval<_Range>()))>;
+
+template<class _View>
+inline constexpr bool enable_borrowed_range<common_view<_View>> = enable_borrowed_range<_View>;
+
+} // namespace ranges
+
+#endif // !defined(_LIBCPP_HAS_NO_RANGES)
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___RANGES_COMMON_VIEW_H

libcxx/include/module.modulemap

module ranges {
     export compare
     export initializer_list
     export iterator
     export *
 
     module __ranges {
       module access                 { header "__ranges/access.h"                }
       module all                    { header "__ranges/all.h"                   }
+      module common_view            { header "__ranges/common_view.h"           }
       module concepts               { header "__ranges/concepts.h"              }
       module copyable_box           { header "__ranges/copyable_box.h"          }
       module data                   { header "__ranges/data.h"                  }
       module empty                  { header "__ranges/empty.h"                 }
       module empty_view             { header "__ranges/empty_view.h"            }
       module enable_borrowed_range  { header "__ranges/enable_borrowed_range.h" }
       module enable_view            { header "__ranges/enable_view.h"           }
       module ref_view               { header "__ranges/ref_view.h"              }

libcxx/include/ranges

namespace std::ranges {
 
   // [range.transform], transform view
   template<input_range V, copy_constructible F>
     requires view<V> && is_object_v<F> &&
              regular_invocable<F&, range_reference_t<V>> &&
              can-reference<invoke_result_t<F&, range_reference_t<V>>>
   class transform_view;
 
+  // [range.common], common view
+  template<view V>
+    requires (!common_range<V> && copyable<iterator_t<V>>)
+  class common_view;
+
+  template<class T>
+  inline constexpr bool enable_borrowed_range<common_view<T>> = enable_borrowed_range<T>;
 }
 
 */
 
 #include <__config>
 #include <__ranges/access.h>
 #include <__ranges/all.h>
+#include <__ranges/common_view.h>
 #include <__ranges/concepts.h>
 #include <__ranges/data.h>
 #include <__ranges/drop_view.h>
 #include <__ranges/empty.h>
 #include <__ranges/empty_view.h>
 #include <__ranges/enable_borrowed_range.h>
 #include <__ranges/enable_view.h>
 #include <__ranges/ref_view.h>

libcxx/test/std/ranges/range.adaptors/range.common.view/base.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
+
+// constexpr V base() const& requires copy_constructible<V>;
+// constexpr V base() &&;
+
+#include <ranges>
+#include <cassert>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+#include "test_range.h"
+
+struct ContiguousView : std::ranges::view_base {
+  int *ptr_;
+  constexpr ContiguousView(int* ptr) : ptr_(ptr) {}
+  constexpr ContiguousView(ContiguousView&&) = default;
+  constexpr ContiguousView& operator=(ContiguousView&&) = default;
+  constexpr friend int* begin(ContiguousView& view) { return view.ptr_; }
+  constexpr friend int* begin(ContiguousView const& view) { return view.ptr_; }
+  constexpr friend sentinel_wrapper<int*> end(ContiguousView& view) {
+    return sentinel_wrapper<int*>{view.ptr_ + 8};
+  }
+  constexpr friend sentinel_wrapper<int*> end(ContiguousView const& view) {
+    return sentinel_wrapper<int*>{view.ptr_ + 8};
+  }
+};
+
+struct CopyableView : std::ranges::view_base {
+  int *ptr_;
+  constexpr CopyableView(int* ptr) : ptr_(ptr) {}
+  constexpr friend int* begin(CopyableView& view) { return view.ptr_; }
+  constexpr friend int* begin(CopyableView const& view) { return view.ptr_; }
+  constexpr friend sentinel_wrapper<int*> end(CopyableView& view) {
+    return sentinel_wrapper<int*>{view.ptr_ + 8};
+  }
+  constexpr friend sentinel_wrapper<int*> end(CopyableView const& view) {
+    return sentinel_wrapper<int*>{view.ptr_ + 8};
+  }
+};
+
+constexpr bool hasLValueQualifiedBase(auto&& view) {
+    return requires { view.base(); };
+}
+
+constexpr bool test() {
+  int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+  {
+    std::ranges::common_view<CopyableView> common(CopyableView{buffer});
+    assert(common.base().ptr_ == buffer);
+    assert(std::move(common).base().ptr_ == buffer);
+    static_assert(hasLValueQualifiedBase(common));
+  }
+
+  {
+    std::ranges::common_view<ContiguousView> common(ContiguousView{buffer});
+    assert(std::move(common).base().ptr_ == buffer);
+    static_assert(!hasLValueQualifiedBase(common));
+  }
+
+  {
+    const std::ranges::common_view<CopyableView> common(CopyableView{buffer});
+    assert(common.base().ptr_ == buffer);
+    assert(std::move(common).base().ptr_ == buffer);
+    static_assert(hasLValueQualifiedBase(common));
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.common.view/begin.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
+
+// constexpr auto begin();
+// constexpr auto begin() const requires range<const V>;
+
+#include <ranges>
+#include <cassert>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+#include "test_range.h"
+
+struct ContiguousView : std::ranges::view_base {
+  int *ptr_;
+  constexpr ContiguousView(int* ptr) : ptr_(ptr) {}
+  constexpr ContiguousView(ContiguousView&&) = default;
+  constexpr ContiguousView& operator=(ContiguousView&&) = default;
+  constexpr friend int* begin(ContiguousView& view) { return view.ptr_; }
+  constexpr friend int* begin(ContiguousView const& view) { return view.ptr_; }
+  constexpr friend sentinel_wrapper<int*> end(ContiguousView& view) {
+    return sentinel_wrapper<int*>{view.ptr_ + 8};
+  }
+  constexpr friend sentinel_wrapper<int*> end(ContiguousView const& view) {
+    return sentinel_wrapper<int*>{view.ptr_ + 8};
+  }
+};
+
+struct CopyableView : std::ranges::view_base {
+  int *ptr_;
+  constexpr CopyableView(int* ptr) : ptr_(ptr) {}
+  constexpr friend int* begin(CopyableView& view) { return view.ptr_; }
+  constexpr friend int* begin(CopyableView const& view) { return view.ptr_; }
+  constexpr friend sentinel_wrapper<int*> end(CopyableView& view) {
+    return sentinel_wrapper<int*>{view.ptr_ + 8};
+  }
+  constexpr friend sentinel_wrapper<int*> end(CopyableView const& view) {
+    return sentinel_wrapper<int*>{view.ptr_ + 8};
+  }
+};
+
+struct MutableView : std::ranges::view_base {
+  int *ptr_;
+  constexpr MutableView(int* ptr) : ptr_(ptr) {}
+  constexpr int* begin() { return ptr_; }
+  constexpr sentinel_wrapper<int*> end() { return sentinel_wrapper<int*>{ptr_ + 8}; }
+};
+
+using ForwardIter = forward_iterator<int*>;
+struct SizedForwardView : std::ranges::view_base {
+  int *ptr_;
+  constexpr SizedForwardView(int* ptr) : ptr_(ptr) {}
+  constexpr friend ForwardIter begin(SizedForwardView& view) { return ForwardIter(view.ptr_); }
+  constexpr friend ForwardIter begin(SizedForwardView const& view) { return ForwardIter(view.ptr_); }
+  constexpr friend sentinel_wrapper<ForwardIter> end(SizedForwardView& view) {
+    return sentinel_wrapper<ForwardIter>{ForwardIter(view.ptr_ + 8)};
+  }
+  constexpr friend sentinel_wrapper<ForwardIter> end(SizedForwardView const& view) {
+    return sentinel_wrapper<ForwardIter>{ForwardIter(view.ptr_ + 8)};
+  }
+};
+
+constexpr auto operator-(sentinel_wrapper<ForwardIter> sent, ForwardIter iter) {
+  return sent.base().base() - iter.base();
+}
+constexpr auto operator-(ForwardIter iter, sentinel_wrapper<ForwardIter> sent) {
+  return iter.base() - sent.base().base();
+}
+
+using RandomAccessIter = random_access_iterator<int*>;
+struct SizedRandomAccessView : std::ranges::view_base {
+  int *ptr_;
+  constexpr SizedRandomAccessView(int* ptr) : ptr_(ptr) {}
+  constexpr friend RandomAccessIter begin(SizedRandomAccessView& view) { return RandomAccessIter(view.ptr_); }
+  constexpr friend RandomAccessIter begin(SizedRandomAccessView const& view) { return RandomAccessIter(view.ptr_); }
+  constexpr friend sentinel_wrapper<RandomAccessIter> end(SizedRandomAccessView& view) {
+    return sentinel_wrapper<RandomAccessIter>{RandomAccessIter(view.ptr_ + 8)};
+  }
+  constexpr friend sentinel_wrapper<RandomAccessIter> end(SizedRandomAccessView const& view) {
+    return sentinel_wrapper<RandomAccessIter>{RandomAccessIter(view.ptr_ + 8)};
+  }
+};
+
+constexpr auto operator-(sentinel_wrapper<RandomAccessIter> sent, RandomAccessIter iter) {
+  return sent.base().base() - iter.base();
+}
+constexpr auto operator-(RandomAccessIter iter, sentinel_wrapper<RandomAccessIter> sent) {
+  return iter.base() - sent.base().base();
+}
+
+template<class T>
+concept BeginEnabled = requires(const std::ranges::common_view<T>& comm) {
+  comm.begin();
+};
+
+constexpr bool test() {
+  int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+  {
+    static_assert( BeginEnabled<CopyableView>);
+    static_assert(!BeginEnabled<MutableView>);
+  }
+
+  {
+    std::ranges::common_view<SizedForwardView> comm(SizedForwardView{buffer});
+    if (!std::is_constant_evaluated())
+      assert(*comm.begin() == 1);
+    ASSERT_SAME_TYPE(decltype(comm.begin()), std::common_iterator<ForwardIter, sentinel_wrapper<ForwardIter>>);
+  }
+
+  {
+    std::ranges::common_view<ContiguousView> comm(ContiguousView{buffer});
+    if (!std::is_constant_evaluated())
+      assert(*comm.begin() == 1);
+    ASSERT_SAME_TYPE(decltype(comm.begin()), std::common_iterator<int*, sentinel_wrapper<int*>>);
+  }
+
+  {
+    std::ranges::common_view<SizedRandomAccessView> comm(SizedRandomAccessView{buffer});
+    if (!std::is_constant_evaluated())
+      assert(*comm.begin() == 1);
+    ASSERT_SAME_TYPE(decltype(comm.begin()), RandomAccessIter);
+  }
+
+  {
+    const std::ranges::common_view<SizedForwardView> comm(SizedForwardView{buffer});
+    if (!std::is_constant_evaluated())
+      assert(*comm.begin() == 1);
+    ASSERT_SAME_TYPE(decltype(comm.begin()), std::common_iterator<ForwardIter, sentinel_wrapper<ForwardIter>>);
+  }
+
+  {
+    const std::ranges::common_view<CopyableView> comm(CopyableView{buffer});
+    if (!std::is_constant_evaluated())
+      assert(*comm.begin() == 1);
+    ASSERT_SAME_TYPE(decltype(comm.begin()), std::common_iterator<int*, sentinel_wrapper<int*>>);
+  }
+
+  {
+    const std::ranges::common_view<SizedRandomAccessView> comm(SizedRandomAccessView{buffer});
+    if (!std::is_constant_evaluated())
+      assert(*comm.begin() == 1);
+    ASSERT_SAME_TYPE(decltype(comm.begin()), RandomAccessIter);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.common.view/borrowing.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>
+//   inline constexpr bool enable_borrowed_range<common_view<T>> = enable_borrowed_range<T>;
+
+#include <ranges>
+#include <cassert>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+
+struct View : std::ranges::view_base {
+  friend int* begin(View&);
+  friend int* begin(View const&);
+  friend sentinel_wrapper<int*> end(View&);
+  friend sentinel_wrapper<int*> end(View const&);
+};
+
+struct BorrowableView : std::ranges::view_base {
+  friend int* begin(BorrowableView&);
+  friend int* begin(BorrowableView const&);
+  friend sentinel_wrapper<int*> end(BorrowableView&);
+  friend sentinel_wrapper<int*> end(BorrowableView const&);
+};
+
+template<>
+inline constexpr bool std::ranges::enable_borrowed_range<BorrowableView> = true;
+
+static_assert(!std::ranges::enable_borrowed_range<std::ranges::common_view<View>>);
+static_assert( std::ranges::enable_borrowed_range<std::ranges::common_view<BorrowableView>>);

libcxx/test/std/ranges/range.adaptors/range.common.view/ctad.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// template<class R>
+//   common_view(R&&) -> common_view<views::all_t<R>>;
+
+#include <ranges>
+#include <cassert>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+
+struct View : std::ranges::view_base {
+  friend int* begin(View&);
+  friend int* begin(View const&);
+  friend sentinel_wrapper<int*> end(View&);
+  friend sentinel_wrapper<int*> end(View const&);
+};
+
+struct Range {
+  friend int* begin(Range&);
+  friend int* begin(Range const&);
+  friend sentinel_wrapper<int*> end(Range&);
+  friend sentinel_wrapper<int*> end(Range const&);
+};
+
+struct BorrowedRange {
+  friend int* begin(BorrowableRange&);
+  friend int* begin(BorrowableRange const&);
+  friend sentinel_wrapper<int*> end(BorrowableRange&);
+  friend sentinel_wrapper<int*> end(BorrowableRange const&);
+};
+
+template<>
+inline constexpr bool std::ranges::enable_borrowed_range<BorrowedRange> = true;
+
+void testCTAD() {
+    View v;
+    Range r;
+    BorrowedRange br;
+    static_assert(std::same_as<
+        decltype(std::ranges::common_view(v)),
+        std::ranges::common_view<View>
+    >);
+    static_assert(std::same_as<
+        decltype(std::ranges::common_view(r)),
+        std::ranges::common_view<std::ranges::ref_view<Range>>
+    >);
+    // std::ranges::common_view(std::move(r)) is ill-formed
+    static_assert(std::same_as<
+        decltype(std::ranges::common_view(br)),
+        std::ranges::common_view<std::ranges::ref_view<BorrowedRange>>
+    >);
+    static_assert(std::same_as<
+        decltype(std::ranges::common_view(std::move(br))),
+        std::ranges::common_view<std::views::all_t<BorrowedRange>>
+    >);
+}

libcxx/test/std/ranges/range.adaptors/range.common.view/ctor.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
+
+// common_view() requires default_initializable<V> = default;
+// constexpr explicit common_view(V r);
+
+#include <ranges>
+#include <cassert>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+#include "test_range.h"
+
+struct ContiguousView : std::ranges::view_base {
+  int *ptr_;
+  constexpr ContiguousView(int* ptr) : ptr_(ptr) {}
+  constexpr ContiguousView(ContiguousView&&) = default;
+  constexpr ContiguousView& operator=(ContiguousView&&) = default;
+  constexpr friend int* begin(ContiguousView& view) { return view.ptr_; }
+  constexpr friend int* begin(ContiguousView const& view) { return view.ptr_; }
+  constexpr friend sentinel_wrapper<int*> end(ContiguousView& view) {
+    return sentinel_wrapper<int*>{view.ptr_ + 8};
+  }
+  constexpr friend sentinel_wrapper<int*> end(ContiguousView const& view) {
+    return sentinel_wrapper<int*>{view.ptr_ + 8};
+  }
+};
+
+struct CopyableView : std::ranges::view_base {
+  int *ptr_;
+  constexpr CopyableView(int* ptr) : ptr_(ptr) {}
+  constexpr friend int* begin(CopyableView& view) { return view.ptr_; }
+  constexpr friend int* begin(CopyableView const& view) { return view.ptr_; }
+  constexpr friend sentinel_wrapper<int*> end(CopyableView& view) {
+    return sentinel_wrapper<int*>{view.ptr_ + 8};
+  }
+  constexpr friend sentinel_wrapper<int*> end(CopyableView const& view) {
+    return sentinel_wrapper<int*>{view.ptr_ + 8};
+  }
+};
+
+struct DefaultConstructibleView : std::ranges::view_base {
+  DefaultConstructibleView();
+  friend int* begin(DefaultConstructibleView& view);
+  friend int* begin(DefaultConstructibleView const& view);
+  friend sentinel_wrapper<int*> end(DefaultConstructibleView& view);
+  friend sentinel_wrapper<int*> end(DefaultConstructibleView const& view);
+};
+
+constexpr bool test() {
+  int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+  {
+    static_assert(!std::default_initializable<std::ranges::common_view<CopyableView>>);
+    static_assert( std::default_initializable<std::ranges::common_view<DefaultConstructibleView>>);
+  }
+
+  {
+    std::ranges::common_view<ContiguousView> common(ContiguousView{buffer});
+    if (!std::is_constant_evaluated())
+      assert(*common.begin() == 1);
+  }
+
+  {
+    ContiguousView v{buffer};
+    std::ranges::common_view<ContiguousView> common(std::move(v));
+    if (!std::is_constant_evaluated())
+      assert(*common.begin() == 1);
+  }
+
+  {
+    const std::ranges::common_view<ContiguousView> common(ContiguousView{buffer});
+    if (!std::is_constant_evaluated())
+      assert(*common.begin() == 1);
+  }
+
+  {
+    const CopyableView v{buffer};
+    const std::ranges::common_view<CopyableView> common(v);
+    if (!std::is_constant_evaluated())
+      assert(*common.begin() == 1);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.common.view/end.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
+
+// constexpr auto end();
+// constexpr auto end() const requires range<const V>;
+
+#include <ranges>
+#include <cassert>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+#include "test_range.h"
+
+struct CopyableView : std::ranges::view_base {
+  int *ptr_;
+  constexpr CopyableView(int* ptr) : ptr_(ptr) {}
+  constexpr friend int* begin(CopyableView& view) { return view.ptr_; }
+  constexpr friend int* begin(CopyableView const& view) { return view.ptr_; }
+  constexpr friend sentinel_wrapper<int*> end(CopyableView& view) {
+    return sentinel_wrapper<int*>{view.ptr_ + 8};
+  }
+  constexpr friend sentinel_wrapper<int*> end(CopyableView const& view) {
+    return sentinel_wrapper<int*>{view.ptr_ + 8};
+  }
+};
+
+using ForwardIter = forward_iterator<int*>;
+struct SizedForwardView : std::ranges::view_base {
+  int *ptr_;
+  constexpr SizedForwardView(int* ptr) : ptr_(ptr) {}
+  constexpr friend ForwardIter begin(SizedForwardView& view) { return ForwardIter(view.ptr_); }
+  constexpr friend ForwardIter begin(SizedForwardView const& view) { return ForwardIter(view.ptr_); }
+  constexpr friend sentinel_wrapper<ForwardIter> end(SizedForwardView& view) {
+    return sentinel_wrapper<ForwardIter>{ForwardIter(view.ptr_ + 8)};
+  }
+  constexpr friend sentinel_wrapper<ForwardIter> end(SizedForwardView const& view) {
+    return sentinel_wrapper<ForwardIter>{ForwardIter(view.ptr_ + 8)};
+  }
+};
+
+constexpr auto operator-(sentinel_wrapper<ForwardIter> sent, ForwardIter iter) {
+  return sent.base().base() - iter.base();
+}
+constexpr auto operator-(ForwardIter iter, sentinel_wrapper<ForwardIter> sent) {
+  return iter.base() - sent.base().base();
+}
+
+using RandomAccessIter = random_access_iterator<int*>;
+struct SizedRandomcAccessView : std::ranges::view_base {
+  int *ptr_;
+  constexpr SizedRandomcAccessView(int* ptr) : ptr_(ptr) {}
+  constexpr friend RandomAccessIter begin(SizedRandomcAccessView& view) { return RandomAccessIter(view.ptr_); }
+  constexpr friend RandomAccessIter begin(SizedRandomcAccessView const& view) { return RandomAccessIter(view.ptr_); }
+  constexpr friend sentinel_wrapper<RandomAccessIter> end(SizedRandomcAccessView& view) {
+    return sentinel_wrapper<RandomAccessIter>{RandomAccessIter(view.ptr_ + 8)};
+  }
+  constexpr friend sentinel_wrapper<RandomAccessIter> end(SizedRandomcAccessView const& view) {
+    return sentinel_wrapper<RandomAccessIter>{RandomAccessIter(view.ptr_ + 8)};
+  }
+};
+
+constexpr auto operator-(sentinel_wrapper<RandomAccessIter> sent, RandomAccessIter iter) {
+  return sent.base().base() - iter.base();
+}
+constexpr auto operator-(RandomAccessIter iter, sentinel_wrapper<RandomAccessIter> sent) {
+  return iter.base() - sent.base().base();
+}
+
+constexpr bool test() {
+  int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+  using CommonForwardIter = std::common_iterator<ForwardIter, sentinel_wrapper<ForwardIter>>;
+  using CommonIntIter = std::common_iterator<int*, sentinel_wrapper<int*>>;
+
+  {
+    std::ranges::common_view<SizedRandomcAccessView> comm(SizedRandomcAccessView{buffer});
+    assert(comm.end().base() == buffer + 8);
+    // Note this should NOT be the sentinel type.
+    ASSERT_SAME_TYPE(decltype(comm.end()), RandomAccessIter);
+  }
+
+  {
+    std::ranges::common_view<SizedForwardView> comm(SizedForwardView{buffer});
+    if (!std::is_constant_evaluated())
+      assert(comm.end() == CommonForwardIter(sentinel_wrapper<ForwardIter>(ForwardIter(buffer + 8))));
+    ASSERT_SAME_TYPE(decltype(comm.end()), CommonForwardIter);
+  }
+
+  {
+    std::ranges::common_view<CopyableView> comm(CopyableView{buffer});
+    if (!std::is_constant_evaluated())
+      assert(comm.end() == CommonIntIter(sentinel_wrapper<int*>(buffer + 8)));
+    ASSERT_SAME_TYPE(decltype(comm.end()), CommonIntIter);
+  }
+
+  {
+    const std::ranges::common_view<SizedRandomcAccessView> comm(SizedRandomcAccessView{buffer});
+    assert(comm.end().base() == buffer + 8);
+    // Note this should NOT be the sentinel type.
+    ASSERT_SAME_TYPE(decltype(comm.end()), RandomAccessIter);
+  }
+
+  {
+    const std::ranges::common_view<SizedForwardView> comm(SizedForwardView{buffer});
+    if (!std::is_constant_evaluated())
+      assert(comm.end() == CommonForwardIter(sentinel_wrapper<ForwardIter>(ForwardIter(buffer + 8))));
+    ASSERT_SAME_TYPE(decltype(comm.end()), CommonForwardIter);
+  }
+
+  {
+    const std::ranges::common_view<CopyableView> comm(CopyableView{buffer});
+    if (!std::is_constant_evaluated())
+      assert(comm.end() == CommonIntIter(sentinel_wrapper<int*>(buffer + 8)));
+    ASSERT_SAME_TYPE(decltype(comm.end()), CommonIntIter);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.common.view/size.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
+
+// constexpr auto size() requires sized_range<V>
+// constexpr auto size() const requires sized_range<const V>
+
+#include <ranges>
+#include <cassert>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+#include "test_range.h"
+
+struct CopyableView : std::ranges::view_base {
+  int *ptr_;
+  constexpr CopyableView(int* ptr) : ptr_(ptr) {}
+  constexpr friend int* begin(CopyableView& view) { return view.ptr_; }
+  constexpr friend int* begin(CopyableView const& view) { return view.ptr_; }
+  constexpr friend sentinel_wrapper<int*> end(CopyableView& view) {
+    return sentinel_wrapper<int*>{view.ptr_ + 8};
+  }
+  constexpr friend sentinel_wrapper<int*> end(CopyableView const& view) {
+    return sentinel_wrapper<int*>{view.ptr_ + 8};
+  }
+};
+
+using ForwardIter = forward_iterator<int*>;
+struct SizedForwardView : std::ranges::view_base {
+  int *ptr_;
+  constexpr SizedForwardView(int* ptr) : ptr_(ptr) {}
+  constexpr friend ForwardIter begin(SizedForwardView& view) { return ForwardIter(view.ptr_); }
+  constexpr friend ForwardIter begin(SizedForwardView const& view) { return ForwardIter(view.ptr_); }
+  constexpr friend sentinel_wrapper<ForwardIter> end(SizedForwardView& view) {
+    return sentinel_wrapper<ForwardIter>{ForwardIter(view.ptr_ + 8)};
+  }
+  constexpr friend sentinel_wrapper<ForwardIter> end(SizedForwardView const& view) {
+    return sentinel_wrapper<ForwardIter>{ForwardIter(view.ptr_ + 8)};
+  }
+};
+
+constexpr auto operator-(sentinel_wrapper<ForwardIter> sent, ForwardIter iter) {
+  return sent.base().base() - iter.base();
+}
+constexpr auto operator-(ForwardIter iter, sentinel_wrapper<ForwardIter> sent) {
+  return iter.base() - sent.base().base();
+}
+
+template<class T>
+concept SizeEnabled = requires(const std::ranges::common_view<T>& comm) {
+  comm.size();
+};
+
+constexpr bool test() {
+  int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+  {
+    static_assert( SizeEnabled<SizedForwardView>);
+    static_assert(!SizeEnabled<CopyableView>);
+  }
+
+  {
+    std::ranges::common_view<SizedForwardView> common(SizedForwardView{buffer});
+    assert(common.size() == 8);
+  }
+
+  {
+    const std::ranges::common_view<SizedForwardView> common(SizedForwardView{buffer});
+    assert(common.size() == 8);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/support/test_iterators.h

 public:
   sentinel_wrapper() = default;
   constexpr explicit sentinel_wrapper(I base) : base_(std::move(base)) {}
 
   constexpr bool operator==(I const& other) const requires std::equality_comparable<I> {
     return base_ == other;
   }
 
+  constexpr I base() const { return base_; }
+
 private:
   I base_ = I();
 };
 
 template <class It>
 class three_way_contiguous_iterator
 {
     static_assert(std::is_pointer_v<It>, "Things probably break in this case");