[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

60

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

73–78

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)

114

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

20

Not needed. (might apply elsewhere too)

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

59

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 ↗

(On Diff #358034)

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

55

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/iterators/iterator.primitives/range.iter.ops/range.iter.ops.advance/iterator_count_sentinel.pass.cpp

public:
   distance_apriori_sentinel() = default;
   constexpr explicit distance_apriori_sentinel(std::ptrdiff_t const count) : count_(count) {}
 
   constexpr bool operator==(std::input_or_output_iterator auto const&) const {
     assert(false && "difference op should take precedence");
     return false;
   }
 
-  constexpr friend std::ptrdiff_t operator-(std::input_or_output_iterator auto const&,
+  friend constexpr std::ptrdiff_t operator-(std::input_or_output_iterator auto const&,
                                             distance_apriori_sentinel const y) {
     return -y.count_;
   }
 
-  constexpr friend std::ptrdiff_t operator-(distance_apriori_sentinel const x,
+  friend constexpr std::ptrdiff_t operator-(distance_apriori_sentinel const x,
                                             std::input_or_output_iterator auto const&) {
     return x.count_;
   }
 
 private:
   std::ptrdiff_t count_ = 0;
 };
 

libcxx/test/std/iterators/iterator.primitives/range.iter.ops/range.iter.ops.advance/iterator_sentinel.pass.cpp

public:
   distance_apriori_sentinel() = default;
   constexpr explicit distance_apriori_sentinel(std::ptrdiff_t const count) : count_(count) {}
 
   constexpr bool operator==(std::input_or_output_iterator auto const&) const {
     assert(false && "difference op should take precedence");
     return false;
   }
 
-  constexpr friend std::ptrdiff_t operator-(std::input_or_output_iterator auto const&,
+  friend constexpr std::ptrdiff_t operator-(std::input_or_output_iterator auto const&,
                                             distance_apriori_sentinel const y) {
     return -y.count_;
   }
 
-  constexpr friend std::ptrdiff_t operator-(distance_apriori_sentinel const x,
+  friend constexpr std::ptrdiff_t operator-(distance_apriori_sentinel const x,
                                             std::input_or_output_iterator auto const&) {
     return x.count_;
   }
 
 private:
   std::ptrdiff_t count_ = 0;
 };
 

libcxx/test/std/iterators/iterator.primitives/range.iter.ops/range.iter.ops.next/iterator_sentinel.pass.cpp

public:
   distance_apriori_sentinel() = default;
   constexpr explicit distance_apriori_sentinel(std::ptrdiff_t const count) : count_(count) {}
 
   constexpr bool operator==(std::input_or_output_iterator auto const&) const {
     assert(false && "difference op should take precedence");
     return false;
   }
 
-  constexpr friend std::ptrdiff_t operator-(std::input_or_output_iterator auto const&,
+  friend constexpr std::ptrdiff_t operator-(std::input_or_output_iterator auto const&,
                                             distance_apriori_sentinel const y) {
     return -y.count_;
   }
 
-  constexpr friend std::ptrdiff_t operator-(distance_apriori_sentinel const x,
+  friend constexpr std::ptrdiff_t operator-(distance_apriori_sentinel const x,
                                             std::input_or_output_iterator auto const&) {
     return x.count_;
   }
 
 private:
   std::ptrdiff_t count_ = 0;
 };
 

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

 
 static_assert(!std::is_invocable_v<RangeDataT, BeginMemberRandomAccess>);
 static_assert(!std::is_invocable_v<RangeDataT, BeginMemberRandomAccess const>);
 static_assert(!std::is_invocable_v<RangeDataT, BeginMemberRandomAccess const&>);
 
 struct BeginFriendContiguousIterator {
   int buff[8];
 
-  constexpr friend ContiguousIter begin(const BeginFriendContiguousIterator &iter) {
+  friend constexpr ContiguousIter begin(const BeginFriendContiguousIterator &iter) {
     return ContiguousIter(iter.buff);
   }
 };
 
 struct BeginFriendRandomAccess {
   friend random_access_iterator<const int*> begin(const BeginFriendRandomAccess iter);
 };
 

libcxx/test/std/ranges/range.adaptors/range.all.pass.cpp

 
 template<bool IsNoexcept>
 struct View : std::ranges::view_base {
   int start_ = 0;
   explicit View() noexcept(IsNoexcept) = default;
   constexpr explicit View(int start) : start_(start) {}
   View(View&&) noexcept(IsNoexcept) = default;
   View& operator=(View&&) noexcept(IsNoexcept) = default;
-  constexpr friend int* begin(View& view) { return globalBuff + view.start_; }
-  constexpr friend int* begin(View const& view) { return globalBuff + view.start_; }
-  constexpr friend int* end(View&) { return globalBuff + 8; }
-  constexpr friend int* end(View const&) { return globalBuff + 8; }
+  friend constexpr int* begin(View& view) { return globalBuff + view.start_; }
+  friend constexpr int* begin(View const& view) { return globalBuff + view.start_; }
+  friend constexpr int* end(View&) { return globalBuff + 8; }
+  friend constexpr int* end(View const&) { return globalBuff + 8; }
 };
 static_assert(std::ranges::view<View<true>>);
 static_assert(std::ranges::view<View<false>>);
 
 template<bool IsNoexcept>
 struct CopyableView : std::ranges::view_base {
   int start_ = 0;
   explicit CopyableView() noexcept(IsNoexcept) = default;
   CopyableView(CopyableView const&) noexcept(IsNoexcept) = default;
   CopyableView& operator=(CopyableView const&) noexcept(IsNoexcept) = default;
   constexpr explicit CopyableView(int start) noexcept : start_(start) {}
-  constexpr friend int* begin(CopyableView& view) { return globalBuff + view.start_; }
-  constexpr friend int* begin(CopyableView const& view) { return globalBuff + view.start_; }
-  constexpr friend int* end(CopyableView&) { return globalBuff + 8; }
-  constexpr friend int* end(CopyableView const&) { return globalBuff + 8; }
+  friend constexpr int* begin(CopyableView& view) { return globalBuff + view.start_; }
+  friend constexpr int* begin(CopyableView const& view) { return globalBuff + view.start_; }
+  friend constexpr int* end(CopyableView&) { return globalBuff + 8; }
+  friend constexpr int* end(CopyableView const&) { return globalBuff + 8; }
 };
 static_assert(std::ranges::view<CopyableView<true>>);
 static_assert(std::ranges::view<CopyableView<false>>);
 
 struct Range {
   int start_;
   constexpr explicit Range(int start) noexcept : start_(start) {}
-  constexpr friend int* begin(Range const& range) { return globalBuff + range.start_; }
-  constexpr friend int* begin(Range& range) { return globalBuff + range.start_; }
-  constexpr friend int* end(Range const&) { return globalBuff + 8; }
-  constexpr friend int* end(Range&) { return globalBuff + 8; }
+  friend constexpr int* begin(Range const& range) { return globalBuff + range.start_; }
+  friend constexpr int* begin(Range& range) { return globalBuff + range.start_; }
+  friend constexpr int* end(Range const&) { return globalBuff + 8; }
+  friend constexpr int* end(Range&) { return globalBuff + 8; }
 };
 
 struct BorrowableRange {
   int start_;
   constexpr explicit BorrowableRange(int start) noexcept : start_(start) {}
-  constexpr friend int* begin(BorrowableRange const& range) { return globalBuff + range.start_; }
-  constexpr friend int* begin(BorrowableRange& range) { return globalBuff + range.start_; }
-  constexpr friend int* end(BorrowableRange const&) { return globalBuff + 8; }
-  constexpr friend int* end(BorrowableRange&) { return globalBuff + 8; }
+  friend constexpr int* begin(BorrowableRange const& range) { return globalBuff + range.start_; }
+  friend constexpr int* begin(BorrowableRange& range) { return globalBuff + range.start_; }
+  friend constexpr int* end(BorrowableRange const&) { return globalBuff + 8; }
+  friend constexpr int* end(BorrowableRange&) { return globalBuff + 8; }
 };
 template<>
 inline constexpr bool std::ranges::enable_borrowed_range<BorrowableRange> = true;
 
 struct RandomAccessRange {
   struct sentinel {
     friend constexpr bool operator==(sentinel, const random_access_iterator<int*> rai) { return rai.base() == globalBuff + 8; }
     friend constexpr std::ptrdiff_t operator-(sentinel, random_access_iterator<int*>) { return -8; }

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;
+  friend constexpr int* begin(ContiguousView& view) { return view.ptr_; }
+  friend constexpr int* begin(ContiguousView const& view) { return view.ptr_; }
+  friend constexpr sentinel_wrapper<int*> end(ContiguousView& view) {
+    return sentinel_wrapper<int*>{view.ptr_ + 8};
+  }
+  friend constexpr 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) {}
+  friend constexpr int* begin(CopyableView& view) { return view.ptr_; }
+  friend constexpr int* begin(CopyableView const& view) { return view.ptr_; }
+  friend constexpr sentinel_wrapper<int*> end(CopyableView& view) {
+    return sentinel_wrapper<int*>{view.ptr_ + 8};
+  }
+  friend constexpr 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);
+
+    ASSERT_SAME_TYPE(decltype(common.base()), CopyableView);
+    ASSERT_SAME_TYPE(decltype(std::move(common).base()), CopyableView);
+    static_assert(hasLValueQualifiedBase(common));
+  }
+
+  {
+    std::ranges::common_view<ContiguousView> common(ContiguousView{buffer});
+    assert(std::move(common).base().ptr_ == buffer);
+
+    ASSERT_SAME_TYPE(decltype(std::move(common).base()), ContiguousView);
+    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);
+
+    ASSERT_SAME_TYPE(decltype(common.base()), CopyableView);
+    ASSERT_SAME_TYPE(decltype(std::move(common).base()), CopyableView);
+    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;
+  friend constexpr int* begin(ContiguousView& view) { return view.ptr_; }
+  friend constexpr int* begin(ContiguousView const& view) { return view.ptr_; }
+  friend constexpr sentinel_wrapper<int*> end(ContiguousView& view) {
+    return sentinel_wrapper<int*>{view.ptr_ + 8};
+  }
+  friend constexpr 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) {}
+  friend constexpr int* begin(CopyableView& view) { return view.ptr_; }
+  friend constexpr int* begin(CopyableView const& view) { return view.ptr_; }
+  friend constexpr sentinel_wrapper<int*> end(CopyableView& view) {
+    return sentinel_wrapper<int*>{view.ptr_ + 8};
+  }
+  friend constexpr 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) {}
+  friend constexpr ForwardIter begin(SizedForwardView& view) { return ForwardIter(view.ptr_); }
+  friend constexpr ForwardIter begin(SizedForwardView const& view) { return ForwardIter(view.ptr_); }
+  friend constexpr sentinel_wrapper<ForwardIter> end(SizedForwardView& view) {
+    return sentinel_wrapper<ForwardIter>{ForwardIter(view.ptr_ + 8)};
+  }
+  friend constexpr sentinel_wrapper<ForwardIter> end(SizedForwardView const& view) {
+    return sentinel_wrapper<ForwardIter>{ForwardIter(view.ptr_ + 8)};
+  }
+};
+// Required to make SizedForwardView a sized view.
+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) {}
+  friend constexpr RandomAccessIter begin(SizedRandomAccessView& view) { return RandomAccessIter(view.ptr_); }
+  friend constexpr RandomAccessIter begin(SizedRandomAccessView const& view) { return RandomAccessIter(view.ptr_); }
+  friend constexpr sentinel_wrapper<RandomAccessIter> end(SizedRandomAccessView& view) {
+    return sentinel_wrapper<RandomAccessIter>{RandomAccessIter(view.ptr_ + 8)};
+  }
+  friend constexpr sentinel_wrapper<RandomAccessIter> end(SizedRandomAccessView const& view) {
+    return sentinel_wrapper<RandomAccessIter>{RandomAccessIter(view.ptr_ + 8)};
+  }
+};
+// Required to make SizedRandomAccessView a sized view.
+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<SizedRandomAccessView> comm(SizedRandomAccessView{buffer});
+    assert(comm.begin() == begin(SizedRandomAccessView(buffer)));
+    ASSERT_SAME_TYPE(decltype(comm.begin()), RandomAccessIter);
+  }
+
+  {
+    const std::ranges::common_view<SizedRandomAccessView> comm(SizedRandomAccessView{buffer});
+    assert(comm.begin() == begin(SizedRandomAccessView(buffer)));
+    ASSERT_SAME_TYPE(decltype(comm.begin()), RandomAccessIter);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  // The non-constexpr tests:
+  int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+  {
+    std::ranges::common_view<SizedForwardView> comm(SizedForwardView{buffer});
+    assert(comm.begin() == begin(SizedForwardView(buffer)));
+    ASSERT_SAME_TYPE(decltype(comm.begin()), std::common_iterator<ForwardIter, sentinel_wrapper<ForwardIter>>);
+  }
+
+  {
+    std::ranges::common_view<ContiguousView> comm(ContiguousView{buffer});
+    assert(comm.begin() == begin(ContiguousView(buffer)));
+    ASSERT_SAME_TYPE(decltype(comm.begin()), std::common_iterator<int*, sentinel_wrapper<int*>>);
+  }
+
+  {
+    const std::ranges::common_view<SizedForwardView> comm(SizedForwardView{buffer});
+    assert(comm.begin() == begin(SizedForwardView(buffer)));
+    ASSERT_SAME_TYPE(decltype(comm.begin()), std::common_iterator<ForwardIter, sentinel_wrapper<ForwardIter>>);
+  }
+
+  {
+    const std::ranges::common_view<CopyableView> comm(CopyableView{buffer});
+    assert(comm.begin() == begin(CopyableView(buffer)));
+    ASSERT_SAME_TYPE(decltype(comm.begin()), std::common_iterator<int*, sentinel_wrapper<int*>>);
+  }
+
+  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_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_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(BorrowedRange&);
+  friend int* begin(BorrowedRange const&);
+  friend sentinel_wrapper<int*> end(BorrowedRange&);
+  friend sentinel_wrapper<int*> end(BorrowedRange 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)) invalid. RValue range must be borrowed.
+    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::ranges::subrange<
+          int *, sentinel_wrapper<int *>, std::ranges::subrange_kind::unsized>>
+    >);
+}

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

libcxx/test/std/ranges/range.adaptors/range.common.view/ctor.view.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 explicit common_view(V r);
+
+#include <ranges>
+#include <cassert>
+
+#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;
+  friend constexpr int* begin(ContiguousView& view) { return view.ptr_; }
+  friend constexpr int* begin(ContiguousView const& view) { return view.ptr_; }
+  friend constexpr sentinel_wrapper<int*> end(ContiguousView& view) {
+    return sentinel_wrapper<int*>{view.ptr_ + 8};
+  }
+  friend constexpr 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) {}
+  friend constexpr int* begin(CopyableView& view) { return view.ptr_; }
+  friend constexpr int* begin(CopyableView const& view) { return view.ptr_; }
+  friend constexpr sentinel_wrapper<int*> end(CopyableView& view) {
+    return sentinel_wrapper<int*>{view.ptr_ + 8};
+  }
+  friend constexpr sentinel_wrapper<int*> end(CopyableView const& view) {
+    return sentinel_wrapper<int*>{view.ptr_ + 8};
+  }
+};
+
+constexpr bool test() {
+  int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+  {
+    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) {}
+  friend constexpr int* begin(CopyableView& view) { return view.ptr_; }
+  friend constexpr int* begin(CopyableView const& view) { return view.ptr_; }
+  friend constexpr sentinel_wrapper<int*> end(CopyableView& view) {
+    return sentinel_wrapper<int*>{view.ptr_ + 8};
+  }
+  friend constexpr 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) {}
+  friend constexpr ForwardIter begin(SizedForwardView& view) { return ForwardIter(view.ptr_); }
+  friend constexpr ForwardIter begin(SizedForwardView const& view) { return ForwardIter(view.ptr_); }
+  friend constexpr sentinel_wrapper<ForwardIter> end(SizedForwardView& view) {
+    return sentinel_wrapper<ForwardIter>{ForwardIter(view.ptr_ + 8)};
+  }
+  friend constexpr 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) {}
+  friend constexpr RandomAccessIter begin(SizedRandomcAccessView& view) { return RandomAccessIter(view.ptr_); }
+  friend constexpr RandomAccessIter begin(SizedRandomcAccessView const& view) { return RandomAccessIter(view.ptr_); }
+  friend constexpr sentinel_wrapper<RandomAccessIter> end(SizedRandomcAccessView& view) {
+    return sentinel_wrapper<RandomAccessIter>{RandomAccessIter(view.ptr_ + 8)};
+  }
+  friend constexpr 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_iterators.h"
+#include "test_range.h"
+
+struct CopyableView : std::ranges::view_base {
+  int *ptr_;
+  constexpr CopyableView(int* ptr) : ptr_(ptr) {}
+  friend constexpr int* begin(CopyableView& view) { return view.ptr_; }
+  friend constexpr int* begin(CopyableView const& view) { return view.ptr_; }
+  friend constexpr sentinel_wrapper<int*> end(CopyableView& view) {
+    return sentinel_wrapper<int*>{view.ptr_ + 8};
+  }
+  friend constexpr 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) {}
+  friend constexpr ForwardIter begin(SizedForwardView& view) { return ForwardIter(view.ptr_); }
+  friend constexpr ForwardIter begin(SizedForwardView const& view) { return ForwardIter(view.ptr_); }
+  friend constexpr sentinel_wrapper<ForwardIter> end(SizedForwardView& view) {
+    return sentinel_wrapper<ForwardIter>{ForwardIter(view.ptr_ + 8)};
+  }
+  friend constexpr 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/std/ranges/range.adaptors/range.drop/types.h

 
 int globalBuff[8];
 
 struct ContiguousView : std::ranges::view_base {
   int start_;
   constexpr ContiguousView(int start = 0) : start_(start) {}
   constexpr ContiguousView(ContiguousView&&) = default;
   constexpr ContiguousView& operator=(ContiguousView&&) = default;
-  constexpr friend int* begin(ContiguousView& view) { return globalBuff + view.start_; }
-  constexpr friend int* begin(ContiguousView const& view) { return globalBuff + view.start_; }
-  constexpr friend int* end(ContiguousView&) { return globalBuff + 8; }
-  constexpr friend int* end(ContiguousView const&) { return globalBuff + 8; }
+  friend constexpr int* begin(ContiguousView& view) { return globalBuff + view.start_; }
+  friend constexpr int* begin(ContiguousView const& view) { return globalBuff + view.start_; }
+  friend constexpr int* end(ContiguousView&) { return globalBuff + 8; }
+  friend constexpr int* end(ContiguousView const&) { return globalBuff + 8; }
 };
 
 struct CopyableView : std::ranges::view_base {
   int start_;
   constexpr CopyableView(int start = 0) : start_(start) {}
   constexpr CopyableView(CopyableView const&) = default;
   constexpr CopyableView& operator=(CopyableView const&) = default;
-  constexpr friend int* begin(CopyableView& view) { return globalBuff + view.start_; }
-  constexpr friend int* begin(CopyableView const& view) { return globalBuff + view.start_; }
-  constexpr friend int* end(CopyableView&) { return globalBuff + 8; }
-  constexpr friend int* end(CopyableView const&) { return globalBuff + 8; }
+  friend constexpr int* begin(CopyableView& view) { return globalBuff + view.start_; }
+  friend constexpr int* begin(CopyableView const& view) { return globalBuff + view.start_; }
+  friend constexpr int* end(CopyableView&) { return globalBuff + 8; }
+  friend constexpr int* end(CopyableView const&) { return globalBuff + 8; }
 };
 
 using ForwardIter = forward_iterator<int*>;
 struct ForwardView : std::ranges::view_base {
   constexpr ForwardView() = default;
   constexpr ForwardView(ForwardView&&) = default;
   constexpr ForwardView& operator=(ForwardView&&) = default;
-  constexpr friend ForwardIter begin(ForwardView&) { return ForwardIter(globalBuff); }
-  constexpr friend ForwardIter begin(ForwardView const&) { return ForwardIter(globalBuff); }
-  constexpr friend ForwardIter end(ForwardView&) { return ForwardIter(globalBuff + 8); }
-  constexpr friend ForwardIter end(ForwardView const&) { return ForwardIter(globalBuff + 8); }
+  friend constexpr ForwardIter begin(ForwardView&) { return ForwardIter(globalBuff); }
+  friend constexpr ForwardIter begin(ForwardView const&) { return ForwardIter(globalBuff); }
+  friend constexpr ForwardIter end(ForwardView&) { return ForwardIter(globalBuff + 8); }
+  friend constexpr ForwardIter end(ForwardView const&) { return ForwardIter(globalBuff + 8); }
 };
 
 struct ForwardRange {
   ForwardIter begin() const;
   ForwardIter end() const;
   ForwardIter begin();
   ForwardIter end();
 };

libcxx/test/std/ranges/range.adaptors/range.transform/types.h

 concept ValidDropView = requires { typename std::ranges::transform_view<T, F>; };
 
 struct ContiguousView : std::ranges::view_base {
   int start_;
   int *ptr_;
   constexpr ContiguousView(int* ptr = globalBuff, int start = 0) : start_(start), ptr_(ptr) {}
   constexpr ContiguousView(ContiguousView&&) = default;
   constexpr ContiguousView& operator=(ContiguousView&&) = default;
-  constexpr friend int* begin(ContiguousView& view) { return view.ptr_ + view.start_; }
-  constexpr friend int* begin(ContiguousView const& view) { return view.ptr_ + view.start_; }
-  constexpr friend int* end(ContiguousView& view) { return view.ptr_ + 8; }
-  constexpr friend int* end(ContiguousView const& view) { return view.ptr_ + 8; }
+  friend constexpr int* begin(ContiguousView& view) { return view.ptr_ + view.start_; }
+  friend constexpr int* begin(ContiguousView const& view) { return view.ptr_ + view.start_; }
+  friend constexpr int* end(ContiguousView& view) { return view.ptr_ + 8; }
+  friend constexpr int* end(ContiguousView const& view) { return view.ptr_ + 8; }
 };
 
 struct CopyableView : std::ranges::view_base {
   int start_;
   constexpr CopyableView(int start = 0) : start_(start) {}
   constexpr CopyableView(CopyableView const&) = default;
   constexpr CopyableView& operator=(CopyableView const&) = default;
-  constexpr friend int* begin(CopyableView& view) { return globalBuff + view.start_; }
-  constexpr friend int* begin(CopyableView const& view) { return globalBuff + view.start_; }
-  constexpr friend int* end(CopyableView&) { return globalBuff + 8; }
-  constexpr friend int* end(CopyableView const&) { return globalBuff + 8; }
+  friend constexpr int* begin(CopyableView& view) { return globalBuff + view.start_; }
+  friend constexpr int* begin(CopyableView const& view) { return globalBuff + view.start_; }
+  friend constexpr int* end(CopyableView&) { return globalBuff + 8; }
+  friend constexpr int* end(CopyableView const&) { return globalBuff + 8; }
 };
 
 using ForwardIter = forward_iterator<int*>;
 struct ForwardView : std::ranges::view_base {
   int *ptr_;
   constexpr ForwardView(int* ptr = globalBuff) : ptr_(ptr) {}
   constexpr ForwardView(ForwardView&&) = default;
   constexpr ForwardView& operator=(ForwardView&&) = default;
-  constexpr friend ForwardIter begin(ForwardView& view) { return ForwardIter(view.ptr_); }
-  constexpr friend ForwardIter begin(ForwardView const& view) { return ForwardIter(view.ptr_); }
-  constexpr friend ForwardIter end(ForwardView& view) { return ForwardIter(view.ptr_ + 8); }
-  constexpr friend ForwardIter end(ForwardView const& view) { return ForwardIter(view.ptr_ + 8); }
+  friend constexpr ForwardIter begin(ForwardView& view) { return ForwardIter(view.ptr_); }
+  friend constexpr ForwardIter begin(ForwardView const& view) { return ForwardIter(view.ptr_); }
+  friend constexpr ForwardIter end(ForwardView& view) { return ForwardIter(view.ptr_ + 8); }
+  friend constexpr ForwardIter end(ForwardView const& view) { return ForwardIter(view.ptr_ + 8); }
 };
 
 using ForwardRange = test_common_range<forward_iterator>;
 
 using RandomAccessIter = random_access_iterator<int*>;
 struct RandomAccessView : std::ranges::view_base {
   RandomAccessIter begin() const noexcept;
   RandomAccessIter end() const noexcept;

libcxx/test/std/utilities/optional/optional.object/optional.object.assign/emplace.pass.cpp

 {
     int i_;
     int j_ = 0;
 public:
     constexpr X() : i_(0) {}
     constexpr X(int i) : i_(i) {}
     constexpr X(int i, int j) : i_(i), j_(j) {}
 
-    constexpr friend bool operator==(const X& x, const X& y)
+    friend constexpr bool operator==(const X& x, const X& y)
         {return x.i_ == y.i_ && x.j_ == y.j_;}
 };
 
 class Y
 {
 public:
     static bool dtor_called;
     Y() = default;

libcxx/test/support/test_iterators.h

public:
   requires std::random_access_iterator<I>
   {
     base_ -= n;
     ++stride_count_;
     --stride_displacement_;
     return *this;
   }
 
-  constexpr friend stride_counting_iterator operator+(stride_counting_iterator i, difference_type const n)
+  friend constexpr stride_counting_iterator operator+(stride_counting_iterator i, difference_type const n)
   requires std::random_access_iterator<I>
   {
     return i += n;
   }
 
-  constexpr friend stride_counting_iterator operator+(difference_type const n, stride_counting_iterator i)
+  friend constexpr stride_counting_iterator operator+(difference_type const n, stride_counting_iterator i)
   requires std::random_access_iterator<I>
   {
     return i += n;
   }
 
-  constexpr friend stride_counting_iterator operator-(stride_counting_iterator i, difference_type const n)
+  friend constexpr stride_counting_iterator operator-(stride_counting_iterator i, difference_type const n)
   requires std::random_access_iterator<I>
   {
     return i -= n;
   }
 
-  constexpr friend difference_type operator-(stride_counting_iterator const& x, stride_counting_iterator const& y)
+  friend constexpr difference_type operator-(stride_counting_iterator const& x, stride_counting_iterator const& y)
   requires std::sized_sentinel_for<I, I>
   {
     return x.base() - y.base();
   }
 
   constexpr bool operator==(stride_counting_iterator const& other) const
   requires std::sentinel_for<I, I>
   {
     return base_ == other.base_;
   }
 
   template <std::sentinel_for<I> S>
   constexpr bool operator==(S const last) const
   {
       return base_ == last;
   }
 
-  constexpr friend bool operator<(stride_counting_iterator const& x, stride_counting_iterator const& y)
+  friend constexpr bool operator<(stride_counting_iterator const& x, stride_counting_iterator const& y)
   requires std::random_access_iterator<I>
   {
     return x.base_ < y.base_;
   }
 
-  constexpr friend bool operator>(stride_counting_iterator const& x, stride_counting_iterator const& y)
+  friend constexpr bool operator>(stride_counting_iterator const& x, stride_counting_iterator const& y)
   requires std::random_access_iterator<I>
   {
     return y < x;
   }
 
-  constexpr friend bool operator<=(stride_counting_iterator const& x, stride_counting_iterator const& y)
+  friend constexpr bool operator<=(stride_counting_iterator const& x, stride_counting_iterator const& y)
   requires std::random_access_iterator<I>
   {
     return !(y < x);
   }
 
-  constexpr friend bool operator>=(stride_counting_iterator const& x, stride_counting_iterator const& y)
+  friend constexpr bool operator>=(stride_counting_iterator const& x, stride_counting_iterator const& y)
   requires std::random_access_iterator<I>
   {
     return !(x < y);
   }
 
 private:
   I base_;
   difference_type stride_count_ = 0;
   difference_type stride_displacement_ = 0;
 };
 
 template <std::input_or_output_iterator I>
 class sentinel_wrapper {
 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 const I& base() const& { return base_; }
+  constexpr I base() && { return std::move(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");

libcxx/test/support/type_classification/swappable.h

constexpr lvalue_adl_swappable(lvalue_adl_swappable const& other) noexcept
         this_(this) {}
 
   constexpr lvalue_adl_swappable&
   operator=(lvalue_adl_swappable other) noexcept {
     value_ = other.value_;
     return *this;
   }
 
-  constexpr friend void swap(lvalue_adl_swappable& x,
+  friend constexpr void swap(lvalue_adl_swappable& x,
                              lvalue_adl_swappable& y) noexcept {
     std::ranges::swap(x.value_, y.value_);
   }
 
   constexpr bool operator==(lvalue_adl_swappable const& other) const noexcept {
     return value_ == other.value_ && this_ == this && other.this_ == &other;
   }
 
lvalue_rvalue_adl_swappable(lvalue_rvalue_adl_swappable const& other) noexcept
         this_(this) {}
 
   constexpr lvalue_rvalue_adl_swappable&
   operator=(lvalue_rvalue_adl_swappable other) noexcept {
     value_ = other.value_;
     return *this;
   }
 
-  constexpr friend void swap(lvalue_rvalue_adl_swappable& x,
+  friend constexpr void swap(lvalue_rvalue_adl_swappable& x,
                              lvalue_rvalue_adl_swappable&& y) noexcept {
     std::ranges::swap(x.value_, y.value_);
   }
 
   constexpr bool
   operator==(lvalue_rvalue_adl_swappable const& other) const noexcept {
     return value_ == other.value_ && this_ == this && other.this_ == &other;
   }
rvalue_lvalue_adl_swappable(rvalue_lvalue_adl_swappable const& other) noexcept
         this_(this) {}
 
   constexpr rvalue_lvalue_adl_swappable&
   operator=(rvalue_lvalue_adl_swappable other) noexcept {
     value_ = other.value_;
     return *this;
   }
 
-  constexpr friend void swap(rvalue_lvalue_adl_swappable&& x,
+  friend constexpr void swap(rvalue_lvalue_adl_swappable&& x,
                              rvalue_lvalue_adl_swappable& y) noexcept {
     std::ranges::swap(x.value_, y.value_);
   }
 
   constexpr bool
   operator==(rvalue_lvalue_adl_swappable const& other) const noexcept {
     return value_ == other.value_ && this_ == this && other.this_ == &other;
   }
constexpr rvalue_adl_swappable(rvalue_adl_swappable const& other) noexcept
         this_(this) {}
 
   constexpr rvalue_adl_swappable&
   operator=(rvalue_adl_swappable other) noexcept {
     value_ = other.value_;
     return *this;
   }
 
-  constexpr friend void swap(rvalue_adl_swappable&& x,
+  friend constexpr void swap(rvalue_adl_swappable&& x,
                              rvalue_adl_swappable&& y) noexcept {
     std::ranges::swap(x.value_, y.value_);
   }
 
   constexpr bool operator==(rvalue_adl_swappable const& other) const noexcept {
     return value_ == other.value_ && this_ == this && other.this_ == &other;
   }
 
constexpr non_move_constructible_adl_swappable(
         this_(this) {}
 
   constexpr non_move_constructible_adl_swappable&
   operator=(non_move_constructible_adl_swappable other) noexcept {
     value_ = other.value_;
     return *this;
   }
 
-  constexpr friend void swap(non_move_constructible_adl_swappable& x,
+  friend constexpr void swap(non_move_constructible_adl_swappable& x,
                              non_move_constructible_adl_swappable& y) noexcept {
     std::ranges::swap(x.value_, y.value_);
   }
 
   constexpr bool
   operator==(non_move_constructible_adl_swappable const& other) const noexcept {
     return value_ == other.value_ && this_ == this && other.this_ == &other;
   }
public:
   constexpr non_move_assignable_adl_swappable(
       non_move_assignable_adl_swappable const& other) noexcept
       : value_(other.value_),
         this_(this) {}
 
   constexpr non_move_assignable_adl_swappable&
   operator=(non_move_assignable_adl_swappable&& other) noexcept = delete;
 
-  constexpr friend void swap(non_move_assignable_adl_swappable& x,
+  friend constexpr void swap(non_move_assignable_adl_swappable& x,
                              non_move_assignable_adl_swappable& y) noexcept {
     std::ranges::swap(x.value_, y.value_);
   }
 
   constexpr bool
   operator==(non_move_assignable_adl_swappable const& other) const noexcept {
     return value_ == other.value_ && this_ == this && other.this_ == &other;
   }
throwable_adl_swappable(throwable_adl_swappable const& other) noexcept
         this_(this) {}
 
   constexpr throwable_adl_swappable&
   operator=(throwable_adl_swappable other) noexcept {
     value_ = other.value_;
     return *this;
   }
 
-  constexpr friend void swap(throwable_adl_swappable& X,
+  friend constexpr void swap(throwable_adl_swappable& X,
                              throwable_adl_swappable& Y) noexcept(false) {
     std::ranges::swap(X.value_, Y.value_);
   }
 
   constexpr bool
   operator==(throwable_adl_swappable const& other) const noexcept {
     return value_ == other.value_ && this_ == this && other.this_ == &other;
   }
 
 private:
   int value_{};
   throwable_adl_swappable* this_ = this;
 };
 
 #endif // TEST_SUPPORT_TYPE_CLASSIFICATION_SWAPPABLE_H