[libc++] [ranges] ref_view and empty_view are borrowed ranges. Normalize borrowed_range tests.

[• Quuxplusone]

Summary

As reported in D116303. I've taken the liberty of simplifying all the existing borrowed_range tests to

• be named borrowing.compile.pass.cpp
• use simple library types, specifically empty_view (is borrowed) and single_view (is not borrowed), wherever possible (the only place this isn't possible AFAICT is in common_view, where I left a comment)
• move range.ref.view into its own subdirectory, but not dig into that rabbit hole otherwise
• consistently test for adherence to concept borrowed_range, rather than constexpr bool enable_borrowed_range — the latter is equally technically correct, but the former is shorter, and also more like what the library user will actually do in practice. No user should ever query enable_borrowed_range directly.

[ldionne]

Instead of using single_view and empty_view to mean NonBorrowedRange and BorrowedRange, I would rather retain such "archetypes" in test_range.h and use them in our tests. That way, our tests won't be wrong if our implementation is, and their names is more telling than single_view and empty_view, which say nothing about their borrowable-ness. This would even be acceptable, but while we're at it why not define them self-standing:

using NonBorrowedRange = std::ranges::single_view;
using BorrowedRange = std::ranges::empty_view;

At least that documents what we're testing for free.

libcxx/test/std/ranges/range.adaptors/range.all/range.ref.view/borrowing.compile.pass.cpp

20–22

[• Quuxplusone]

In D118164#3270391, @ldionne wrote:

Instead of using single_view and empty_view to mean NonBorrowedRange and BorrowedRange, I would rather retain such "archetypes" in test_range.h and use them in our tests. That way, our tests won't be wrong if our implementation is, and their names is more telling than single_view and empty_view, which say nothing about their borrowable-ness. This would even be acceptable, but while we're at it why not define them self-standing:

using NonBorrowedRange = std::ranges::single_view;
using BorrowedRange = std::ranges::empty_view;

My resistance to this idea is the usual: "there's no such thing as an archetype." These tests do test the specific codepath devoted to borrowed ranges; but we shouldn't lose sight of the fact that the specific T we're instantiating them with has all the properties of single_view<T> or empty_view<T> — for example, it's a view itself, as opposed to a non-view. I actually just proposed a non-view BorrowedRange in one of @philnik's reviews! I suppose we could have our thing be named BorrowedView, and then have a BorrowedRange that's not a view, as well... Anyway, I'll pursue that a little bit, but at the moment I'm skeptical.
(Note that take_view<BorrowedView> is OK but take_view<BorrowedRange /*i.e. not a view*/> would be ill-formed.)

[• Quuxplusone]

Add BorrowedRange, BorrowedView, and NonBorrowedView to "support/test_range.h". Ping @ldionne!

libcxx/include/__ranges/empty_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_EMPTY_VIEW_H
 #define _LIBCPP___RANGES_EMPTY_VIEW_H
 
 #include <__config>
+#include <__ranges/enable_borrowed_range.h>
 #include <__ranges/view_interface.h>
 #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<class _Tp>
     requires is_object_v<_Tp>
   class empty_view : public view_interface<empty_view<_Tp>> {
   public:
     _LIBCPP_HIDE_FROM_ABI static constexpr _Tp* begin() noexcept { return nullptr; }
     _LIBCPP_HIDE_FROM_ABI static constexpr _Tp* end() noexcept { return nullptr; }
     _LIBCPP_HIDE_FROM_ABI static constexpr _Tp* data() noexcept { return nullptr; }
     _LIBCPP_HIDE_FROM_ABI static constexpr size_t size() noexcept { return 0; }
     _LIBCPP_HIDE_FROM_ABI static constexpr bool empty() noexcept { return true; }
   };
+
+  template<class _Tp>
+  inline constexpr bool enable_borrowed_range<empty_view<_Tp>> = true;
 } // namespace ranges
 
 #endif // !defined(_LIBCPP_HAS_NO_RANGES)
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___RANGES_EMPTY_VIEW_H

libcxx/include/__ranges/ref_view.h

 #include <__iterator/concepts.h>
 #include <__iterator/incrementable_traits.h>
 #include <__iterator/iterator_traits.h>
 #include <__memory/addressof.h>
 #include <__ranges/access.h>
 #include <__ranges/concepts.h>
 #include <__ranges/data.h>
 #include <__ranges/empty.h>
+#include <__ranges/enable_borrowed_range.h>
 #include <__ranges/size.h>
 #include <__ranges/view_interface.h>
 #include <__utility/forward.h>
 #include <concepts>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
public:
     constexpr auto data() const
       requires contiguous_range<_Range>
     { return ranges::data(*__range_); }
   };
 
   template<class _Range>
   ref_view(_Range&) -> ref_view<_Range>;
 
+  template<class _Tp>
+  inline constexpr bool enable_borrowed_range<ref_view<_Tp>> = true;
 } // namespace ranges
 
 #endif // !defined(_LIBCPP_HAS_NO_RANGES)
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___RANGES_REF_VIEW_H

libcxx/test/std/ranges/range.adaptors/range.all/range.owning.view/borrowing.compile.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-no-concepts
 // UNSUPPORTED: libcpp-has-no-incomplete-ranges
 
 // template<class T>
 //   inline constexpr bool enable_borrowed_range<owning_view<T>> = enable_borrowed_range<T>;
 
 #include <ranges>
-#include <cassert>
 
-struct Range {
-  int *begin() const;
-  int *end() const;
-};
+#include "test_range.h"
 
-struct BorrowableRange {
-  int *begin() const;
-  int *end() const;
-};
-
-template<>
-inline constexpr bool std::ranges::enable_borrowed_range<BorrowableRange> = true;
-
-static_assert(!std::ranges::enable_borrowed_range<std::ranges::owning_view<Range>>);
-static_assert( std::ranges::enable_borrowed_range<std::ranges::owning_view<BorrowableRange>>);
+static_assert( std::ranges::borrowed_range<std::ranges::owning_view<BorrowedView>>);
+static_assert(!std::ranges::borrowed_range<std::ranges::owning_view<NonBorrowedView>>);

libcxx/test/std/ranges/range.adaptors/range.all/range.ref.view/borrowing.compile.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-no-concepts
 // UNSUPPORTED: libcpp-has-no-incomplete-ranges
 
-// class std::ranges::subrange;
+// template<class T>
+//   inline constexpr bool enable_borrowed_range<ref_view<T>> = true;
 
 #include <ranges>
 
-#include "test_iterators.h"
+#include "test_range.h"
 
-namespace ranges = std::ranges;
-
-static_assert(ranges::borrowed_range<ranges::subrange<int*>>);
-static_assert(ranges::borrowed_range<ranges::subrange<int*, int const*>>);
-static_assert(ranges::borrowed_range<ranges::subrange<int*, sentinel_wrapper<int*>, ranges::subrange_kind::unsized>>);
+static_assert(std::ranges::borrowed_range<std::ranges::ref_view<BorrowedRange>>);
+static_assert(std::ranges::borrowed_range<std::ranges::ref_view<BorrowedView>>);
+static_assert(std::ranges::borrowed_range<std::ranges::ref_view<NonBorrowedView>>);

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

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-no-concepts
 // UNSUPPORTED: libcpp-has-no-incomplete-ranges
 
 // template<class T>
 //   inline constexpr bool enable_borrowed_range<common_view<T>> = enable_borrowed_range<T>;
 
 #include <ranges>
-#include <cassert>
 
-#include "test_iterators.h"
-
-struct View : std::ranges::view_base {
-  int *begin() const;
-  sentinel_wrapper<int*> end() const;
-};
-
-struct BorrowableView : std::ranges::view_base {
+// common_view can only wrap Ts that are `view<T> && !common_range<T>`, so we need to invent one.
+struct Uncommon : std::ranges::view_base {
     int *begin() const;
-  sentinel_wrapper<int*> end() const;
+    std::unreachable_sentinel_t end() const;
 };
-template<>
-inline constexpr bool std::ranges::enable_borrowed_range<BorrowableView> = true;
 
-static_assert(!std::ranges::enable_borrowed_range<std::ranges::common_view<View>>);
-static_assert( std::ranges::enable_borrowed_range<std::ranges::common_view<BorrowableView>>);
+static_assert(!std::ranges::borrowed_range<std::ranges::common_view<Uncommon>>);
+static_assert(!std::ranges::borrowed_range<std::ranges::common_view<std::ranges::owning_view<Uncommon>>>);
+static_assert( std::ranges::borrowed_range<std::ranges::common_view<std::ranges::ref_view<Uncommon>>>);

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

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-no-concepts
 // UNSUPPORTED: libcpp-has-no-incomplete-ranges
 
-// class std::ranges::subrange;
+// template<class T>
+//   inline constexpr bool enable_borrowed_range<empty_view<T>> = true;
 
 #include <ranges>
 
-#include "test_iterators.h"
+#include "test_range.h"
 
-namespace ranges = std::ranges;
-
-static_assert(ranges::borrowed_range<ranges::subrange<int*>>);
-static_assert(ranges::borrowed_range<ranges::subrange<int*, int const*>>);
-static_assert(ranges::borrowed_range<ranges::subrange<int*, sentinel_wrapper<int*>, ranges::subrange_kind::unsized>>);
+static_assert(std::ranges::borrowed_range<std::ranges::empty_view<int>>);
+static_assert(std::ranges::borrowed_range<std::ranges::empty_view<int*>>);
+static_assert(std::ranges::borrowed_range<std::ranges::empty_view<BorrowedView>>);
+static_assert(std::ranges::borrowed_range<std::ranges::empty_view<NonBorrowedView>>);

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

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-no-concepts
 // UNSUPPORTED: 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"
+#include "test_range.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>>);
+static_assert( std::ranges::borrowed_range<std::ranges::reverse_view<BorrowedView>>);
+static_assert(!std::ranges::borrowed_range<std::ranges::reverse_view<NonBorrowedView>>);

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

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-no-concepts
 // UNSUPPORTED: libcpp-has-no-incomplete-ranges
 
 // template<class T>
 //   inline constexpr bool enable_borrowed_range<take_view<T>> = enable_borrowed_range<T>;
 
 #include <ranges>
-#include <cassert>
 
-#include "test_iterators.h"
+#include "test_range.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::take_view<View>>);
-static_assert( std::ranges::enable_borrowed_range<std::ranges::take_view<BorrowableView>>);
+static_assert( std::ranges::borrowed_range<std::ranges::take_view<BorrowedView>>);
+static_assert(!std::ranges::borrowed_range<std::ranges::take_view<NonBorrowedView>>);

libcxx/test/std/ranges/range.factories/range.iota.view/borrowing.compile.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-no-concepts
 // UNSUPPORTED: libcpp-has-no-incomplete-ranges
 
 // template<class W, class Bound>
 //   inline constexpr bool enable_borrowed_range<iota_view<W, Bound>> = true;
 
 #include <ranges>
-#include <cassert>
-#include <concepts>
 
-#include "test_macros.h"
-#include "types.h"
-
-static_assert(std::ranges::enable_borrowed_range<std::ranges::iota_view<int, int>>);
-static_assert(std::ranges::enable_borrowed_range<std::ranges::iota_view<int, std::unreachable_sentinel_t>>);
-static_assert(std::ranges::enable_borrowed_range<std::ranges::iota_view<int, IntComparableWith<int>>>);
+static_assert(std::ranges::borrowed_range<std::ranges::iota_view<int, int>>);
+static_assert(std::ranges::borrowed_range<std::ranges::iota_view<int, std::unreachable_sentinel_t>>);
+static_assert(std::ranges::borrowed_range<std::ranges::iota_view<int*, int*>>);
+static_assert(std::ranges::borrowed_range<std::ranges::iota_view<int*, std::unreachable_sentinel_t>>);

libcxx/test/std/ranges/range.factories/range.single.view/borrowing.compile.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-no-concepts
 // UNSUPPORTED: libcpp-has-no-incomplete-ranges
 
-// class std::ranges::subrange;
+// single_view does not specialize enable_borrowed_range
 
 #include <ranges>
 
-#include "test_iterators.h"
+#include "test_range.h"
 
-namespace ranges = std::ranges;
-
-static_assert(ranges::borrowed_range<ranges::subrange<int*>>);
-static_assert(ranges::borrowed_range<ranges::subrange<int*, int const*>>);
-static_assert(ranges::borrowed_range<ranges::subrange<int*, sentinel_wrapper<int*>, ranges::subrange_kind::unsized>>);
+static_assert(!std::ranges::borrowed_range<std::ranges::single_view<int>>);
+static_assert(!std::ranges::borrowed_range<std::ranges::single_view<int*>>);
+static_assert(!std::ranges::borrowed_range<std::ranges::single_view<BorrowedView>>);
+static_assert(!std::ranges::borrowed_range<std::ranges::single_view<NonBorrowedView>>);

libcxx/test/std/ranges/range.utility/range.subrange/borrowing.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// template<class I, class S, subrange_kind K>
+//   inline constexpr bool enable_borrowed_range<subrange<I, S, K>> = true;
+
+#include <ranges>
+
+static_assert(std::ranges::borrowed_range<std::ranges::subrange<int*, const int*, std::ranges::subrange_kind::sized>>);
+static_assert(std::ranges::borrowed_range<std::ranges::subrange<int*, std::unreachable_sentinel_t, std::ranges::subrange_kind::sized>>);
+static_assert(std::ranges::borrowed_range<std::ranges::subrange<int*, std::unreachable_sentinel_t, std::ranges::subrange_kind::unsized>>);

libcxx/test/support/test_range.h

 requires std::input_or_output_iterator<I<int*> >
 struct test_view : std::ranges::view_base {
   I<int*> begin();
   I<int const*> begin() const;
   sentinel end();
   sentinel end() const;
 };
 
+struct BorrowedRange {
+  int *begin() const;
+  int *end() const;
+  BorrowedRange(BorrowedRange&&) = delete;
+};
+template<> inline constexpr bool std::ranges::enable_borrowed_range<BorrowedRange> = true;
+static_assert(!std::ranges::view<BorrowedRange>);
+static_assert(std::ranges::borrowed_range<BorrowedRange>);
+
+using BorrowedView = std::ranges::empty_view<int>;
+static_assert(std::ranges::view<BorrowedView>);
+static_assert(std::ranges::borrowed_range<BorrowedView>);
+
+using NonBorrowedView = std::ranges::single_view<int>;
+static_assert(std::ranges::view<NonBorrowedView>);
+static_assert(!std::ranges::borrowed_range<NonBorrowedView>);
+
 #endif // LIBCXX_TEST_SUPPORT_TEST_RANGE_H