This is an archive of the discontinued LLVM Phabricator instance.

libcxx/include/__ranges/reverse_view.h
21–22	Not needed since we don't use `min`/`max`.
36	Per our discussion just now, could you file a bug report against Clang to ask whether this is intended: https://godbolt.org/z/bs15aq466?
37	Why not `[[no_unique_address]]`?
libcxx/test/std/ranges/range.adaptors/range.reverse/base.pass.cpp
43	Please comment `// test with a non-common_range` below, and `// test with a common_range` above. This applies elsewhere too - I'd like to be able to tell exactly what you're testing by just glancing at it - imagine I'm veeeery lazy.
libcxx/test/std/ranges/range.adaptors/range.reverse/begin.pass.cpp
45	Can we add a test with a random access range that is not a common range? We won't be caching in that case either.
83	As we just discussed, this test doesn't fail properly even if we remove the caching inside `reverse_view`, so that should be fixed.
libcxx/test/std/ranges/range.adaptors/range.reverse/ctor.view.pass.cpp
43	Can you test the explicit-ness by doing static_assert( std::is_constructible_v<...>); static_assert(!std::is_convertible_v<...>);
libcxx/test/std/ranges/range.adaptors/range.reverse/end.pass.cpp
58	This looks like a copy-paste leftover from the tests for `begin` (quoting yourself). Let's remove.
libcxx/test/std/ranges/range.adaptors/range.reverse/range_concept_conformance.compile.pass.cpp
25–28

This revision is now accepted and ready to land.Aug 9 2021, 12:02 PM

zoecarver marked 8 inline comments as done.Aug 9 2021, 12:50 PM

Apply review comments.

This revision was landed with ongoing or failed builds.Aug 9 2021, 3:10 PM

Closed by commit rG9d982c67ba01: [libcxx][ranges] Add `ranges::reverse_view`. (authored by zoecarver). · Explain Why

This revision was automatically updated to reflect the committed changes.

zoecarver added a commit: rG9d982c67ba01: [libcxx][ranges] Add `ranges::reverse_view`..

Harbormaster completed remote builds in B118740: Diff 365270.Aug 9 2021, 4:21 PM

Revision Contents

Path

Size

libcxx/

docs/

Status/

RangesPaper.csv

2 lines

include/

CMakeLists.txt

2 lines

__ranges/

reverse_view.h

112 lines

module.modulemap

1 line

ranges

10 lines

test/

libcxx/

diagnostics/

detail.headers/

ranges/

reverse_view.module.verify.cpp

16 lines

std/

ranges/

range.adaptors/

range.reverse/

base.pass.cpp

75 lines

begin.pass.cpp

153 lines

borrowing.compile.pass.cpp

40 lines

ctad.compile.pass.cpp

69 lines

ctor.default.pass.cpp

60 lines

ctor.view.pass.cpp

57 lines

end.pass.cpp

69 lines

range_concept_conformance.compile.pass.cpp

29 lines

size.pass.cpp

82 lines

types.h

46 lines

Diff 365297

libcxx/docs/Status/RangesPaper.csv

	Show First 20 Lines • Show All 140 Lines • ▼ Show 20 Lines
	`[range.iota] <http://wg21.link/range.iota>`_,iota_view,[range.all],Zoe Carver,In Progress			`[range.iota] <http://wg21.link/range.iota>`_,iota_view,[range.all],Zoe Carver,In Progress
	`[range.take] <http://wg21.link/range.take>`_,take_view,[range.all],Zoe Carver,✅			`[range.take] <http://wg21.link/range.take>`_,take_view,[range.all],Zoe Carver,✅
	`[range.join] <http://wg21.link/range.join>`_,join_view,[range.all],Zoe Carver,In Progress			`[range.join] <http://wg21.link/range.join>`_,join_view,[range.all],Zoe Carver,In Progress
	`[range.empty] <http://wg21.link/range.empty>`_,`empty_view <https://llvm.org/D103208>`_,[view.interface],Zoe Carver,✅			`[range.empty] <http://wg21.link/range.empty>`_,`empty_view <https://llvm.org/D103208>`_,[view.interface],Zoe Carver,✅
	`[range.single] <http://wg21.link/range.single>`_,single_view,[view.interface],Zoe Carver,✅			`[range.single] <http://wg21.link/range.single>`_,single_view,[view.interface],Zoe Carver,✅
	`[range.split] <http://wg21.link/range.split>`_,split_view,[range.all],Zoe Carver,In Progress			`[range.split] <http://wg21.link/range.split>`_,split_view,[range.all],Zoe Carver,In Progress
	`[range.counted] <http://wg21.link/range.counted>`_,view::counted,[range.subrange],Zoe Carver,Not started			`[range.counted] <http://wg21.link/range.counted>`_,view::counted,[range.subrange],Zoe Carver,Not started
	`[range.common] <http://wg21.link/range.common>`_,common_view,[range.all],Zoe Carver,✅			`[range.common] <http://wg21.link/range.common>`_,common_view,[range.all],Zoe Carver,✅
	`[range.reverse] <http://wg21.link/range.reverse>`_,reverse_view,[range.all],Unassigned,Not started			`[range.reverse] <http://wg21.link/range.reverse>`_,reverse_view,[range.all],Zoe Carver,✅

libcxx/include/CMakeLists.txt

Show First 20 Lines • Show All 193 Lines • ▼ Show 20 Lines	set(files
__ranges/data.h		__ranges/data.h
__ranges/drop_view.h		__ranges/drop_view.h
__ranges/empty_view.h		__ranges/empty_view.h
__ranges/empty.h		__ranges/empty.h
__ranges/enable_borrowed_range.h		__ranges/enable_borrowed_range.h
__ranges/enable_view.h		__ranges/enable_view.h
__ranges/non_propagating_cache.h		__ranges/non_propagating_cache.h
__ranges/ref_view.h		__ranges/ref_view.h
		__ranges/reverse_view.h
		__ranges/take_view.h
__ranges/single_view.h		__ranges/single_view.h
__ranges/size.h		__ranges/size.h
__ranges/subrange.h		__ranges/subrange.h
__ranges/take_view.h		__ranges/take_view.h
__ranges/transform_view.h		__ranges/transform_view.h
__ranges/view_interface.h		__ranges/view_interface.h
__split_buffer		__split_buffer
__std_stream		__std_stream
▲ Show 20 Lines • Show All 237 Lines • Show Last 20 Lines

libcxx/include/__ranges/reverse_view.h

This file was added.

				// -- 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_REVERSE_VIEW_H
				#define _LIBCPP___RANGES_REVERSE_VIEW_H

				#include <__config>
				#include <__iterator/concepts.h>
				#include <__iterator/next.h>
				#include <__iterator/reverse_iterator.h>
				#include <__ranges/access.h>
				#include <__ranges/all.h>
				#include <__ranges/concepts.h>
				#include <__ranges/enable_borrowed_range.h>
				#include <__ranges/non_propagating_cache.h>
				#include <__ranges/size.h>
				#include <__ranges/view_interface.h>
				ldionneUnsubmitted Done Reply Inline Actions Not needed since we don't use `min`/`max`. ldionne: Not needed since we don't use `min`/`max`.
				#include <concepts>
				#include <type_traits>

				#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
				#pragma GCC system_header
				#endif

				_LIBCPP_BEGIN_NAMESPACE_STD

				#if !defined(_LIBCPP_HAS_NO_RANGES)

				namespace ranges {
				template<view _View>
				requires bidirectional_range<_View>
				ldionneUnsubmitted Not Done Reply Inline Actions Per our discussion just now, could you file a bug report against Clang to ask whether this is intended: https://godbolt.org/z/bs15aq466? ldionne: Per our discussion just now, could you file a bug report against Clang to ask whether this is…
				class reverse_view : public view_interface<reverse_view<_View>> {
				ldionneUnsubmitted Done Reply Inline Actions Why not `[[no_unique_address]]`? ldionne: Why not `[[no_unique_address]]`?
				// We cache begin() whenever ranges::next is not guaranteed O(1) to provide an
				// amortized O(1) begin() method.
				static constexpr bool _UseCache = !random_access_range<_View> && !common_range<_View>;
				using _Cache = _If<_UseCache, __non_propagating_cache<reverse_iterator<iterator_t<_View>>>, __empty_cache>;
				[[no_unique_address]] _Cache __cached_begin_ = _Cache();
				[[no_unique_address]] _View __base_ = _View();

				public:
				_LIBCPP_HIDE_FROM_ABI
				reverse_view() requires default_initializable<_View> = default;

				_LIBCPP_HIDE_FROM_ABI
				constexpr explicit reverse_view(_View __view) : __base_(_VSTD::move(__view)) {}

				_LIBCPP_HIDE_FROM_ABI
				constexpr _View base() const& requires copy_constructible<_View> { return __base_; }

				_LIBCPP_HIDE_FROM_ABI
				constexpr _View base() && { return _VSTD::move(__base_); }

				_LIBCPP_HIDE_FROM_ABI
				constexpr reverse_iterator<iterator_t<_View>> begin() {
				if constexpr (_UseCache)
				if (__cached_begin_.__has_value())
				return *__cached_begin_;

				auto __tmp = _VSTD::make_reverse_iterator(ranges::next(ranges::begin(__base_), ranges::end(__base_)));
				if constexpr (_UseCache)
				__cached_begin_.__set(__tmp);
				return __tmp;
				}

				_LIBCPP_HIDE_FROM_ABI
				constexpr reverse_iterator<iterator_t<_View>> begin() requires common_range<_View> {
				return _VSTD::make_reverse_iterator(ranges::end(__base_));
				}

				_LIBCPP_HIDE_FROM_ABI
				constexpr auto begin() const requires common_range<const _View> {
				return _VSTD::make_reverse_iterator(ranges::end(__base_));
				}

				_LIBCPP_HIDE_FROM_ABI
				constexpr reverse_iterator<iterator_t<_View>> end() {
				return _VSTD::make_reverse_iterator(ranges::begin(__base_));
				}

				_LIBCPP_HIDE_FROM_ABI
				constexpr auto end() const requires common_range<const _View> {
				return _VSTD::make_reverse_iterator(ranges::begin(__base_));
				}

				_LIBCPP_HIDE_FROM_ABI
				constexpr auto size() requires sized_range<_View> {
				return ranges::size(__base_);
				}

				_LIBCPP_HIDE_FROM_ABI
				constexpr auto size() const requires sized_range<const _View> {
				return ranges::size(__base_);
				}
				};

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

				template<class _Tp>
				inline constexpr bool enable_borrowed_range<reverse_view<_Tp>> = enable_borrowed_range<_Tp>;
				} // namespace ranges

				#endif // !defined(_LIBCPP_HAS_NO_RANGES)

				_LIBCPP_END_NAMESPACE_STD

				#endif // _LIBCPP___RANGES_REVERSE_VIEW_H

libcxx/include/module.modulemap

Show First 20 Lines • Show All 625 Lines • ▼ Show 20 Lines	module __ranges {
module data { private header "__ranges/data.h" }		module data { private header "__ranges/data.h" }
module drop_view { private header "__ranges/drop_view.h" }		module drop_view { private header "__ranges/drop_view.h" }
module empty { private header "__ranges/empty.h" }		module empty { private header "__ranges/empty.h" }
module empty_view { private header "__ranges/empty_view.h" }		module empty_view { private header "__ranges/empty_view.h" }
module enable_borrowed_range { private header "__ranges/enable_borrowed_range.h" }		module enable_borrowed_range { private header "__ranges/enable_borrowed_range.h" }
module enable_view { private header "__ranges/enable_view.h" }		module enable_view { private header "__ranges/enable_view.h" }
module non_propagating_cache { private header "__ranges/non_propagating_cache.h" }		module non_propagating_cache { private header "__ranges/non_propagating_cache.h" }
module ref_view { private header "__ranges/ref_view.h" }		module ref_view { private header "__ranges/ref_view.h" }
		module reverse_view { private header "__ranges/reverse_view.h" }
module size { private header "__ranges/size.h" }		module size { private header "__ranges/size.h" }
module single_view { private header "__ranges/single_view.h" }		module single_view { private header "__ranges/single_view.h" }
module subrange { private header "__ranges/subrange.h" }		module subrange { private header "__ranges/subrange.h" }
module take_view { private header "__ranges/take_view.h" }		module take_view { private header "__ranges/take_view.h" }
module transform_view { private header "__ranges/transform_view.h" }		module transform_view { private header "__ranges/transform_view.h" }
module view_interface { private header "__ranges/view_interface.h" }		module view_interface { private header "__ranges/view_interface.h" }
}		}
}		}
▲ Show 20 Lines • Show All 263 Lines • Show Last 20 Lines

libcxx/include/ranges

Show First 20 Lines • Show All 148 Lines • ▼ Show 20 Lines	requires view<V> && is_object_v<F> &&
can-reference<invoke_result_t<F&, range_reference_t<V>>>		can-reference<invoke_result_t<F&, range_reference_t<V>>>
class transform_view;		class transform_view;

// [range.common], common view		// [range.common], common view
template<view V>		template<view V>
requires (!common_range<V> && copyable<iterator_t<V>>)		requires (!common_range<V> && copyable<iterator_t<V>>)
class common_view;		class common_view;

		// [range.reverse], reverse view
		template<view V>
		requires bidirectional_range<V>
		class reverse_view;

		template<class T>
		inline constexpr bool enable_borrowed_range<reverse_view<T>> = enable_borrowed_range<T>;

template<class T>		template<class T>
inline constexpr bool enable_borrowed_range<common_view<T>> = enable_borrowed_range<T>;		inline constexpr bool enable_borrowed_range<common_view<T>> = enable_borrowed_range<T>;

// [range.take], take view		// [range.take], take view
template<view> class take_view;		template<view> class take_view;

template<class T>		template<class T>
inline constexpr bool enable_borrowed_range<take_view<T>> = enable_borrowed_range<T>;		inline constexpr bool enable_borrowed_range<take_view<T>> = enable_borrowed_range<T>;
Show All 18 Lines
#include <__ranges/dangling.h>		#include <__ranges/dangling.h>
#include <__ranges/data.h>		#include <__ranges/data.h>
#include <__ranges/drop_view.h>		#include <__ranges/drop_view.h>
#include <__ranges/empty.h>		#include <__ranges/empty.h>
#include <__ranges/empty_view.h>		#include <__ranges/empty_view.h>
#include <__ranges/enable_borrowed_range.h>		#include <__ranges/enable_borrowed_range.h>
#include <__ranges/enable_view.h>		#include <__ranges/enable_view.h>
#include <__ranges/ref_view.h>		#include <__ranges/ref_view.h>
		#include <__ranges/reverse_view.h>
		#include <__ranges/take_view.h>
#include <__ranges/single_view.h>		#include <__ranges/single_view.h>
#include <__ranges/size.h>		#include <__ranges/size.h>
#include <__ranges/subrange.h>		#include <__ranges/subrange.h>
#include <__ranges/take_view.h>		#include <__ranges/take_view.h>
#include <__ranges/transform_view.h>		#include <__ranges/transform_view.h>
#include <__ranges/view_interface.h>		#include <__ranges/view_interface.h>
#include <compare> // Required by the standard.		#include <compare> // Required by the standard.
#include <initializer_list> // Required by the standard.		#include <initializer_list> // Required by the standard.
Show All 23 Lines

libcxx/test/libcxx/diagnostics/detail.headers/ranges/reverse_view.module.verify.cpp

This file was added.

				// -- 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
				//
				//===----------------------------------------------------------------------===//

				// REQUIRES: modules-build

				// WARNING: This test was generated by 'generate_private_header_tests.py'
				// and should not be edited manually.

				// expected-error@: {{use of private header from outside its module: '__ranges/reverse_view.h'}}
				#include <__ranges/reverse_view.h>

libcxx/test/std/ranges/range.adaptors/range.reverse/base.pass.cpp

This file was added.

				//===----------------------------------------------------------------------===//
				//
				// 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
				// UNSUPPORTED: libcpp-has-no-incomplete-ranges

				// constexpr V base() const& requires copy_constructible<V> { return base_; }
				// constexpr V base() && { return std::move(base_); }

				#include <ranges>
				#include <cassert>

				#include "test_macros.h"
				#include "types.h"

				constexpr bool test() {
				int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};

				// Test common ranges.
				{
				// Test non-const.
				{
				auto rev = std::ranges::reverse_view(BidirRange{buffer});
				assert(rev.base().ptr_ == buffer);
				assert(std::move(rev).base().ptr_ == buffer);

				ASSERT_SAME_TYPE(decltype(rev.base()), BidirRange);
				ASSERT_SAME_TYPE(decltype(std::move(rev).base()), BidirRange);
				}
				// Test const.
				{
				const auto rev = std::ranges::reverse_view(BidirRange{buffer});
				assert(rev.base().ptr_ == buffer);
				assert(std::move(rev).base().ptr_ == buffer);

				ASSERT_SAME_TYPE(decltype(rev.base()), BidirRange);
				ldionneUnsubmitted Done Reply Inline Actions Please comment `// test with a non-common_range` below, and `// test with a common_range` above. This applies elsewhere too - I'd like to be able to tell exactly what you're testing by just glancing at it - imagine I'm veeeery lazy. ldionne: Please comment `// test with a non-common_range` below, and `// test with a common_range` above.
				ASSERT_SAME_TYPE(decltype(std::move(rev).base()), BidirRange);
				}
				}
				// Test non-common ranges.
				{
				// Test non-const (also move only).
				{
				auto rev = std::ranges::reverse_view(BidirSentRange<MoveOnly>{buffer});
				assert(std::move(rev).base().ptr_ == buffer);

				ASSERT_SAME_TYPE(decltype(std::move(rev).base()), BidirSentRange<MoveOnly>);
				}
				// Test const.
				{
				const auto rev = std::ranges::reverse_view(BidirSentRange<Copyable>{buffer});
				assert(rev.base().ptr_ == buffer);
				assert(std::move(rev).base().ptr_ == buffer);

				ASSERT_SAME_TYPE(decltype(rev.base()), BidirSentRange<Copyable>);
				ASSERT_SAME_TYPE(decltype(std::move(rev).base()), BidirSentRange<Copyable>);
				}
				}

				return true;
				}

				int main(int, char**) {
				test();
				static_assert(test());

				return 0;
				}

libcxx/test/std/ranges/range.adaptors/range.reverse/begin.pass.cpp

This file was added.

				//===----------------------------------------------------------------------===//
				//
				// 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
				// UNSUPPORTED: libcpp-has-no-incomplete-ranges

				// constexpr reverse_iterator<iterator_t<V>> begin();
				// constexpr reverse_iterator<iterator_t<V>> begin() requires common_range<V>;
				// constexpr auto begin() const requires common_range<const V>;

				#include <ranges>
				#include <cassert>

				#include "test_macros.h"
				#include "types.h"

				static int globalCount = 0;

				struct CountedIter {
				typedef std::bidirectional_iterator_tag iterator_category;
				typedef int value_type;
				typedef std::ptrdiff_t difference_type;
				typedef int* pointer;
				typedef int& reference;
				typedef CountedIter self;

				pointer ptr_;
				CountedIter(pointer ptr) : ptr_(ptr) {}
				CountedIter() = default;

				reference operator*() const;
				pointer operator->() const;
				auto operator<=>(const self&) const = default;

				self& operator++() { globalCount++; ++ptr_; return *this; }
				self operator++(int) {
				auto tmp = *this;
				++*this;
				ldionneUnsubmitted Done Reply Inline Actions Can we add a test with a random access range that is not a common range? We won't be caching in that case either. ldionne: Can we add a test with a random access range that is not a common range? We won't be caching…
				return tmp;
				}

				self& operator--();
				self operator--(int);
				};

				struct CountedView : std::ranges::view_base {
				int *ptr_;

				CountedView(int *ptr) : ptr_(ptr) {}

				auto begin() { return CountedIter(ptr_); }
				auto begin() const { return CountedIter(ptr_); }
				auto end() { return sentinel_wrapper<CountedIter>(CountedIter(ptr_ + 8)); }
				auto end() const { return sentinel_wrapper<CountedIter>(CountedIter(ptr_ + 8)); }
				};

				struct RASentRange : std::ranges::view_base {
				using sent_t = sentinel_wrapper<random_access_iterator<int*>>;
				using sent_const_t = sentinel_wrapper<random_access_iterator<const int*>>;

				int *ptr_;

				constexpr RASentRange(int *ptr) : ptr_(ptr) {}

				constexpr random_access_iterator<int> begin() { return random_access_iterator<int>{ptr_}; }
				constexpr random_access_iterator<const int> begin() const { return random_access_iterator<const int>{ptr_}; }
				constexpr sent_t end() { return sent_t{random_access_iterator<int*>{ptr_ + 8}}; }
				constexpr sent_const_t end() const { return sent_const_t{random_access_iterator<const int*>{ptr_ + 8}}; }
				};

				template<class T>
				concept BeginInvocable = requires(T t) { t.begin(); };

				constexpr bool test() {
				int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};

				ldionneUnsubmitted Done Reply Inline Actions As we just discussed, this test doesn't fail properly even if we remove the caching inside `reverse_view`, so that should be fixed. ldionne: As we just discussed, this test doesn't fail properly even if we remove the caching inside…
				// Common bidirectional range.
				{
				auto rev = std::ranges::reverse_view(BidirRange{buffer});
				assert(rev.begin().base().base() == buffer + 8);
				assert(std::move(rev).begin().base().base() == buffer + 8);

				ASSERT_SAME_TYPE(decltype(rev.begin()), std::reverse_iterator<bidirectional_iterator<int*>>);
				ASSERT_SAME_TYPE(decltype(std::move(rev).begin()), std::reverse_iterator<bidirectional_iterator<int*>>);
				}
				// Const common bidirectional range.
				{
				const auto rev = std::ranges::reverse_view(BidirRange{buffer});
				assert(rev.begin().base().base() == buffer + 8);
				assert(std::move(rev).begin().base().base() == buffer + 8);

				ASSERT_SAME_TYPE(decltype(rev.begin()), std::reverse_iterator<bidirectional_iterator<const int*>>);
				ASSERT_SAME_TYPE(decltype(std::move(rev).begin()), std::reverse_iterator<bidirectional_iterator<const int*>>);
				}
				// Non-common, non-const (move only) bidirectional range.
				{
				auto rev = std::ranges::reverse_view(BidirSentRange<MoveOnly>{buffer});
				assert(std::move(rev).begin().base().base() == buffer + 8);

				ASSERT_SAME_TYPE(decltype(std::move(rev).begin()), std::reverse_iterator<bidirectional_iterator<int*>>);
				}
				// Non-common, non-const bidirectional range.
				{
				auto rev = std::ranges::reverse_view(BidirSentRange<Copyable>{buffer});
				assert(rev.begin().base().base() == buffer + 8);
				assert(std::move(rev).begin().base().base() == buffer + 8);

				ASSERT_SAME_TYPE(decltype(rev.begin()), std::reverse_iterator<bidirectional_iterator<int*>>);
				ASSERT_SAME_TYPE(decltype(std::move(rev).begin()), std::reverse_iterator<bidirectional_iterator<int*>>);
				}
				// Non-common random access range.
				// Note: const overload invalid for non-common ranges, though it would not be imposible
				// to implement for random access ranges.
				{
				auto rev = std::ranges::reverse_view(RASentRange{buffer});
				assert(rev.begin().base().base() == buffer + 8);
				assert(std::move(rev).begin().base().base() == buffer + 8);

				ASSERT_SAME_TYPE(decltype(rev.begin()), std::reverse_iterator<random_access_iterator<int*>>);
				ASSERT_SAME_TYPE(decltype(std::move(rev).begin()), std::reverse_iterator<random_access_iterator<int*>>);
				}
				{
				static_assert( BeginInvocable< std::ranges::reverse_view<BidirSentRange<Copyable>>>);
				static_assert(!BeginInvocable<const std::ranges::reverse_view<BidirSentRange<Copyable>>>);
				}

				return true;
				}

				int main(int, char**) {
				test();
				static_assert(test());

				{
				// Make sure we cache begin.
				int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
				CountedView view{buffer};
				std::ranges::reverse_view rev(view);
				assert(rev.begin().base().ptr_ == buffer + 8);
				assert(globalCount == 8);
				assert(rev.begin().base().ptr_ == buffer + 8);
				assert(globalCount == 8);
				}

				return 0;
				}

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

This file was added.

				//===----------------------------------------------------------------------===//
				//
				// 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
				// UNSUPPORTED: libcpp-has-no-incomplete-ranges

				// template<class T>
				// inline constexpr bool enable_borrowed_range<reverse_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::reverse_view<View>>);
				static_assert( std::ranges::enable_borrowed_range<std::ranges::reverse_view<BorrowableView>>);

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

This file was added.

				//===----------------------------------------------------------------------===//
				//
				// 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
				// UNSUPPORTED: libcpp-has-no-incomplete-ranges

				// template<class R>
				// reverse_view(R&&) -> reverse_view<views::all_t<R>>;

				#include <ranges>
				#include <cassert>
				#include <concepts>

				#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::reverse_view(v)),
				std::ranges::reverse_view<View>
				>);
				static_assert(std::same_as<
				decltype(std::ranges::reverse_view(r)),
				std::ranges::reverse_view<std::ranges::ref_view<Range>>
				>);
				// std::ranges::reverse_view(std::move(r)) invalid. RValue range must be borrowed.
				static_assert(std::same_as<
				decltype(std::ranges::reverse_view(br)),
				std::ranges::reverse_view<std::ranges::ref_view<BorrowedRange>>
				>);
				static_assert(std::same_as<
				decltype(std::ranges::reverse_view(std::move(br))),
				std::ranges::reverse_view<std::ranges::subrange<
				int , sentinel_wrapper<int >, std::ranges::subrange_kind::unsized>>
				>);
				}

libcxx/test/std/ranges/range.adaptors/range.reverse/ctor.default.pass.cpp

This file was added.

				//===----------------------------------------------------------------------===//
				//
				// 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
				// UNSUPPORTED: libcpp-has-no-incomplete-ranges

				// reverse_view() requires default_initializable<V> = default;

				#include <ranges>
				#include <cassert>

				#include "test_macros.h"
				#include "types.h"

				enum CtorKind { DefaultCtor, PtrCtor };
				template<CtorKind CK>
				struct BidirRangeWith : std::ranges::view_base {
				int *ptr_ = nullptr;

				constexpr BidirRangeWith() requires (CK == DefaultCtor) = default;
				constexpr BidirRangeWith(int *ptr);

				constexpr bidirectional_iterator<int> begin() { return bidirectional_iterator<int>{ptr_}; }
				constexpr bidirectional_iterator<const int> begin() const { return bidirectional_iterator<const int>{ptr_}; }
				constexpr bidirectional_iterator<int> end() { return bidirectional_iterator<int>{ptr_ + 8}; }
				constexpr bidirectional_iterator<const int> end() const { return bidirectional_iterator<const int>{ptr_ + 8}; }
				};

				constexpr bool test() {
				{
				static_assert( std::default_initializable<std::ranges::reverse_view<BidirRangeWith<DefaultCtor>>>);
				static_assert(!std::default_initializable<std::ranges::reverse_view<BidirRangeWith<PtrCtor>>>);
				}

				{
				std::ranges::reverse_view<BidirRangeWith<DefaultCtor>> rev;
				assert(rev.base().ptr_ == nullptr);
				}
				{
				const std::ranges::reverse_view<BidirRangeWith<DefaultCtor>> rev;
				assert(rev.base().ptr_ == nullptr);
				}

				return true;
				}

				int main(int, char**) {
				test();
				static_assert(test());

				return 0;
				}

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

This file was added.

				//===----------------------------------------------------------------------===//
				//
				// 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
				// UNSUPPORTED: libcpp-has-no-incomplete-ranges

				// constexpr explicit reverse_view(V r);

				#include <ranges>
				#include <cassert>

				#include "test_macros.h"
				#include "types.h"

				constexpr bool test() {
				int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};

				{
				BidirRange r{buffer};
				std::ranges::reverse_view<BidirRange> rev(r);
				assert(rev.base().ptr_ == buffer);
				}
				{
				const BidirRange r{buffer};
				const std::ranges::reverse_view<BidirRange> rev(r);
				assert(rev.base().ptr_ == buffer);
				}
				{
				std::ranges::reverse_view<BidirSentRange<MoveOnly>> rev(BidirSentRange<MoveOnly>{buffer});
				assert(std::move(rev).base().ptr_ == buffer);
				}
				{
				const std::ranges::reverse_view<BidirSentRange<Copyable>> rev(BidirSentRange<Copyable>{buffer});
				assert(rev.base().ptr_ == buffer);
				}
				{
				ldionneUnsubmitted Done Reply Inline Actions Can you test the explicit-ness by doing static_assert( std::is_constructible_v<...>); static_assert(!std::is_convertible_v<...>); ldionne: Can you test the explicit-ness by doing ``` static_assert( std::is_constructible_v<...>)…
				// Make sure this ctor is marked as "explicit".
				static_assert( std::is_constructible_v<std::ranges::reverse_view<BidirRange>, BidirRange>);
				static_assert(!std::is_convertible_v<std::ranges::reverse_view<BidirRange>, BidirRange>);
				}

				return true;
				}

				int main(int, char**) {
				test();
				static_assert(test());

				return 0;
				}

libcxx/test/std/ranges/range.adaptors/range.reverse/end.pass.cpp

This file was added.

				//===----------------------------------------------------------------------===//
				//
				// 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
				// UNSUPPORTED: libcpp-has-no-incomplete-ranges

				// constexpr reverse_iterator<iterator_t<V>> end();
				// constexpr auto end() const requires common_range<const V>;

				#include <ranges>
				#include <cassert>

				#include "test_macros.h"
				#include "types.h"

				constexpr bool test() {
				int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};

				// Common bidirectional range.
				{
				auto rev = std::ranges::reverse_view(BidirRange{buffer});
				assert(rev.end().base().base() == buffer);
				assert(std::move(rev).end().base().base() == buffer);

				ASSERT_SAME_TYPE(decltype(rev.end()), std::reverse_iterator<bidirectional_iterator<int*>>);
				ASSERT_SAME_TYPE(decltype(std::move(rev).end()), std::reverse_iterator<bidirectional_iterator<int*>>);
				}
				// Const common bidirectional range.
				{
				const auto rev = std::ranges::reverse_view(BidirRange{buffer});
				assert(rev.end().base().base() == buffer);
				assert(std::move(rev).end().base().base() == buffer);

				ASSERT_SAME_TYPE(decltype(rev.end()), std::reverse_iterator<bidirectional_iterator<const int*>>);
				ASSERT_SAME_TYPE(decltype(std::move(rev).end()), std::reverse_iterator<bidirectional_iterator<const int*>>);
				}
				// Non-common, non-const (move only) bidirectional range.
				{
				auto rev = std::ranges::reverse_view(BidirSentRange<MoveOnly>{buffer});
				assert(std::move(rev).end().base().base() == buffer);

				ASSERT_SAME_TYPE(decltype(std::move(rev).end()), std::reverse_iterator<bidirectional_iterator<int*>>);
				}
				// Non-common, const bidirectional range.
				{
				auto rev = std::ranges::reverse_view(BidirSentRange<Copyable>{buffer});
				assert(rev.end().base().base() == buffer);
				assert(std::move(rev).end().base().base() == buffer);

				ASSERT_SAME_TYPE(decltype(rev.end()), std::reverse_iterator<bidirectional_iterator<int*>>);
				ASSERT_SAME_TYPE(decltype(std::move(rev).end()), std::reverse_iterator<bidirectional_iterator<int*>>);
				ldionneUnsubmitted Done Reply Inline Actions This looks like a copy-paste leftover from the tests for `begin` (quoting yourself). Let's remove. ldionne: This looks like a copy-paste leftover from the tests for `begin` (quoting yourself). Let's…
				}

				return true;
				}

				int main(int, char**) {
				test();
				static_assert(test());

				return 0;
				}

libcxx/test/std/ranges/range.adaptors/range.reverse/range_concept_conformance.compile.pass.cpp

This file was added.

//===----------------------------------------------------------------------===//

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

// UNSUPPORTED: libcpp-has-no-incomplete-ranges

// Test that reverse_view conforms to range and view concepts.

#include <ranges>

#include <cassert>

#include <concepts>

#include "test_iterators.h"

#include "test_range.h"

static_assert( std::ranges::bidirectional_range<std::ranges::reverse_view<test_view<bidirectional_iterator>>>);

static_assert( std::ranges::random_access_range<std::ranges::reverse_view<test_view<random_access_iterator>>>);

static_assert( std::ranges::random_access_range<std::ranges::reverse_view<test_view<contiguous_iterator>>>);

static_assert(!std::ranges::contiguous_range<std::ranges::reverse_view<test_view<contiguous_iterator>>>);

ldionneUnsubmitted

Done

#include "test_range.h"

- static_assert(std::ranges::bidirectional_range<std::ranges::reverse_view<test_view<bidirectional_iterator>>>);

- static_assert(std::ranges::random_access_range<std::ranges::reverse_view<test_view<random_access_iterator>>>);

- static_assert(std::ranges::random_access_range<std::ranges::reverse_view<test_view<contiguous_iterator>>>);

+ static_assert( std::ranges::bidirectional_range<std::ranges::reverse_view<test_view<bidirectional_iterator>>>);

+ static_assert( std::ranges::random_access_range<std::ranges::reverse_view<test_view<random_access_iterator>>>);

+ static_assert( std::ranges::random_access_range<std::ranges::reverse_view<test_view<contiguous_iterator>>>);