[libc++] Implement ranges::view

[ldionne]

libcxx/test/std/ranges/range.view/view.compile.pass.cpp

27–30

@cjdb I found it very surprising that I had to provide both those overloads for the range concept to be satisfied. Is that really intended, or is that a bug in the patch that adds range (which is under review)?

[cjdb]

libcxx/test/std/ranges/range.view/view.compile.pass.cpp

27–30

This is a very annoying artefact of the poison pills. @tcanens, what's the likelihood we can get LWG to review their existence?

[zoecarver]

Nice! Looks good sans the nits.

libcxx/docs/OneRangesProposalStatus.csv

43

Is there anything else here? I think you can mark it as complete.

libcxx/include/ranges

62

We need to keep this.

libcxx/test/std/ranges/range.view/view.compile.pass.cpp

36

Nit: spacing (and elsewhere).

[zoecarver]

libcxx/test/std/ranges/range.view/enable_view.compile.pass.cpp

23

What if you named these more like the types in the other test file? So this would be Empty, next would be PrivateViewBase, then EnableViewFalse, then DerivesViewBase, then EnableViewTrue (or something similar).

[tcanens]

libcxx/test/std/ranges/range.view/view.compile.pass.cpp

27–30

Would definitely take a paper and implementation experience.

[ldionne]

Apply review comments

[zoecarver]

🚢 it.

libcxx/include/ranges

62

Never mind I see we're including this twice 🤦‍♂️.

[ldionne]

libcxx/test/std/ranges/range.view/view.compile.pass.cpp

36

So the original reason to indent it that way was to make the thing we're actually trying to test stand out. But I guess I'll remove it :-).

[cjdb]

LGTM overall, tests are very elegant! Would you mind adding checks that our existing ranges aren't views to the conformance tests please?

[ldionne]

Address review comments.

[cjdb]

LGTM, pending a subsumption test.

[ldionne]

Add subsumption test.

[ldionne]

Will ship once CI passes.

[ldionne]

Rebase onto main

libcxx/docs/OneRangesProposalStatus.csv

 [counted.iterator],,"[iterator.concepts], [iterator.cust.swap], [iterator.cust.move], [default.sentinels]",,,
 [stream.iterators],,[default.sentinels],,,
 [ranges.syn]: pt. 1,All the stuff not specified elsewhere. ,"[range.access], [iterator.concepts], [range.all], [range.subrange], unreachable, [range.empty]",,,
 [ranges.syn]: pt. 2,"iterator_t, sentinel_t, and safe_iterator_t",[range.access],Christopher Di Bella,"`D100255 <https://llvm.org/D100255>`_, `D100269 <https://llvm.org/D100269>`_",
 [range.access],"ranges::begin, end, cbegin, cend, rbegin, rend, crbegin, and crend",[iterator.concepts],Christopher Di Bella,`D100255 <https://llvm.org/D100255>`_,
 [ranges.primitives],"size, empty, data, and cdata",[iterator.concepts],Zoe Carver,,
 [range.range],,[range.access],,,
 [range.sized],,"[range.primitives], [range.range]",,,
-[range.view],View and enable_view,[range.range],,,
+[range.view],View and enable_view,[range.range],Louis Dionne,,
 [range.refinements],"OutputRange, InputRange, ForwardRange, BidirectionalRange, RandomAccessRange, ContiguousRange, CommonRange, ViewableRange","[ranges.syn]: pt. 2, [range.range]",Christopher Di Bella,"input_range: `D100271 <https://llvm.org/D100271>`_
 forward_range: `D100275 <https://llvm.org/D100275>`_
 bidirectional_range: `D100278 <https://llvm.org/D100278>`_",
 [view.interface],[range.utility.helpers] and view_interface,"[ranges.syn]: pt. 2, [range.view], [range.iterator.operations.prev], [range.refinements]",,,
 [range.subrange],,[view.interface],,,
 [range.all],view::all,"[range.subrange], [range.view.ref]",,,
 [range.view.ref],ref-view,[view.interface],,,
 [range.filter],filter_view,[range.all],,,

libcxx/include/CMakeLists.txt

set(files
   __node_handle
   __nullptr
   __ranges/begin.h
   __ranges/cbegin.h
   __ranges/cend.h
   __ranges/concepts.h
   __ranges/end.h
   __ranges/enable_borrowed_range.h
+  __ranges/view.h
   __split_buffer
   __sso_allocator
   __std_stream
   __string
   __threading_support
   __tree
   __tuple
   __undef_macros

libcxx/include/__ranges/view.h

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___RANGES_VIEW_H
+#define _LIBCPP___RANGES_VIEW_H
+
+#include <__config>
+#include <__ranges/concepts.h>
+#include <concepts>
+
+
+#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 {
+
+struct view_base { };
+
+template <class _Tp>
+inline constexpr bool enable_view = derived_from<_Tp, view_base>;
+
+template <class _Tp>
+concept view =
+  range<_Tp> &&
+  movable<_Tp> &&
+  default_initializable<_Tp> &&
+  enable_view<_Tp>;
+
+} // end namespace ranges
+
+#endif // !_LIBCPP_HAS_NO_RANGES
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___RANGES_VIEW_H

libcxx/include/ranges

template<range R>
     using range_difference_t = iter_difference_t<iterator_t<R>>;
   template<range R>
     using range_value_t = iter_value_t<iterator_t<R>>;
   template<range R>
     using range_reference_t = iter_reference_t<iterator_t<R>>;
   template<range R>
     using range_rvalue_reference_t = iter_rvalue_reference_t<iterator_t<R>>;
 
+  // [range.view], views
+  template<class T>
+    inline constexpr bool enable_view = ...;
+
+  struct view_base { };
+
+  template<class T>
+    concept view = ...;
+
   // [range.refinements], other range refinements
   template <class _Tp>
     concept common_range = see below;
 }
 
 */
 
 #include <__config>
 #include <__ranges/begin.h>
 #include <__ranges/cbegin.h>
 #include <__ranges/cend.h>
 #include <__ranges/concepts.h>
-#include <__ranges/end.h>
 #include <__ranges/enable_borrowed_range.h>
 #include <__ranges/end.h>
+#include <__ranges/view.h>
 #include <compare>          // Required by the standard.
 #include <initializer_list> // Required by the standard.
 #include <iterator>         // Required by the standard.
 #include <type_traits>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header

libcxx/test/std/ranges/range.view/enable_view.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// XFAIL: msvc && clang
+
+// <ranges>
+
+// template<class T>
+// inline constexpr bool enable_view = ...;
+
+#include <ranges>
+
+#include "test_macros.h"
+
+// Doesn't derive from view_base
+struct NotAView1 { };
+static_assert(!std::ranges::enable_view<NotAView1>);
+
+// Derives from view_base, but privately
+struct NotAView2 : private std::ranges::view_base { };
+static_assert(!std::ranges::enable_view<NotAView2>);
+
+// Derives from view_base, but specializes enable_view to false
+struct NotAView3 : std::ranges::view_base { };
+namespace std::ranges { template <> constexpr bool enable_view<NotAView3> = false; }
+static_assert(!std::ranges::enable_view<NotAView3>);
+
+
+// Derives from view_base
+struct View1 : std::ranges::view_base { };
+static_assert(std::ranges::enable_view<View1>);
+
+// Does not derive from view_base, but specializes enable_view to true
+struct View2 { };
+namespace std::ranges { template <> constexpr bool enable_view<View2> = true; }
+static_assert(std::ranges::enable_view<View2>);
+
+
+// Make sure that enable_view is a bool, not some other contextually-convertible-to-bool type.
+ASSERT_SAME_TYPE(decltype(std::ranges::enable_view<NotAView1>), const bool);
+ASSERT_SAME_TYPE(decltype(std::ranges::enable_view<View1>), const bool);

libcxx/test/std/ranges/range.view/view.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// XFAIL: msvc && clang
+
+// <ranges>
+
+// template<class T>
+// concept view = ...;
+
+#include <ranges>
+
+#include "test_macros.h"
+
+// The type would be a view, but it's not moveable.
+struct NotMoveable : std::ranges::view_base {
+  NotMoveable() = default;
+  NotMoveable(NotMoveable&&) = delete;
+  NotMoveable& operator=(NotMoveable&&) = delete;
+  friend int* begin(NotMoveable&);
+  friend int* begin(NotMoveable const&);
+  friend int* end(NotMoveable&);
+  friend int* end(NotMoveable const&);
+};
+static_assert(std::ranges::range<NotMoveable>);
+static_assert(!std::movable<NotMoveable>);
+static_assert(std::default_initializable<NotMoveable>);
+static_assert(std::ranges::enable_view<NotMoveable>);
+  static_assert(!std::ranges::view<NotMoveable>);
+
+// The type would be a view, but it's not default initializable
+struct NotDefaultInit : std::ranges::view_base {
+  NotDefaultInit() = delete;
+  friend int* begin(NotDefaultInit&);
+  friend int* begin(NotDefaultInit const&);
+  friend int* end(NotDefaultInit&);
+  friend int* end(NotDefaultInit const&);
+};
+static_assert(std::ranges::range<NotDefaultInit>);
+static_assert(std::movable<NotDefaultInit>);
+static_assert(!std::default_initializable<NotDefaultInit>);
+static_assert(std::ranges::enable_view<NotDefaultInit>);
+  static_assert(!std::ranges::view<NotDefaultInit>);
+
+// The type would be a view, but it doesn't enable it with enable_view
+struct NotExplicitlyEnabled {
+  NotExplicitlyEnabled() = default;
+  NotExplicitlyEnabled(NotExplicitlyEnabled&&) = default;
+  NotExplicitlyEnabled& operator=(NotExplicitlyEnabled&&) = default;
+  friend int* begin(NotExplicitlyEnabled&);
+  friend int* begin(NotExplicitlyEnabled const&);
+  friend int* end(NotExplicitlyEnabled&);
+  friend int* end(NotExplicitlyEnabled const&);
+};
+static_assert(std::ranges::range<NotExplicitlyEnabled>);
+static_assert(std::movable<NotExplicitlyEnabled>);
+static_assert(std::default_initializable<NotExplicitlyEnabled>);
+static_assert(!std::ranges::enable_view<NotExplicitlyEnabled>);
+  static_assert(!std::ranges::view<NotExplicitlyEnabled>);
+
+// The type has everything else, but it's not a range
+struct NotARange : std::ranges::view_base {
+  NotARange() = default;
+  NotARange(NotARange&&) = default;
+  NotARange& operator=(NotARange&&) = default;
+};
+static_assert(!std::ranges::range<NotARange>);
+static_assert(std::movable<NotARange>);
+static_assert(std::default_initializable<NotARange>);
+static_assert(std::ranges::enable_view<NotARange>);
+  static_assert(!std::ranges::view<NotARange>);
+
+// The type satisfies all requirements
+struct View : std::ranges::view_base {
+  View() = default;
+  View(View&&) = default;
+  View& operator=(View&&) = default;
+  friend int* begin(View&);
+  friend int* begin(View const&);
+  friend int* end(View&);
+  friend int* end(View const&);
+};
+static_assert(std::ranges::range<View>);
+static_assert(std::movable<View>);
+static_assert(std::default_initializable<View>);
+static_assert(std::ranges::enable_view<View>);
+  static_assert(std::ranges::view<View>);

libcxx/test/std/ranges/range.view/view_base.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// XFAIL: msvc && clang
+
+// <ranges>
+
+// struct view_base { };
+
+#include <ranges>
+#include <type_traits>
+
+static_assert(std::is_empty_v<std::ranges::view_base>);
+static_assert(std::is_trivial_v<std::ranges::view_base>);
+
+// Make sure we can inherit from it, as it's intended (that wouldn't be the
+// case if e.g. it was marked as final).
+struct View : std::ranges::view_base { };