diff --git a/libcxx/docs/OneRangesProposalStatus.csv b/libcxx/docs/OneRangesProposalStatus.csv
--- a/libcxx/docs/OneRangesProposalStatus.csv
+++ b/libcxx/docs/OneRangesProposalStatus.csv
@@ -137,7 +137,7 @@
`[range.all] <http://wg21.link/range.all>`_,`view::all <https://llvm.org/D102028>`_,"[range.subrange], [range.view.ref]",Zoe Carver,In progress
`[range.view.ref] <http://wg21.link/range.view>`_,`ref-view <https://llvm.org/D102020>`_,[view.interface],Zoe Carver,In progress
`[range.filter] <http://wg21.link/range.filter>`_,filter_view,[range.all],Louis Dionne,Not started
-`[range.transform] <http://wg21.link/range.transform>`_,`transform_view <https://llvm.org/D103056>`_,[range.all],Zoe Carver,In progress
+`[range.transform] <http://wg21.link/range.transform>`_,`transform_view <https://llvm.org/D103056>`_,[range.all],Zoe Carver,✅
`[range.iota] <http://wg21.link/range.iota>`_,iota_view,[range.all],Louis Dionne,Not started
`[range.take] <http://wg21.link/range.take>`_,take_view,[range.all],Zoe Carver,Not started
`[range.join] <http://wg21.link/range.join>`_,join_view,[range.all],Christopher Di Bella,Not started
diff --git a/libcxx/include/CMakeLists.txt b/libcxx/include/CMakeLists.txt
--- a/libcxx/include/CMakeLists.txt
+++ b/libcxx/include/CMakeLists.txt
@@ -149,10 +149,11 @@
__ranges/empty_view.h
__ranges/enable_borrowed_range.h
__ranges/enable_view.h
- __ranges/view_interface.h
__ranges/ref_view.h
__ranges/size.h
__ranges/subrange.h
+ __ranges/transform_view.h
+ __ranges/view_interface.h
__split_buffer
__std_stream
__string
diff --git a/libcxx/include/__ranges/concepts.h b/libcxx/include/__ranges/concepts.h
--- a/libcxx/include/__ranges/concepts.h
+++ b/libcxx/include/__ranges/concepts.h
@@ -112,6 +112,9 @@
template <class _Tp>
concept common_range = range<_Tp> && same_as<iterator_t<_Tp>, sentinel_t<_Tp> >;
+
+ template<bool _Const, class _Tp>
+ using __maybe_const = conditional_t<_Const, const _Tp, _Tp>;
} // namespace ranges
#endif // !defined(_LIBCPP_HAS_NO_RANGES)
diff --git a/libcxx/include/__ranges/copyable_box.h b/libcxx/include/__ranges/copyable_box.h
--- a/libcxx/include/__ranges/copyable_box.h
+++ b/libcxx/include/__ranges/copyable_box.h
@@ -86,8 +86,8 @@
return *this;
}
- constexpr _Tp const& operator*() const { return *__val_; }
- constexpr _Tp& operator*() { return *__val_; }
+ constexpr _Tp const& operator*() const noexcept { return *__val_; }
+ constexpr _Tp& operator*() noexcept { return *__val_; }
constexpr explicit operator bool() const noexcept { return static_cast<bool>(__val_); }
};
@@ -140,8 +140,8 @@
return *this;
}
- constexpr _Tp const& operator*() const { return __val_; }
- constexpr _Tp& operator*() { return __val_; }
+ constexpr _Tp const& operator*() const noexcept { return __val_; }
+ constexpr _Tp& operator*() noexcept { return __val_; }
constexpr explicit operator bool() const noexcept { return true; }
};
} // namespace ranges
diff --git a/libcxx/include/__ranges/transform_view.h b/libcxx/include/__ranges/transform_view.h
new file mode 100644
--- /dev/null
+++ b/libcxx/include/__ranges/transform_view.h
@@ -0,0 +1,352 @@
+// -*- 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_TRANSFORM_VIEW_H
+#define _LIBCPP___RANGES_TRANSFORM_VIEW_H
+
+#include <__config>
+#include <__iterator/iterator_traits.h>
+#include <__iterator/concepts.h>
+#include <__ranges/access.h>
+#include <__ranges/concepts.h>
+#include <__ranges/copyable_box.h>
+#include <__ranges/empty.h>
+#include <__ranges/view_interface.h>
+#include <type_traits>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if !defined(_LIBCPP_HAS_NO_RANGES)
+
+// REVIEW-NOTE: This is *not* part of the transform_view patch and will be added by a *separate* PR.
+template<class _I1, class _I2 = _I1>
+concept indirectly_swappable =
+ indirectly_readable<_I1> &&
+ indirectly_readable<_I2> &&
+ requires(const _I1 i1, const _I2 i2) {
+ ranges::iter_swap(i1, i1);
+ ranges::iter_swap(i1, i2);
+ ranges::iter_swap(i2, i1);
+ ranges::iter_swap(i2, i2);
+ };
+// END-REVIEW-NOTE.
+
+namespace ranges {
+
+template<class _View, class _Fn>
+concept __transform_view_constraints =
+ view<_View> && is_object_v<_Fn> &&
+ regular_invocable<_Fn&, range_reference_t<_View>> &&
+ __referenceable<invoke_result_t<_Fn&, range_reference_t<_View>>>;
+
+template<input_range _View, copy_constructible _Fn>
+ requires __transform_view_constraints<_View, _Fn>
+class transform_view : public view_interface<transform_view<_View, _Fn>> {
+ template<bool> class __iterator;
+ template<bool> class __sentinel;
+
+ [[no_unique_address]] __copyable_box<_Fn> __func_;
+ [[no_unique_address]] _View __base_ = _View();
+
+public:
+ transform_view()
+ requires default_initializable<_View> && default_initializable<_Fn> = default;
+
+ constexpr transform_view(_View __base, _Fn __func)
+ : __func_(_VSTD::in_place, _VSTD::move(__func)), __base_(_VSTD::move(__base)) {}
+
+ constexpr _View base() const& requires copy_constructible<_View> { return __base_; }
+ constexpr _View base() && { return _VSTD::move(__base_); }
+
+ constexpr __iterator<false> begin() {
+ return __iterator<false>{*this, ranges::begin(__base_)};
+ }
+ constexpr __iterator<true> begin() const
+ requires range<const _View> &&
+ regular_invocable<const _Fn&, range_reference_t<const _View>>
+ {
+ return __iterator<true>(*this, ranges::begin(__base_));
+ }
+
+ constexpr __sentinel<false> end() {
+ return __sentinel<false>(ranges::end(__base_));
+ }
+ constexpr __iterator<false> end()
+ requires common_range<_View>
+ {
+ return __iterator<false>(*this, ranges::end(__base_));
+ }
+ constexpr __sentinel<true> end() const
+ requires range<const _View> &&
+ regular_invocable<const _Fn&, range_reference_t<const _View>>
+ {
+ return __sentinel<true>(ranges::end(__base_));
+ }
+ constexpr __iterator<true> end() const
+ requires common_range<const _View> &&
+ regular_invocable<const _Fn&, range_reference_t<const _View>>
+ {
+ return __iterator<true>(*this, 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: replace the decltype with all_t when that's implemented.
+template<class _Range, class _Fn>
+transform_view(_Range&&, _Fn)
+ -> transform_view<decltype(views::all(std::declval<_Range>())), _Fn>;
+
+template<class _View>
+struct __transform_view_iterator_concept { using type = input_iterator_tag; };
+
+template<random_access_range _View>
+struct __transform_view_iterator_concept<_View> { using type = random_access_iterator_tag; };
+
+template<bidirectional_range _View>
+struct __transform_view_iterator_concept<_View> { using type = bidirectional_iterator_tag; };
+
+template<forward_range _View>
+struct __transform_view_iterator_concept<_View> { using type = forward_iterator_tag; };
+
+template<class, class>
+struct __transform_view_iterator_category_base {};
+
+template<forward_range _View, class _Fn>
+struct __transform_view_iterator_category_base<_View, _Fn> {
+ using _Cat = typename iterator_traits<iterator_t<_View>>::iterator_category;
+
+ using iterator_category = conditional_t<
+ is_lvalue_reference_v<invoke_result_t<_Fn&, range_reference_t<_View>>>,
+ conditional_t<
+ derived_from<_Cat, contiguous_iterator_tag>,
+ random_access_iterator_tag,
+ _Cat
+ >,
+ input_iterator_tag
+ >;
+};
+
+template<input_range _View, copy_constructible _Fn>
+ requires __transform_view_constraints<_View, _Fn>
+template<bool _Const>
+class transform_view<_View, _Fn>::__iterator
+ : public __transform_view_iterator_category_base<_View, _Fn> {
+
+ using _Parent = __maybe_const<_Const, transform_view>;
+ using _Base = __maybe_const<_Const, _View>;
+
+ iterator_t<_Base> __current_ = iterator_t<_Base>();
+ _Parent *__parent_ = nullptr;
+
+ template<bool>
+ friend class transform_view<_View, _Fn>::__sentinel;
+
+public:
+ using iterator_concept = typename __transform_view_iterator_concept<_View>::type;
+ using value_type = remove_cvref_t<invoke_result_t<_Fn&, range_reference_t<_Base>>>;
+ using difference_type = range_difference_t<_Base>;
+
+ __iterator() = default;
+
+ constexpr __iterator(_Parent& __parent, iterator_t<_Base> __current)
+ : __current_(_VSTD::move(__current)), __parent_(_VSTD::addressof(__parent)) {}
+ constexpr __iterator(__iterator<false> __i)
+ requires _Const && convertible_to<iterator_t<_View>, iterator_t<_Base>>
+ : __current_(_VSTD::move(__i.__current_)), __parent_(__i.__parent_) {}
+
+ constexpr iterator_t<_Base> base() const&
+ requires copyable<iterator_t<_Base>>
+ {
+ return __current_;
+ }
+ constexpr iterator_t<_Base> base() && {
+ return _VSTD::move(__current_);
+ }
+
+ constexpr decltype(auto) operator*() const
+ noexcept(noexcept(_VSTD::invoke(*__parent_->__func_, *__current_)))
+ {
+ return _VSTD::invoke(*__parent_->__func_, *__current_);
+ }
+
+ constexpr __iterator& operator++() {
+ ++__current_;
+ return *this;
+ }
+ constexpr void operator++(int) { ++__current_; }
+ constexpr __iterator operator++(int)
+ requires forward_range<_Base>
+ {
+ auto __tmp = *this;
+ ++*this;
+ return __tmp;
+ }
+
+ constexpr __iterator& operator--()
+ requires bidirectional_range<_Base>
+ {
+ --__current_;
+ return *this;
+ }
+ constexpr __iterator operator--(int)
+ requires bidirectional_range<_Base>
+ {
+ auto __tmp = *this;
+ --*this;
+ return __tmp;
+ }
+
+ constexpr __iterator& operator+=(difference_type __n)
+ requires random_access_range<_Base>
+ {
+ __current_ += __n;
+ return *this;
+ }
+ constexpr __iterator& operator-=(difference_type __n)
+ requires random_access_range<_Base>
+ {
+ __current_ -= __n;
+ return *this;
+ }
+ constexpr decltype(auto) operator[](difference_type __n) const
+ noexcept(noexcept(_VSTD::invoke(*__parent_->__func_, __current_[__n])))
+ requires random_access_range<_Base>
+ {
+ return _VSTD::invoke(*__parent_->__func_, __current_[__n]);
+ }
+
+ friend constexpr bool operator==(const __iterator& __x, const __iterator& __y)
+ requires equality_comparable<iterator_t<_Base>>
+ {
+ return __x.__current_ == __y.__current_;
+ }
+
+ friend constexpr bool operator<(const __iterator& __x, const __iterator& __y)
+ requires random_access_range<_Base>
+ {
+ return __x.__current_ < __y.__current_;
+ }
+ friend constexpr bool operator>(const __iterator& __x, const __iterator& __y)
+ requires random_access_range<_Base>
+ {
+ return __x.__current_ > __y.__current_;
+ }
+ friend constexpr bool operator<=(const __iterator& __x, const __iterator& __y)
+ requires random_access_range<_Base>
+ {
+ return __x.__current_ <= __y.__current_;
+ }
+ friend constexpr bool operator>=(const __iterator& __x, const __iterator& __y)
+ requires random_access_range<_Base>
+ {
+ return __x.__current_ >= __y.__current_;
+ }
+
+// TODO: Fix this as soon as soon as three_way_comparable is implemented.
+// friend constexpr auto operator<=>(const __iterator& __x, const __iterator& __y)
+// requires random_access_range<_Base> && three_way_comparable<iterator_t<_Base>>
+// {
+// return __x.__current_ <=> __y.__current_;
+// }
+
+ friend constexpr __iterator operator+(__iterator __i, difference_type __n)
+ requires random_access_range<_Base>
+ {
+ return __iterator{*__i.__parent_, __i.__current_ + __n};
+ }
+ friend constexpr __iterator operator+(difference_type __n, __iterator __i)
+ requires random_access_range<_Base>
+ {
+ return __iterator{*__i.__parent_, __i.__current_ + __n};
+ }
+
+ friend constexpr __iterator operator-(__iterator __i, difference_type __n)
+ requires random_access_range<_Base>
+ {
+ return __iterator{*__i.__parent_, __i.__current_ - __n};
+ }
+ friend constexpr difference_type operator-(const __iterator& __x, const __iterator& __y)
+ requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
+ {
+ return __x.__current_ - __y.__current_;
+ }
+
+ friend constexpr decltype(auto) iter_move(const __iterator& __i)
+ noexcept(noexcept(*__i))
+ {
+ if constexpr (is_lvalue_reference_v<decltype(*__i)>)
+ return _VSTD::move(*__i);
+ else
+ return *__i;
+ }
+};
+
+template<input_range _View, copy_constructible _Fn>
+ requires __transform_view_constraints<_View, _Fn>
+template<bool _Const>
+class transform_view<_View, _Fn>::__sentinel {
+ using _Parent = __maybe_const<_Const, transform_view>;
+ using _Base = __maybe_const<_Const, _View>;
+
+ sentinel_t<_Base> __end_ = sentinel_t<_Base>();
+
+ template<bool>
+ friend class transform_view<_View, _Fn>::__iterator;
+
+ template<bool>
+ friend class transform_view<_View, _Fn>::__sentinel;
+
+public:
+ __sentinel() = default;
+
+ constexpr explicit __sentinel(sentinel_t<_Base> __end_) : __end_(__end_) {}
+ constexpr __sentinel(__sentinel<false> __i)
+ requires _Const && convertible_to<sentinel_t<_View>, sentinel_t<_Base>>
+ : __end_(_VSTD::move(__i.__end_)) {}
+
+ constexpr sentinel_t<_Base> base() const { return __end_; }
+
+ template<bool _OtherConst>
+ requires sentinel_for<sentinel_t<_Base>, iterator_t<__maybe_const<_OtherConst, _View>>>
+ friend constexpr bool operator==(const __iterator<_OtherConst>& __x, const __sentinel& __y) {
+ return __x.__current_ == __y.__end_;
+ }
+
+ template<bool _OtherConst>
+ requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<__maybe_const<_OtherConst, _View>>>
+ friend constexpr range_difference_t<__maybe_const<_OtherConst, _View>>
+ operator-(const __iterator<_OtherConst>& __x, const __sentinel& __y) {
+ return __x.__current_ - __y.__end_;
+ }
+
+ template<bool _OtherConst>
+ requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<__maybe_const<_OtherConst, _View>>>
+ friend constexpr range_difference_t<__maybe_const<_OtherConst, _View>>
+ operator-(const __sentinel& __x, const __iterator<_OtherConst>& __y) {
+ return __x.__end_ - __y.__current_;
+ }
+};
+
+} // namespace ranges
+
+#endif // !defined(_LIBCPP_HAS_NO_RANGES)
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___RANGES_TRANSFORM_VIEW_H
diff --git a/libcxx/include/optional b/libcxx/include/optional
--- a/libcxx/include/optional
+++ b/libcxx/include/optional
@@ -906,7 +906,7 @@
_LIBCPP_INLINE_VISIBILITY
constexpr
const value_type&
- operator*() const&
+ operator*() const& noexcept
{
_LIBCPP_ASSERT(this->has_value(), "optional operator* called on a disengaged value");
return this->__get();
@@ -915,7 +915,7 @@
_LIBCPP_INLINE_VISIBILITY
constexpr
value_type&
- operator*() &
+ operator*() & noexcept
{
_LIBCPP_ASSERT(this->has_value(), "optional operator* called on a disengaged value");
return this->__get();
@@ -924,7 +924,7 @@
_LIBCPP_INLINE_VISIBILITY
constexpr
value_type&&
- operator*() &&
+ operator*() && noexcept
{
_LIBCPP_ASSERT(this->has_value(), "optional operator* called on a disengaged value");
return _VSTD::move(this->__get());
@@ -933,7 +933,7 @@
_LIBCPP_INLINE_VISIBILITY
constexpr
const value_type&&
- operator*() const&&
+ operator*() const&& noexcept
{
_LIBCPP_ASSERT(this->has_value(), "optional operator* called on a disengaged value");
return _VSTD::move(this->__get());
diff --git a/libcxx/include/ranges b/libcxx/include/ranges
--- a/libcxx/include/ranges
+++ b/libcxx/include/ranges
@@ -101,6 +101,14 @@
template<class T>
inline constexpr bool enable_borrowed_range<drop_view<T>> = enable_borrowed_range<T>;
+
+ // [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;
+
}
*/
@@ -118,6 +126,7 @@
#include <__ranges/ref_view.h>
#include <__ranges/size.h>
#include <__ranges/subrange.h>
+#include <__ranges/transform_view.h>
#include <__ranges/view_interface.h>
#include <compare> // Required by the standard.
#include <initializer_list> // Required by the standard.
diff --git a/libcxx/test/std/ranges/range.adaptors/range.transform/base.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.transform/base.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.transform/base.pass.cpp
@@ -0,0 +1,59 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 "test_macros.h"
+#include "types.h"
+
+constexpr bool test() {
+ {
+ std::ranges::transform_view<ContiguousView, Increment> transformView;
+ ContiguousView base = std::move(transformView).base();
+ ASSERT_SAME_TYPE(ContiguousView, decltype(std::move(transformView).base()));
+ assert(std::ranges::begin(base) == globalBuff);
+ }
+
+ {
+ std::ranges::transform_view<CopyableView, Increment> transformView;
+ CopyableView base1 = transformView.base();
+ ASSERT_SAME_TYPE(CopyableView, decltype(transformView.base()));
+ assert(std::ranges::begin(base1) == globalBuff);
+
+ CopyableView base2 = std::move(transformView).base();
+ ASSERT_SAME_TYPE(CopyableView, decltype(std::move(transformView).base()));
+ assert(std::ranges::begin(base2) == globalBuff);
+ }
+
+ {
+ const std::ranges::transform_view<CopyableView, Increment> transformView;
+ const CopyableView base1 = transformView.base();
+ ASSERT_SAME_TYPE(CopyableView, decltype(transformView.base()));
+ assert(std::ranges::begin(base1) == globalBuff);
+
+ const CopyableView base2 = std::move(transformView).base();
+ ASSERT_SAME_TYPE(CopyableView, decltype(std::move(transformView).base()));
+ assert(std::ranges::begin(base2) == globalBuff);
+ }
+
+ return true;
+}
+
+int main(int, char**) {
+ test();
+ static_assert(test());
+
+ return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.transform/begin.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.transform/begin.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.transform/begin.pass.cpp
@@ -0,0 +1,62 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 iterator<false> begin();
+// constexpr iterator<true> begin() const
+// requires range<const V> &&
+// regular_invocable<const F&, range_reference_t<const V>>;
+
+#include <ranges>
+
+#include "test_macros.h"
+#include "types.h"
+
+template<class T>
+concept BeginInvocable = requires(T t) { t.begin(); };
+
+constexpr bool test() {
+ int buff[8] = {0, 1, 2, 3, 4, 5, 6, 7};
+
+ {
+ std::ranges::transform_view transformView(ContiguousView{buff}, Increment{});
+ assert(transformView.begin().base() == buff);
+ assert(*transformView.begin() == 1);
+ }
+
+ {
+ std::ranges::transform_view transformView(ForwardView{buff}, Increment{});
+ assert(transformView.begin().base().base() == buff);
+ assert(*transformView.begin() == 1);
+ }
+
+ {
+ std::ranges::transform_view transformView(InputView{buff}, Increment{});
+ assert(transformView.begin().base().base() == buff);
+ assert(*transformView.begin() == 1);
+ }
+
+ {
+ const std::ranges::transform_view transformView(ContiguousView{buff}, IncrementConst{});
+ assert(*transformView.begin() == 1);
+ }
+
+ static_assert(!BeginInvocable<const std::ranges::transform_view<ContiguousView, Increment>>);
+
+ return true;
+}
+
+int main(int, char**) {
+ test();
+ static_assert(test());
+
+ return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.transform/ctad.compile.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.transform/ctad.compile.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.transform/ctad.compile.pass.cpp
@@ -0,0 +1,25 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+
+// CTAD tests.
+
+#include <ranges>
+
+#include "test_macros.h"
+#include "types.h"
+
+static_assert(std::same_as<decltype(std::ranges::transform_view(InputView(), Increment())),
+ std::ranges::transform_view<InputView, Increment>>);
+static_assert(std::same_as<decltype(std::ranges::transform_view(std::declval<ForwardRange&>(), Increment())),
+ std::ranges::transform_view<std::ranges::ref_view<ForwardRange>, Increment>>);
+static_assert(std::same_as<decltype(std::ranges::transform_view(BorrowableRange(), Increment())),
+ std::ranges::transform_view<std::ranges::subrange<int*>, Increment>>);
diff --git a/libcxx/test/std/ranges/range.adaptors/range.transform/end.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.transform/end.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.transform/end.pass.cpp
@@ -0,0 +1,74 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 sentinel<false> end();
+// constexpr iterator<false> end() requires common_range<V>;
+// constexpr sentinel<true> end() const
+// requires range<const V> &&
+// regular_invocable<const F&, range_reference_t<const V>>;
+// constexpr iterator<true> end() const
+// requires common_range<const V> &&
+// regular_invocable<const F&, range_reference_t<const V>>;
+
+#include <ranges>
+
+#include "test_macros.h"
+#include "types.h"
+
+template<class T>
+concept EndInvocable = requires(T t) { t.end(); };
+
+template<class T>
+concept EndIsIter = requires(T t) { ++t.end(); };
+
+constexpr bool test() {
+ {
+ std::ranges::transform_view transformView(ContiguousView{}, Increment{});
+ assert(transformView.end().base() == globalBuff + 8);
+ }
+
+ {
+ std::ranges::transform_view transformView(ForwardView{}, Increment{});
+ assert(transformView.end().base().base() == globalBuff + 8);
+ }
+
+ {
+ std::ranges::transform_view transformView(InputView{}, Increment{});
+ assert(transformView.end().base() == globalBuff + 8);
+ }
+
+ {
+ const std::ranges::transform_view transformView(ContiguousView{}, IncrementConst{});
+ assert(transformView.end().base() == globalBuff + 8);
+ }
+
+ static_assert(!EndInvocable<const std::ranges::transform_view<ContiguousView, Increment>>);
+ static_assert( EndInvocable< std::ranges::transform_view<ContiguousView, Increment>>);
+ static_assert( EndInvocable<const std::ranges::transform_view<ContiguousView, IncrementConst>>);
+ static_assert(!EndInvocable<const std::ranges::transform_view<InputView, Increment>>);
+ static_assert( EndInvocable< std::ranges::transform_view<InputView, Increment>>);
+ static_assert( EndInvocable<const std::ranges::transform_view<InputView, IncrementConst>>);
+
+ static_assert(!EndIsIter<const std::ranges::transform_view<InputView, IncrementConst>>);
+ static_assert(!EndIsIter< std::ranges::transform_view<InputView, Increment>>);
+ static_assert( EndIsIter<const std::ranges::transform_view<ContiguousView, IncrementConst>>);
+ static_assert( EndIsIter< std::ranges::transform_view<ContiguousView, Increment>>);
+
+ return true;
+}
+
+int main(int, char**) {
+ test();
+ static_assert(test());
+
+ return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.transform/general.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.transform/general.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.transform/general.pass.cpp
@@ -0,0 +1,75 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+
+// Some basic examples of how transform_view might be used in the wild. This is a general
+// collection of sample algorithms and functions that try to mock general usage of
+// this view.
+
+#include <ranges>
+
+#include <cctype>
+#include <functional>
+#include <list>
+#include <numeric>
+#include <string>
+#include <vector>
+
+#include <cassert>
+#include "test_macros.h"
+#include "test_iterators.h"
+#include "types.h"
+
+template<std::ranges::range R>
+auto toUpper(R range) {
+ return std::ranges::transform_view(range, [](char c) { return std::toupper(c); });
+}
+
+unsigned badRandom() { return 42; }
+
+template<std::ranges::range R, class Fn = std::plus<std::iter_value_t<R>>>
+auto withRandom(R&& range, Fn func = Fn()) {
+ return std::ranges::transform_view(range, std::bind_front(func, badRandom()));
+}
+
+template<class E1, class E2, size_t N, class Join = std::plus<E1>>
+auto joinArrays(E1 (&a)[N], E2 (&b)[N], Join join = Join()) {
+ return std::ranges::transform_view(a, [&a, &b, join](auto& x) {
+ auto idx = (&x) - a;
+ return join(x, b[idx]);
+ });
+}
+
+int main(int, char**) {
+ {
+ std::vector vec = {1, 2, 3, 4};
+ auto sortOfRandom = withRandom(vec);
+ std::vector check = {43, 44, 45, 46};
+ assert(std::equal(sortOfRandom.begin(), sortOfRandom.end(), check.begin(), check.end()));
+ }
+
+ {
+ int a[4] = {1, 2, 3, 4};
+ int b[4] = {4, 3, 2, 1};
+ auto out = joinArrays(a, b);
+ int check[4] = {5, 5, 5, 5};
+ assert(std::equal(out.begin(), out.end(), check));
+ }
+
+ {
+ std::string_view str = "Hello, World.";
+ auto upp = toUpper(str);
+ std::string_view check = "HELLO, WORLD.";
+ assert(std::equal(upp.begin(), upp.end(), check.begin(), check.end()));
+ }
+
+ return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.transform/iterator/arithmetic.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.transform/iterator/arithmetic.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.transform/iterator/arithmetic.pass.cpp
@@ -0,0 +1,48 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+
+// transform_view::<iterator>::operator{++,--,+=,-=}
+
+#include <ranges>
+
+#include "test_macros.h"
+#include "../types.h"
+
+constexpr bool test() {
+ std::ranges::transform_view<ContiguousView, Increment> transformView;
+ auto iter = std::move(transformView).begin();
+ assert((++iter).base() == globalBuff + 1);
+
+ assert((iter++).base() == globalBuff + 1);
+ assert(iter.base() == globalBuff + 2);
+
+ assert((--iter).base() == globalBuff + 1);
+ assert((iter--).base() == globalBuff + 1);
+ assert(iter.base() == globalBuff);
+
+ // Check that decltype(InputIter++) == void.
+ ASSERT_SAME_TYPE(decltype(
+ std::declval<std::ranges::iterator_t<std::ranges::transform_view<InputView, Increment>>>()++),
+ void);
+
+ assert((iter += 4).base() == globalBuff + 4);
+ assert((iter -= 3).base() == globalBuff + 1);
+
+ return true;
+}
+
+int main(int, char**) {
+ test();
+ static_assert(test());
+
+ return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.transform/iterator/base.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.transform/iterator/base.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.transform/iterator/base.pass.cpp
@@ -0,0 +1,52 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+
+// transform_view::<iterator>::base
+
+#include <ranges>
+
+#include "test_macros.h"
+#include "../types.h"
+
+template<class V, class F>
+concept BaseInvocable = requires(std::ranges::iterator_t<std::ranges::transform_view<V, F>> iter) {
+ iter.base();
+};
+
+constexpr bool test() {
+ {
+ std::ranges::transform_view<ContiguousView, Increment> transformView;
+ auto iter = std::move(transformView).begin();
+ ASSERT_SAME_TYPE(int*, decltype(iter.base()));
+ assert(iter.base() == globalBuff);
+ ASSERT_SAME_TYPE(int*, decltype(std::move(iter).base()));
+ assert(std::move(iter).base() == globalBuff);
+ }
+
+ {
+ std::ranges::transform_view<InputView, Increment> transformView;
+ auto iter = transformView.begin();
+ assert(std::move(iter).base() == globalBuff);
+ ASSERT_SAME_TYPE(cpp20_input_iterator<int *>, decltype(std::move(iter).base()));
+ }
+
+ static_assert(!BaseInvocable<InputView, Increment>);
+
+ return true;
+}
+
+int main(int, char**) {
+ test();
+ static_assert(test());
+
+ return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.transform/iterator/compare.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.transform/iterator/compare.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.transform/iterator/compare.pass.cpp
@@ -0,0 +1,67 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+
+// transform_view::<iterator>::operator{<,>,<=,>=}
+
+#include <ranges>
+#include <compare>
+
+#include "test_macros.h"
+#include "../types.h"
+
+constexpr bool test() {
+ {
+ std::ranges::transform_view<ContiguousView, Increment> transformView1;
+ auto iter1 = std::move(transformView1).begin();
+ std::ranges::transform_view<ContiguousView, Increment> transformView2;
+ auto iter2 = std::move(transformView2).begin();
+ assert(iter1 == iter2);
+ assert(iter1 + 1 != iter2);
+ assert(iter1 + 1 == iter2 + 1);
+
+ assert(iter1 < iter1 + 1);
+ assert(iter1 + 1 > iter1);
+ assert(iter1 <= iter1 + 1);
+ assert(iter1 <= iter2);
+ assert(iter1 + 1 >= iter2);
+ assert(iter1 >= iter2);
+ }
+
+// TODO: when three_way_comparable is implemented and std::is_eq is implemented,
+// uncomment this.
+// {
+// std::ranges::transform_view<ThreeWayCompView, Increment> transformView1;
+// auto iter1 = transformView1.begin();
+// std::ranges::transform_view<ThreeWayCompView, Increment> transformView2;
+// auto iter2 = transformView2.begin();
+//
+// assert(std::is_eq(iter1 <=> iter2));
+// assert(std::is_lteq(iter1 <=> iter2));
+// ++iter2;
+// assert(std::is_neq(iter1 <=> iter2));
+// assert(std::is_lt(iter1 <=> iter2));
+// assert(std::is_gt(iter2 <=> iter1));
+// assert(std::is_gteq(iter2 <=> iter1));
+//
+// static_assert( std::three_way_comparable<std::iterator_t<std::ranges::transform_view<ThreeWayCompView, Increment>>>);
+// static_assert(!std::three_way_comparable<std::iterator_t<std::ranges::transform_view<ContiguousView, Increment>>>);
+// }
+
+ return true;
+}
+
+int main(int, char**) {
+ test();
+ static_assert(test());
+
+ return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.transform/iterator/deref.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.transform/iterator/deref.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.transform/iterator/deref.pass.cpp
@@ -0,0 +1,44 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+
+// transform_view::<iterator>::operator*
+
+#include <ranges>
+
+#include "test_macros.h"
+#include "../types.h"
+
+int main(int, char**) {
+ int buff[8] = {0, 1, 2, 3, 4, 5, 6, 7};
+
+ {
+ std::ranges::transform_view transformView(ContiguousView{buff}, Increment{});
+ assert(*transformView.begin() == 1);
+ }
+
+ static_assert(!noexcept(
+ *std::declval<std::ranges::iterator_t<std::ranges::transform_view<ContiguousView, Increment>>>()));
+ static_assert( noexcept(
+ *std::declval<std::ranges::iterator_t<std::ranges::transform_view<ContiguousView, IncrementNoexcept>>>()));
+
+ ASSERT_SAME_TYPE(
+ int,
+ decltype(*std::declval<std::ranges::transform_view<RandomAccessView, Increment>>().begin()));
+ ASSERT_SAME_TYPE(
+ int&,
+ decltype(*std::declval<std::ranges::transform_view<RandomAccessView, IncrementRef>>().begin()));
+ ASSERT_SAME_TYPE(
+ int&&,
+ decltype(*std::declval<std::ranges::transform_view<RandomAccessView, IncrementRvalueRef>>().begin()));
+
+ return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.transform/iterator/iter_move.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.transform/iterator/iter_move.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.transform/iterator/iter_move.pass.cpp
@@ -0,0 +1,50 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+
+// transform_view::<iterator>::operator[]
+
+#include <ranges>
+
+#include "test_macros.h"
+#include "../types.h"
+
+constexpr bool test() {
+ int buff[8] = {0, 1, 2, 3, 4, 5, 6, 7};
+
+ {
+ std::ranges::transform_view transformView(ContiguousView{buff}, Increment{});
+ auto iter = transformView.begin();
+ static_assert(!noexcept(std::ranges::iter_move(iter)));
+
+ assert(std::ranges::iter_move(iter) == 1);
+ assert(std::ranges::iter_move(iter + 2) == 3);
+
+ ASSERT_SAME_TYPE(int, decltype(std::ranges::iter_move(iter)));
+ ASSERT_SAME_TYPE(int, decltype(std::ranges::iter_move(std::move(iter))));
+ }
+
+ {
+ static_assert( noexcept(std::ranges::iter_move(
+ std::declval<std::ranges::iterator_t<std::ranges::transform_view<ContiguousView, IncrementNoexcept>>&>())));
+ static_assert(!noexcept(std::ranges::iter_move(
+ std::declval<std::ranges::iterator_t<std::ranges::transform_view<ContiguousView, Increment>>&>())));
+ }
+
+ return true;
+}
+
+int main(int, char**) {
+ test();
+ static_assert(test());
+
+ return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.transform/iterator/plus_minus.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.transform/iterator/plus_minus.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.transform/iterator/plus_minus.pass.cpp
@@ -0,0 +1,41 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+
+// transform_view::<iterator>::operator{+,-}
+
+#include <ranges>
+
+#include "test_macros.h"
+#include "../types.h"
+
+constexpr bool test() {
+ std::ranges::transform_view<ContiguousView, Increment> transformView1;
+ auto iter1 = std::move(transformView1).begin();
+ std::ranges::transform_view<ContiguousView, Increment> transformView2;
+ auto iter2 = std::move(transformView2).begin();
+ iter1 += 4;
+ assert((iter1 + 1).base() == globalBuff + 5);
+ assert((1 + iter1).base() == globalBuff + 5);
+ assert((iter1 - 1).base() == globalBuff + 3);
+ assert(iter1 - iter2 == 4);
+ assert((iter1 + 2) - 2 == iter1);
+ assert((iter1 - 2) + 2 == iter1);
+
+ return true;
+}
+
+int main(int, char**) {
+ test();
+ static_assert(test());
+
+ return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.transform/iterator/requirements.compile.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.transform/iterator/requirements.compile.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.transform/iterator/requirements.compile.pass.cpp
@@ -0,0 +1,24 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+
+// The requirements for transform_view::<iterator>'s members.
+
+#include <ranges>
+
+#include "test_macros.h"
+#include "../types.h"
+
+static_assert(std::ranges::bidirectional_range<std::ranges::transform_view<BidirectionalView, IncrementConst>>);
+static_assert(!std::ranges::bidirectional_range<std::ranges::transform_view<ForwardView, IncrementConst>>);
+
+static_assert(std::ranges::random_access_range<std::ranges::transform_view<RandomAccessView, IncrementConst>>);
+static_assert(!std::ranges::random_access_range<std::ranges::transform_view<BidirectionalView, IncrementConst>>);
diff --git a/libcxx/test/std/ranges/range.adaptors/range.transform/iterator/sentinel.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.transform/iterator/sentinel.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.transform/iterator/sentinel.pass.cpp
@@ -0,0 +1,65 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+
+// class transform_view::<sentinel>;
+
+#include <ranges>
+
+#include "test_macros.h"
+#include "../types.h"
+
+template<class T>
+concept EndIsIter = requires(T t) { ++t.end(); };
+
+constexpr bool test() {
+ std::ranges::transform_view<SizedSentinelView, IncrementConst> transformView1;
+ // Going to const and back.
+ auto sent1 = transformView1.end();
+ std::ranges::sentinel_t<const std::ranges::transform_view<SizedSentinelView, IncrementConst>> sent2{sent1};
+ std::ranges::sentinel_t<const std::ranges::transform_view<SizedSentinelView, IncrementConst>> sent3{sent2};
+ (void)sent3;
+
+ static_assert(!EndIsIter<decltype(sent1)>);
+ static_assert(!EndIsIter<decltype(sent2)>);
+ assert(sent1.base() == globalBuff + 8);
+
+ std::ranges::transform_view transformView2(SizedSentinelView{4}, IncrementConst());
+ auto sent4 = transformView2.end();
+ auto iter = transformView1.begin();
+ {
+ assert(iter != sent1);
+ assert(iter != sent2);
+ assert(iter != sent4);
+ }
+
+ {
+ assert(iter + 8 == sent1);
+ assert(iter + 8 == sent2);
+ assert(iter + 4 == sent4);
+ }
+
+ {
+ assert(sent1 - iter == 8);
+ assert(sent4 - iter == 4);
+ assert(iter - sent1 == -8);
+ assert(iter - sent4 == -4);
+ }
+
+ return true;
+}
+
+int main(int, char**) {
+ test();
+ static_assert(test());
+
+ return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.transform/iterator/subscript.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.transform/iterator/subscript.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.transform/iterator/subscript.pass.cpp
@@ -0,0 +1,50 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+
+// transform_view::<iterator>::operator[]
+
+#include <ranges>
+
+#include "test_macros.h"
+#include "../types.h"
+
+constexpr bool test() {
+ int buff[8] = {0, 1, 2, 3, 4, 5, 6, 7};
+ std::ranges::transform_view transformView1(ContiguousView{buff}, Increment{});
+ auto iter1 = std::move(transformView1).begin() + 1;
+ assert(iter1[0] == 2);
+ assert(iter1[4] == 6);
+
+ static_assert(!noexcept(
+ std::declval<std::ranges::iterator_t<std::ranges::transform_view<ContiguousView, Increment>>>()[0]));
+ static_assert( noexcept(
+ std::declval<std::ranges::iterator_t<std::ranges::transform_view<ContiguousView, IncrementNoexcept>>>()[0]));
+
+ ASSERT_SAME_TYPE(
+ int,
+ decltype(std::declval<std::ranges::transform_view<RandomAccessView, Increment>>().begin()[0]));
+ ASSERT_SAME_TYPE(
+ int&,
+ decltype(std::declval<std::ranges::transform_view<RandomAccessView, IncrementRef>>().begin()[0]));
+ ASSERT_SAME_TYPE(
+ int&&,
+ decltype(std::declval<std::ranges::transform_view<RandomAccessView, IncrementRvalueRef>>().begin()[0]));
+
+ return true;
+}
+
+int main(int, char**) {
+ test();
+ static_assert(test());
+
+ return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.transform/iterator/types.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.transform/iterator/types.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.transform/iterator/types.pass.cpp
@@ -0,0 +1,93 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+
+// transform_view::<iterator>::difference_type
+// transform_view::<iterator>::value_type
+// transform_view::<iterator>::iterator_category
+// transform_view::<iterator>::iterator_concept
+
+#include <ranges>
+
+#include "test_macros.h"
+#include "../types.h"
+
+template<class V, class F>
+concept HasIterCategory = requires { typename std::ranges::transform_view<V, F>::iterator_category; };
+
+constexpr bool test() {
+ {
+ // Member typedefs for contiguous iterator.
+ static_assert(std::same_as<std::iterator_traits<int*>::iterator_concept, std::contiguous_iterator_tag>);
+ static_assert(std::same_as<std::iterator_traits<int*>::iterator_category, std::random_access_iterator_tag>);
+
+ using TView = std::ranges::transform_view<ContiguousView, IncrementRef>;
+ using TIter = std::ranges::iterator_t<TView>;
+ static_assert(std::same_as<typename TIter::iterator_concept, std::random_access_iterator_tag>);
+ static_assert(std::same_as<typename TIter::iterator_category, std::random_access_iterator_tag>);
+ static_assert(std::same_as<typename TIter::value_type, int>);
+ static_assert(std::same_as<typename TIter::difference_type, std::ptrdiff_t>);
+ }
+ {
+ // Member typedefs for random access iterator.
+ using TView = std::ranges::transform_view<RandomAccessView, IncrementRef>;
+ using TIter = std::ranges::iterator_t<TView>;
+ static_assert(std::same_as<typename TIter::iterator_concept, std::random_access_iterator_tag>);
+ static_assert(std::same_as<typename TIter::iterator_category, std::random_access_iterator_tag>);
+ static_assert(std::same_as<typename TIter::value_type, int>);
+ static_assert(std::same_as<typename TIter::difference_type, std::ptrdiff_t>);
+ }
+ {
+ // Member typedefs for random access iterator/not-lvalue-ref.
+ using TView = std::ranges::transform_view<RandomAccessView, Increment>;
+ using TIter = std::ranges::iterator_t<TView>;
+ static_assert(std::same_as<typename TIter::iterator_concept, std::random_access_iterator_tag>);
+ static_assert(std::same_as<typename TIter::iterator_category, std::input_iterator_tag>); // Note: this is now input_iterator_tag.
+ static_assert(std::same_as<typename TIter::value_type, int>);
+ static_assert(std::same_as<typename TIter::difference_type, std::ptrdiff_t>);
+ }
+ {
+ // Member typedefs for bidirectional iterator.
+ using TView = std::ranges::transform_view<BidirectionalView, IncrementRef>;
+ using TIter = std::ranges::iterator_t<TView>;
+ static_assert(std::same_as<typename TIter::iterator_concept, std::bidirectional_iterator_tag>);
+ static_assert(std::same_as<typename TIter::iterator_category, std::bidirectional_iterator_tag>);
+ static_assert(std::same_as<typename TIter::value_type, int>);
+ static_assert(std::same_as<typename TIter::difference_type, std::ptrdiff_t>);
+ }
+ {
+ // Member typedefs for forward iterator.
+ using TView = std::ranges::transform_view<ForwardView, IncrementRef>;
+ using TIter = std::ranges::iterator_t<TView>;
+ static_assert(std::same_as<typename TIter::iterator_concept, std::forward_iterator_tag>);
+ static_assert(std::same_as<typename TIter::iterator_category, std::forward_iterator_tag>);
+ static_assert(std::same_as<typename TIter::value_type, int>);
+ static_assert(std::same_as<typename TIter::difference_type, std::ptrdiff_t>);
+ }
+ {
+ // Member typedefs for input iterator.
+ using TView = std::ranges::transform_view<InputView, IncrementRef>;
+ using TIter = std::ranges::iterator_t<TView>;
+ static_assert(std::same_as<typename TIter::iterator_concept, std::input_iterator_tag>);
+ static_assert(!HasIterCategory<InputView, IncrementRef>);
+ static_assert(std::same_as<typename TIter::value_type, int>);
+ static_assert(std::same_as<typename TIter::difference_type, std::ptrdiff_t>);
+ }
+
+ return true;
+}
+
+int main(int, char**) {
+ test();
+ static_assert(test());
+
+ return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.transform/size.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.transform/size.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.transform/size.pass.cpp
@@ -0,0 +1,48 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 "test_macros.h"
+#include "types.h"
+
+template<class T>
+concept SizeInvocable = requires(T t) { t.size(); };
+
+constexpr bool test() {
+ {
+ std::ranges::transform_view transformView(ContiguousView{}, Increment{});
+ assert(transformView.size() == 8);
+ }
+
+ {
+ const std::ranges::transform_view transformView(ContiguousView{globalBuff, 4}, Increment{});
+ assert(transformView.size() == 4);
+ }
+
+ static_assert(!SizeInvocable<std::ranges::transform_view<ForwardView, Increment>>);
+
+ static_assert(SizeInvocable<std::ranges::transform_view<SizedSentinelNotConstView, Increment>>);
+ static_assert(!SizeInvocable<const std::ranges::transform_view<SizedSentinelNotConstView, Increment>>);
+
+ return true;
+}
+
+int main(int, char**) {
+ test();
+ static_assert(test());
+
+ return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.transform/types.h b/libcxx/test/std/ranges/range.adaptors/range.transform/types.h
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.transform/types.h
@@ -0,0 +1,155 @@
+#ifndef TEST_STD_RANGES_RANGE_ADAPTORS_RANGE_TRANSFORM_TYPES_H
+#define TEST_STD_RANGES_RANGE_ADAPTORS_RANGE_TRANSFORM_TYPES_H
+
+#include "test_macros.h"
+#include "test_iterators.h"
+#include "test_range.h"
+
+int globalBuff[8] = {0,1,2,3,4,5,6,7};
+
+template<class T, class F>
+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; }
+};
+
+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; }
+};
+
+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); }
+};
+
+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;
+ RandomAccessIter begin() noexcept;
+ RandomAccessIter end() noexcept;
+};
+
+using BidirectionalIter = bidirectional_iterator<int*>;
+struct BidirectionalView : std::ranges::view_base {
+ BidirectionalIter begin() const;
+ BidirectionalIter end() const;
+ BidirectionalIter begin();
+ BidirectionalIter end();
+};
+
+struct BorrowableRange {
+ friend int* begin(BorrowableRange const& range);
+ friend int* end(BorrowableRange const&);
+ friend int* begin(BorrowableRange& range);
+ friend int* end(BorrowableRange&);
+};
+
+template<>
+inline constexpr bool std::ranges::enable_borrowed_range<BorrowableRange> = true;
+
+struct InputView : std::ranges::view_base {
+ int *ptr;
+ constexpr InputView(int* ptr = globalBuff) : ptr(ptr) {}
+ constexpr cpp20_input_iterator<int*> begin() const { return cpp20_input_iterator<int*>(ptr); }
+ constexpr int* end() const { return ptr + 8; }
+ constexpr cpp20_input_iterator<int*> begin() { return cpp20_input_iterator<int*>(ptr); }
+ constexpr int* end() { return ptr + 8; }
+};
+
+constexpr bool operator==(const cpp20_input_iterator<int*> &lhs, int* rhs) { return lhs.base() == rhs; }
+constexpr bool operator==(int* lhs, const cpp20_input_iterator<int*> &rhs) { return rhs.base() == lhs; }
+
+struct SizedSentinelView : std::ranges::view_base {
+ int count;
+ constexpr SizedSentinelView(int count = 8) : count(count) {}
+ constexpr RandomAccessIter begin() const { return RandomAccessIter(globalBuff); }
+ constexpr int* end() const { return globalBuff + count; }
+ constexpr RandomAccessIter begin() { return RandomAccessIter(globalBuff); }
+ constexpr int* end() { return globalBuff + count; }
+};
+
+constexpr long operator- (const RandomAccessIter &lhs, int* rhs) { return lhs.base() - rhs; }
+constexpr long operator- (int* lhs, const RandomAccessIter &rhs) { return lhs - rhs.base(); }
+constexpr bool operator==(const RandomAccessIter &lhs, int* rhs) { return lhs.base() == rhs; }
+constexpr bool operator==(int* lhs, const RandomAccessIter &rhs) { return rhs.base() == lhs; }
+
+struct SizedSentinelNotConstView : std::ranges::view_base {
+ ForwardIter begin() const;
+ int *end() const;
+ ForwardIter begin();
+ int *end();
+ size_t size();
+};
+bool operator==(const ForwardIter &lhs, int* rhs);
+bool operator==(int* lhs, const ForwardIter &rhs);
+
+struct Range {
+ friend int* begin(Range const&);
+ friend int* end(Range const&);
+ friend int* begin(Range&);
+ friend int* end(Range&);
+};
+
+using CountedIter = stride_counting_iterator<forward_iterator<int*>>;
+struct CountedView : std::ranges::view_base {
+ constexpr CountedIter begin() { return CountedIter(ForwardIter(globalBuff)); }
+ constexpr CountedIter begin() const { return CountedIter(ForwardIter(globalBuff)); }
+ constexpr CountedIter end() { return CountedIter(ForwardIter(globalBuff + 8)); }
+ constexpr CountedIter end() const { return CountedIter(ForwardIter(globalBuff + 8)); }
+};
+
+using ThreeWayCompIter = three_way_contiguous_iterator<int*>;
+struct ThreeWayCompView : std::ranges::view_base {
+ constexpr ThreeWayCompIter begin() { return ThreeWayCompIter(globalBuff); }
+ constexpr ThreeWayCompIter begin() const { return ThreeWayCompIter(globalBuff); }
+ constexpr ThreeWayCompIter end() { return ThreeWayCompIter(globalBuff + 8); }
+ constexpr ThreeWayCompIter end() const { return ThreeWayCompIter(globalBuff + 8); }
+};
+
+struct Increment {
+ constexpr int operator()(int x) { return x + 1; }
+};
+
+struct IncrementConst {
+ constexpr int operator()(int x) const { return x + 1; }
+};
+
+struct IncrementRef {
+ constexpr int& operator()(int x) { return ++x; }
+};
+
+struct IncrementRvalueRef {
+ constexpr int&& operator()(int x) { return std::move(++x); }
+};
+
+struct IncrementNoexcept {
+ constexpr int operator()(int x) noexcept { return x + 1; }
+};
+
+#endif // TEST_STD_RANGES_RANGE_ADAPTORS_RANGE_TRANSFORM_TYPES_H
diff --git a/libcxx/test/std/utilities/optional/optional.object/optional.object.observe/dereference.pass.cpp b/libcxx/test/std/utilities/optional/optional.object/optional.object.observe/dereference.pass.cpp
--- a/libcxx/test/std/utilities/optional/optional.object/optional.object.observe/dereference.pass.cpp
+++ b/libcxx/test/std/utilities/optional/optional.object/optional.object.observe/dereference.pass.cpp
@@ -44,6 +44,7 @@
{
optional<X> opt; ((void)opt);
ASSERT_SAME_TYPE(decltype(*opt), X&);
+ LIBCPP_STATIC_ASSERT(noexcept(*opt));
// ASSERT_NOT_NOEXCEPT(*opt);
// FIXME: This assertion fails with GCC because it can see that
// (A) operator*() is constexpr, and
diff --git a/libcxx/test/std/utilities/optional/optional.object/optional.object.observe/dereference_const.pass.cpp b/libcxx/test/std/utilities/optional/optional.object/optional.object.observe/dereference_const.pass.cpp
--- a/libcxx/test/std/utilities/optional/optional.object/optional.object.observe/dereference_const.pass.cpp
+++ b/libcxx/test/std/utilities/optional/optional.object/optional.object.observe/dereference_const.pass.cpp
@@ -37,6 +37,7 @@
{
const optional<X> opt; ((void)opt);
ASSERT_SAME_TYPE(decltype(*opt), X const&);
+ LIBCPP_STATIC_ASSERT(noexcept(*opt));
// ASSERT_NOT_NOEXCEPT(*opt);
// FIXME: This assertion fails with GCC because it can see that
// (A) operator*() is constexpr, and
diff --git a/libcxx/test/std/utilities/optional/optional.object/optional.object.observe/dereference_const_rvalue.pass.cpp b/libcxx/test/std/utilities/optional/optional.object/optional.object.observe/dereference_const_rvalue.pass.cpp
--- a/libcxx/test/std/utilities/optional/optional.object/optional.object.observe/dereference_const_rvalue.pass.cpp
+++ b/libcxx/test/std/utilities/optional/optional.object/optional.object.observe/dereference_const_rvalue.pass.cpp
@@ -37,6 +37,7 @@
{
const optional<X> opt; ((void)opt);
ASSERT_SAME_TYPE(decltype(*std::move(opt)), X const &&);
+ LIBCPP_STATIC_ASSERT(noexcept(*opt));
// ASSERT_NOT_NOEXCEPT(*std::move(opt));
// FIXME: This assertion fails with GCC because it can see that
// (A) operator*() is constexpr, and
diff --git a/libcxx/test/std/utilities/optional/optional.object/optional.object.observe/dereference_rvalue.pass.cpp b/libcxx/test/std/utilities/optional/optional.object/optional.object.observe/dereference_rvalue.pass.cpp
--- a/libcxx/test/std/utilities/optional/optional.object/optional.object.observe/dereference_rvalue.pass.cpp
+++ b/libcxx/test/std/utilities/optional/optional.object/optional.object.observe/dereference_rvalue.pass.cpp
@@ -44,6 +44,7 @@
{
optional<X> opt; ((void)opt);
ASSERT_SAME_TYPE(decltype(*std::move(opt)), X&&);
+ LIBCPP_STATIC_ASSERT(noexcept(*opt));
// ASSERT_NOT_NOEXCEPT(*std::move(opt));
// FIXME: This assertion fails with GCC because it can see that
// (A) operator*() is constexpr, and
diff --git a/libcxx/test/support/test_iterators.h b/libcxx/test/support/test_iterators.h
--- a/libcxx/test/support/test_iterators.h
+++ b/libcxx/test/support/test_iterators.h
@@ -874,6 +874,62 @@
I base_ = I();
};
+template <class It>
+class three_way_contiguous_iterator
+{
+ static_assert(std::is_pointer_v<It>, "Things probably break in this case");
+
+ It it_;
+
+ template <class U> friend class three_way_contiguous_iterator;
+public:
+ typedef std::contiguous_iterator_tag iterator_category;
+ typedef typename std::iterator_traits<It>::value_type value_type;
+ typedef typename std::iterator_traits<It>::difference_type difference_type;
+ typedef It pointer;
+ typedef typename std::iterator_traits<It>::reference reference;
+ typedef typename std::remove_pointer<It>::type element_type;
+
+ TEST_CONSTEXPR_CXX14 It base() const {return it_;}
+
+ TEST_CONSTEXPR_CXX14 three_way_contiguous_iterator() : it_() {}
+ explicit TEST_CONSTEXPR_CXX14 three_way_contiguous_iterator(It it) : it_(it) {}
+ template <class U>
+ TEST_CONSTEXPR_CXX14 three_way_contiguous_iterator(const three_way_contiguous_iterator<U>& u) : it_(u.it_) {}
+
+ TEST_CONSTEXPR_CXX14 reference operator*() const {return *it_;}
+ TEST_CONSTEXPR_CXX14 pointer operator->() const {return it_;}
+
+ TEST_CONSTEXPR_CXX14 three_way_contiguous_iterator& operator++() {++it_; return *this;}
+ TEST_CONSTEXPR_CXX14 three_way_contiguous_iterator operator++(int)
+ {three_way_contiguous_iterator tmp(*this); ++(*this); return tmp;}
+
+ TEST_CONSTEXPR_CXX14 three_way_contiguous_iterator& operator--() {--it_; return *this;}
+ TEST_CONSTEXPR_CXX14 three_way_contiguous_iterator operator--(int)
+ {three_way_contiguous_iterator tmp(*this); --(*this); return tmp;}
+
+ TEST_CONSTEXPR_CXX14 three_way_contiguous_iterator& operator+=(difference_type n) {it_ += n; return *this;}
+ TEST_CONSTEXPR_CXX14 three_way_contiguous_iterator operator+(difference_type n) const
+ {three_way_contiguous_iterator tmp(*this); tmp += n; return tmp;}
+ friend TEST_CONSTEXPR_CXX14 three_way_contiguous_iterator operator+(difference_type n, three_way_contiguous_iterator x)
+ {x += n; return x;}
+ TEST_CONSTEXPR_CXX14 three_way_contiguous_iterator& operator-=(difference_type n) {return *this += -n;}
+ TEST_CONSTEXPR_CXX14 three_way_contiguous_iterator operator-(difference_type n) const
+ {three_way_contiguous_iterator tmp(*this); tmp -= n; return tmp;}
+
+ TEST_CONSTEXPR_CXX14 reference operator[](difference_type n) const {return it_[n];}
+
+ template <class T>
+ void operator,(T const &) DELETE_FUNCTION;
+
+ friend TEST_CONSTEXPR_CXX14
+ difference_type operator-(const three_way_contiguous_iterator& x, const three_way_contiguous_iterator& y) {
+ return x.base() - y.base();
+ }
+
+ friend auto operator<=>(const three_way_contiguous_iterator&, const three_way_contiguous_iterator&) = default;
+};
+
// clang-format on
#endif // TEST_STD_VER > 17 && defined(__cpp_lib_concepts)