--- /dev/null
+// -*- 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_REF_VIEW_H
+#define _LIBCPP___RANGES_REF_VIEW_H
+
+#include <__config>
+#include <__iterator/concepts.h>
+#include <__iterator/iterator_traits.h>
+#include <__ranges/access.h>
+#include <__ranges/data.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)
+
+namespace ranges {
+ template<range _Range>
+ requires is_object_v<_Range>
+ class ref_view : public view_interface<ref_view<_Range>> {
+ _Range *__range_;
+
+ static void __fun(_Range&);
+ static void __fun(_Range&&) = delete;
+
+public:
+ template<class _Tp>
+ requires __different_from<_Tp, ref_view> &&
+ convertible_to<_Tp, _Range&> && requires { __fun(declval<_Tp>()); }
+ constexpr ref_view(_Tp&& __t)
+ : __range_(_VSTD::addressof(static_cast<_Range&>(_VSTD::forward<_Tp>(__t))))
+ {}
+
+ constexpr _Range& base() const { return *__range_; }
+
+ constexpr iterator_t<_Range> begin() const { return ranges::begin(*__range_); }
+ constexpr sentinel_t<_Range> end() const { return ranges::end(*__range_); }
+
+ constexpr bool empty() const
+ requires requires { ranges::empty(*__range_); }
+ { return ranges::empty(*__range_); }
+
+ constexpr auto size() const
+ requires sized_range<_Range>
+ { return ranges::size(*__range_); }
+
+ // TODO: This needs to use contiguous_range.
+ constexpr auto data() const
+ requires contiguous_iterator<iterator_t<_Range>>
+ { return ranges::data(*__range_); }
+ };
+
+ template<class _Range>
+ ref_view(_Range&) -> ref_view<_Range>;
+
+} // namespace ranges
+
+#endif // !defined(_LIBCPP_HAS_NO_RANGES)
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___RANGES_REF_VIEW_H
--- /dev/null
+//===----------------------------------------------------------------------===//
+//
+// 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
+
+// std::ranges::ref_view
+
+#include <ranges>
+
+#include <cassert>
+#include "test_macros.h"
+#include "test_iterators.h"
+
+int globalBuff[8];
+
+template<class T>
+concept ValidRefView = requires { typename std::ranges::ref_view<T>; };
+
+struct Range {
+ int start = 0;
+ friend constexpr int* begin(Range const& range) { return globalBuff + range.start; }
+ friend constexpr int* end(Range const&) { return globalBuff + 8; }
+ friend constexpr int* begin(Range& range) { return globalBuff + range.start; }
+ friend constexpr int* end(Range&) { return globalBuff + 8; }
+};
+
+struct BeginOnly {
+ friend int* begin(BeginOnly const&);
+ friend int* begin(BeginOnly &);
+};
+
+static_assert( ValidRefView<Range>);
+static_assert(!ValidRefView<BeginOnly>);
+static_assert(!ValidRefView<int (&)[4]>);
+static_assert( ValidRefView<int[4]>);
+
+static_assert(std::derived_from<std::ranges::ref_view<Range>, std::ranges::view_interface<std::ranges::ref_view<Range>>>);
+
+struct RangeConvertible {
+ operator Range& ();
+};
+
+struct RValueRangeConvertible {
+ operator Range&& ();
+};
+
+static_assert( std::is_constructible_v<std::ranges::ref_view<Range>, Range&>);
+static_assert( std::is_constructible_v<std::ranges::ref_view<Range>, RangeConvertible>);
+static_assert(!std::is_constructible_v<std::ranges::ref_view<Range>, RValueRangeConvertible>);
+
+struct ConstConvertibleToLValueAndRValue {
+ operator Range& () const;
+ operator Range&& () const;
+};
+static_assert( std::is_convertible_v<RangeConvertible, std::ranges::ref_view<Range>>);
+static_assert(!std::is_convertible_v<RValueRangeConvertible, std::ranges::ref_view<Range>>);
+static_assert(!std::is_convertible_v<ConstConvertibleToLValueAndRValue, std::ranges::ref_view<Range>>);
+
+struct ForwardRange {
+ constexpr forward_iterator<int*> begin() const { return forward_iterator<int*>(globalBuff); }
+ constexpr forward_iterator<int*> end() const { return forward_iterator<int*>(globalBuff + 8); }
+};
+
+struct Cpp17InputRange {
+ struct sentinel {
+ friend constexpr bool operator==(sentinel, cpp17_input_iterator<int*> iter) { return iter.base() == globalBuff + 8; }
+ friend constexpr std::ptrdiff_t operator-(sentinel, cpp17_input_iterator<int*>) { return -8; }
+ friend constexpr std::ptrdiff_t operator-(cpp17_input_iterator<int*>, sentinel) { return 8; }
+ };
+
+ constexpr cpp17_input_iterator<int*> begin() const {
+ return cpp17_input_iterator<int*>(globalBuff);
+ }
+ constexpr sentinel end() const { return {}; }
+};
+
+struct Cpp20InputRange {
+ struct sentinel {
+ friend constexpr bool operator==(sentinel, const cpp20_input_iterator<int*> &iter) { return iter.base() == globalBuff + 8; }
+ friend constexpr std::ptrdiff_t operator-(sentinel, const cpp20_input_iterator<int*>&) { return -8; }
+ };
+
+ constexpr cpp20_input_iterator<int*> begin() const {
+ return cpp20_input_iterator<int*>(globalBuff);
+ }
+ constexpr sentinel end() const { return {}; }
+};
+
+template<>
+inline constexpr bool std::ranges::enable_borrowed_range<Cpp20InputRange> = true;
+
+template<class R>
+concept EmptyIsInvocable = requires (std::ranges::ref_view<R> view) { view.empty(); };
+
+template<class R>
+concept SizeIsInvocable = requires (std::ranges::ref_view<R> view) { view.size(); };
+
+template<class R>
+concept DataIsInvocable = requires (std::ranges::ref_view<R> view) { view.data(); };
+
+// Testing ctad.
+static_assert(std::same_as<decltype(std::ranges::ref_view(std::declval<Range&>())),
+ std::ranges::ref_view<Range>>);
+
+constexpr bool test() {
+ {
+ // ref_view::base
+ Range range;
+ std::ranges::ref_view<Range> view{range};
+ assert(view.begin() == globalBuff);
+ view.base() = Range{2};
+ assert(view.begin() == globalBuff + 2);
+ }
+
+ {
+ // ref_view::begin
+ Range range1;
+ std::ranges::ref_view<Range> view1 = range1;
+ assert(view1.begin() == globalBuff);
+
+ ForwardRange range2;
+ std::ranges::ref_view<ForwardRange> view2 = range2;
+ assert(view2.begin().base() == globalBuff);
+
+ Cpp17InputRange range3;
+ std::ranges::ref_view<Cpp17InputRange> view3 = range3;
+ assert(view3.begin().base() == globalBuff);
+
+ Cpp20InputRange range4;
+ std::ranges::ref_view<Cpp20InputRange> view4 = range4;
+ assert(view4.begin().base() == globalBuff);
+ }
+
+ {
+ // ref_view::end
+ Range range1;
+ std::ranges::ref_view<Range> view1 = range1;
+ assert(view1.end() == globalBuff + 8);
+
+ ForwardRange range2;
+ std::ranges::ref_view<ForwardRange> view2 = range2;
+ assert(view2.end().base() == globalBuff + 8);
+
+ Cpp17InputRange range3;
+ std::ranges::ref_view<Cpp17InputRange> view3 = range3;
+ assert(view3.end() == cpp17_input_iterator(globalBuff + 8));
+
+ Cpp20InputRange range4;
+ std::ranges::ref_view<Cpp20InputRange> view4 = range4;
+ assert(view4.end() == cpp20_input_iterator(globalBuff + 8));
+ }
+
+ {
+ // ref_view::empty
+ Range range{8};
+ std::ranges::ref_view<Range> view1 = range;
+ assert(view1.empty());
+
+ ForwardRange range2;
+ std::ranges::ref_view<ForwardRange> view2 = range2;
+ assert(!view2.empty());
+
+ static_assert(!EmptyIsInvocable<Cpp17InputRange>);
+ static_assert(!EmptyIsInvocable<Cpp20InputRange>);
+ }
+
+ {
+ // ref_view::size
+ Range range1{8};
+ std::ranges::ref_view<Range> view1 = range1;
+ assert(view1.size() == 0);
+
+ Range range2{2};
+ std::ranges::ref_view<Range> view2 = range2;
+ assert(view2.size() == 6);
+
+ static_assert(!SizeIsInvocable<ForwardRange>);
+ }
+
+ {
+ // ref_view::data
+ Range range1;
+ std::ranges::ref_view<Range> view1 = range1;
+ assert(view1.data() == globalBuff);
+
+ Range range2{2};
+ std::ranges::ref_view<Range> view2 = range2;
+ assert(view2.data() == globalBuff + 2);
+
+ static_assert(!DataIsInvocable<ForwardRange>);
+ }
+
+ return true;
+}
+
+int main(int, char**) {
+ test();
+ static_assert(test());
+
+ return 0;
+}