[libcxx][ranges] Implement `ranges::borrowed_range`.

[cjdb]

LGTM overall. Please don't forget the conformance tests!

[Mordante]

Wasn't this already in the subrange patch?

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

64

Can you test with some standard library types, for example std:;string, std::vector, std::string_view, and std::span.

[zoecarver]

Adds range conformance tests.

[cjdb]

This also needs a subsumption test. Once that's in place, I'll review it and likely LGTM it!

[zoecarver]

Add subsumption test.

[cjdb]

LGTM!

[Mordante]

LGTM! Make sure it passes CI before committing.

[zoecarver]

Rebase.

libcxx/include/__ranges/concepts.h

 namespace ranges {
   // [range.range]
   template <class _Tp>
   concept range = requires(_Tp& __t) {
     ranges::begin(__t); // sometimes equality-preserving
     ranges::end(__t);
   };
 
+  template<class _Range>
+  concept borrowed_range = range<_Range> &&
+    (is_lvalue_reference_v<_Range> || enable_borrowed_range<remove_cvref_t<_Range>>);
+
   // `iterator_t` defined in <__ranges/access.h>
 
   template <range _Rp>
   using sentinel_t = decltype(ranges::end(declval<_Rp&>()));
 
   template <range _Rp>
   using range_difference_t = iter_difference_t<iterator_t<_Rp> >;
 

libcxx/test/std/containers/associative/map/range_concept_conformance.compile.pass.cpp

 namespace stdr = std::ranges;
 
 static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
 static_assert(stdr::common_range<range>);
 static_assert(stdr::bidirectional_range<range>);
 static_assert(!stdr::view<range>);
 static_assert(!stdr::random_access_range<range>);
 static_assert(stdr::sized_range<range>);
-static_assert(stdr::borrowed_range<range const>);
+static_assert(!stdr::borrowed_range<range>);
 
 static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
 static_assert(stdr::common_range<range const>);
 static_assert(stdr::bidirectional_range<range const>);
 static_assert(!stdr::view<range const>);
 static_assert(!stdr::random_access_range<range const>);
 static_assert(stdr::sized_range<range const>);
-static_assert(stdr::borrowed_range<range const>);
+static_assert(!stdr::borrowed_range<range const>);

libcxx/test/std/containers/associative/multimap/range_concept_conformance.compile.pass.cpp

 namespace stdr = std::ranges;
 
 static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
 static_assert(stdr::common_range<range>);
 static_assert(stdr::bidirectional_range<range>);
 static_assert(!stdr::view<range>);
 static_assert(!stdr::random_access_range<range>);
 static_assert(stdr::sized_range<range>);
+static_assert(!stdr::borrowed_range<range>);
 
 static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
 static_assert(stdr::common_range<range const>);
 static_assert(stdr::bidirectional_range<range const>);
 static_assert(!stdr::view<range const>);
 static_assert(!stdr::random_access_range<range const>);
 static_assert(stdr::sized_range<range const>);
+static_assert(!stdr::borrowed_range<range const>);

libcxx/test/std/containers/associative/multiset/range_concept_conformance.compile.pass.cpp

 namespace stdr = std::ranges;
 
 static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
 static_assert(stdr::common_range<range>);
 static_assert(stdr::bidirectional_range<range>);
 static_assert(!stdr::view<range>);
 static_assert(!stdr::random_access_range<range>);
 static_assert(stdr::sized_range<range>);
+static_assert(!stdr::borrowed_range<range>);
 
 static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
 static_assert(stdr::common_range<range const>);
 static_assert(stdr::bidirectional_range<range const>);
 static_assert(!stdr::view<range const>);
 static_assert(!stdr::random_access_range<range const>);
 static_assert(stdr::sized_range<range const>);
+static_assert(!stdr::borrowed_range<range const>);

libcxx/test/std/containers/associative/set/range_concept_conformance.compile.pass.cpp

 
 static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
 static_assert(stdr::bidirectional_range<range>);
 static_assert(!stdr::random_access_range<range>);
 static_assert(stdr::common_range<range>);
 static_assert(stdr::input_range<range>);
 static_assert(!stdr::view<range>);
 static_assert(stdr::sized_range<range>);
+static_assert(!stdr::borrowed_range<range>);
 
 static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
 static_assert(stdr::bidirectional_range<range const>);
 static_assert(!stdr::random_access_range<range const>);
 static_assert(stdr::common_range<range const>);
 static_assert(stdr::input_range<range>);
 static_assert(!stdr::view<range const>);
 static_assert(stdr::sized_range<range const>);
+static_assert(!stdr::borrowed_range<range const>);

libcxx/test/std/containers/sequences/array/range_concept_conformance.compile.pass.cpp

 using range = std::array<int, 10>;
 namespace stdr = std::ranges;
 
 static_assert(!stdr::view<range>);
 static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
 static_assert(stdr::common_range<range>);
 static_assert(stdr::random_access_range<range>);
 static_assert(stdr::sized_range<range>);
+static_assert(!stdr::borrowed_range<range>);
 
 static_assert(!stdr::view<range const>);
 static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
 static_assert(stdr::common_range<range const>);
 static_assert(stdr::random_access_range<range const>);
 static_assert(stdr::sized_range<range const>);
+static_assert(!stdr::borrowed_range<range const>);

libcxx/test/std/containers/sequences/deque/range_concept_conformance.compile.pass.cpp

 using range = std::deque<int>;
 namespace stdr = std::ranges;
 
 static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
 static_assert(stdr::common_range<range>);
 static_assert(stdr::random_access_range<range>);
 static_assert(!stdr::view<range>);
 static_assert(stdr::sized_range<range>);
+static_assert(!stdr::borrowed_range<range>);
 
 static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
 static_assert(stdr::common_range<range const>);
 static_assert(stdr::random_access_range<range const>);
 static_assert(!stdr::view<range const>);
 static_assert(stdr::sized_range<range const>);
+static_assert(!stdr::borrowed_range<range const>);

libcxx/test/std/containers/sequences/forwardlist/range_concept_conformance.compile.pass.cpp

 namespace stdr = std::ranges;
 
 static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
 static_assert(stdr::common_range<range>);
 static_assert(stdr::forward_range<range>);
 static_assert(!stdr::bidirectional_range<range>);
 static_assert(!stdr::view<range>);
 static_assert(!stdr::sized_range<range>);
+static_assert(!stdr::borrowed_range<range>);
 
 static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
 static_assert(stdr::common_range<range const>);
 static_assert(stdr::forward_range<range const>);
 static_assert(!stdr::bidirectional_range<range const>);
 static_assert(!stdr::view<range const>);
 static_assert(!stdr::sized_range<range const>);
+static_assert(!stdr::borrowed_range<range const>);

libcxx/test/std/containers/sequences/list/range_concept_conformance.compile.pass.cpp

 namespace stdr = std::ranges;
 
 static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
 static_assert(stdr::common_range<range>);
 static_assert(stdr::bidirectional_range<range>);
 static_assert(!stdr::view<range>);
 static_assert(!stdr::random_access_range<range>);
 static_assert(stdr::sized_range<range>);
+static_assert(!stdr::borrowed_range<range>);
 
 static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
 static_assert(stdr::common_range<range const>);
 static_assert(stdr::bidirectional_range<range const>);
 static_assert(!stdr::view<range const>);
 static_assert(!stdr::random_access_range<range const>);
 static_assert(stdr::sized_range<range const>);
+static_assert(!stdr::borrowed_range<range const>);

libcxx/test/std/containers/sequences/vector.bool/range_concept_conformance.compile.pass.cpp

 using range = std::vector<bool>;
 namespace stdr = std::ranges;
 
 static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
 static_assert(stdr::common_range<range>);
 static_assert(stdr::random_access_range<range>);
 static_assert(!stdr::view<range>);
 static_assert(stdr::sized_range<range>);
+static_assert(!stdr::borrowed_range<range>);
 
 static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
 static_assert(stdr::common_range<range const>);
 static_assert(stdr::random_access_range<range const>);
 static_assert(!stdr::view<range const>);
 static_assert(stdr::sized_range<range const>);
+static_assert(!stdr::borrowed_range<range const>);

libcxx/test/std/containers/sequences/vector/range_concept_conformance.compile.pass.cpp

 using range = std::vector<int>;
 namespace stdr = std::ranges;
 
 static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
 static_assert(stdr::common_range<range>);
 static_assert(stdr::random_access_range<range>);
 static_assert(!stdr::view<range>);
 static_assert(stdr::sized_range<range>);
+static_assert(!stdr::borrowed_range<range>);
 
 static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
 static_assert(stdr::common_range<range const>);
 static_assert(stdr::random_access_range<range const>);
 static_assert(!stdr::view<range const>);
 static_assert(stdr::sized_range<range const>);
+static_assert(!stdr::borrowed_range<range const>);

libcxx/test/std/containers/unord/unord.map/range_concept_conformance.compile.pass.cpp

 namespace stdr = std::ranges;
 
 static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
 static_assert(stdr::common_range<range>);
 static_assert(stdr::forward_range<range>);
 static_assert(!stdr::bidirectional_range<range>);
 static_assert(!stdr::view<range>);
 static_assert(stdr::sized_range<range>);
+static_assert(!stdr::borrowed_range<range>);
 
 static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
 static_assert(stdr::common_range<range const>);
 static_assert(stdr::forward_range<range const>);
 static_assert(!stdr::bidirectional_range<range const>);
 static_assert(!stdr::view<range const>);
 static_assert(stdr::sized_range<range const>);
+static_assert(!stdr::borrowed_range<range const>);

libcxx/test/std/containers/unord/unord.multimap/range_concept_conformance.compile.pass.cpp

 namespace stdr = std::ranges;
 
 static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
 static_assert(stdr::common_range<range>);
 static_assert(stdr::forward_range<range>);
 static_assert(!stdr::bidirectional_range<range>);
 static_assert(!stdr::view<range>);
 static_assert(stdr::sized_range<range>);
+static_assert(!stdr::borrowed_range<range>);
 
 static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
 static_assert(stdr::common_range<range const>);
 static_assert(stdr::forward_range<range const>);
 static_assert(!stdr::bidirectional_range<range const>);
 static_assert(!stdr::view<range const>);
 static_assert(stdr::sized_range<range const>);
+static_assert(!stdr::borrowed_range<range const>);

libcxx/test/std/containers/unord/unord.multiset/range_concept_conformance.compile.pass.cpp

 namespace stdr = std::ranges;
 
 static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
 static_assert(stdr::common_range<range>);
 static_assert(stdr::forward_range<range>);
 static_assert(!stdr::bidirectional_range<range>);
 static_assert(!stdr::view<range>);
 static_assert(stdr::sized_range<range>);
+static_assert(!stdr::borrowed_range<range>);
 
 static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
 static_assert(stdr::common_range<range const>);
 static_assert(stdr::forward_range<range const>);
 static_assert(!stdr::bidirectional_range<range const>);
 static_assert(!stdr::view<range const>);
 static_assert(stdr::sized_range<range const>);
+static_assert(!stdr::borrowed_range<range const>);

libcxx/test/std/containers/unord/unord.set/range_concept_conformance.compile.pass.cpp

 namespace stdr = std::ranges;
 
 static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
 static_assert(stdr::common_range<range>);
 static_assert(stdr::forward_range<range>);
 static_assert(!stdr::bidirectional_range<range>);
 static_assert(!stdr::view<range>);
 static_assert(stdr::sized_range<range>);
+static_assert(!stdr::borrowed_range<range>);
 
 static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
 static_assert(stdr::common_range<range const>);
 static_assert(stdr::forward_range<range const>);
 static_assert(!stdr::bidirectional_range<range const>);
 static_assert(!stdr::view<range const>);
 static_assert(stdr::sized_range<range const>);
+static_assert(!stdr::borrowed_range<range const>);

libcxx/test/std/containers/views/range_concept_conformance.compile.pass.cpp

 using range = std::span<int>;
 namespace stdr = std::ranges;
 
 static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
 static_assert(stdr::common_range<range>);
 static_assert(stdr::random_access_range<range>);
 static_assert(!stdr::view<range>);
 static_assert(stdr::sized_range<range>);
+static_assert(stdr::borrowed_range<range>);
 
 static_assert(std::same_as<stdr::iterator_t<range const>, range::iterator>);
 static_assert(stdr::common_range<range const>);
 static_assert(stdr::random_access_range<range const>);
 static_assert(!stdr::view<range const>);
 static_assert(stdr::sized_range<range const>);
+static_assert(stdr::borrowed_range<range const>);

libcxx/test/std/input.output/filesystems/class.directory_iterator/range_concept_conformance.compile.pass.cpp

 
 namespace stdr = std::ranges;
 
 static_assert(std::same_as<stdr::iterator_t<fs::directory_iterator>, fs::directory_iterator>);
 static_assert(stdr::common_range<fs::directory_iterator>);
 static_assert(stdr::input_range<fs::directory_iterator>);
 static_assert(!stdr::view<fs::directory_iterator>);
 static_assert(!stdr::sized_range<fs::directory_iterator>);
+static_assert(!stdr::borrowed_range<fs::directory_iterator>);
 
 static_assert(std::same_as<stdr::iterator_t<fs::directory_iterator const>, fs::directory_iterator>);
 static_assert(stdr::common_range<fs::directory_iterator const>);
 static_assert(stdr::input_range<fs::directory_iterator const>);
 static_assert(!stdr::view<fs::directory_iterator const>);
 static_assert(!stdr::sized_range<fs::directory_iterator const>);
+static_assert(!stdr::borrowed_range<fs::directory_iterator const>);
 
 static_assert(std::same_as<stdr::iterator_t<fs::recursive_directory_iterator>, fs::recursive_directory_iterator>);
 static_assert(stdr::common_range<fs::recursive_directory_iterator>);
 static_assert(stdr::input_range<fs::recursive_directory_iterator>);
 static_assert(!stdr::view<fs::recursive_directory_iterator>);
 static_assert(!stdr::sized_range<fs::recursive_directory_iterator>);
+static_assert(!stdr::borrowed_range<fs::recursive_directory_iterator>);
 
 static_assert(std::same_as<stdr::iterator_t<fs::recursive_directory_iterator const>, fs::recursive_directory_iterator>);
 static_assert(stdr::common_range<fs::recursive_directory_iterator const>);
 static_assert(stdr::input_range<fs::recursive_directory_iterator const>);
 static_assert(!stdr::view<fs::recursive_directory_iterator const>);
 static_assert(!stdr::sized_range<fs::recursive_directory_iterator const>);
+static_assert(!stdr::borrowed_range<fs::recursive_directory_iterator const>);

libcxx/test/std/input.output/filesystems/class.path/range_concept_conformance.compile.pass.cpp

 namespace stdr = std::ranges;
 
 static_assert(std::same_as<stdr::iterator_t<fs::path>, fs::path::iterator>);
 static_assert(stdr::common_range<fs::path>);
 static_assert(stdr::bidirectional_range<fs::path>);
 static_assert(!stdr::view<fs::path>);
 static_assert(!stdr::random_access_range<fs::path>);
 static_assert(!stdr::sized_range<fs::path>);
+static_assert(!stdr::borrowed_range<fs::path>);
 
 static_assert(std::same_as<stdr::iterator_t<fs::path const>, fs::path::const_iterator>);
 static_assert(stdr::common_range<fs::path const>);
 static_assert(stdr::bidirectional_range<fs::path const>);
 static_assert(!stdr::view<fs::path const>);
 static_assert(!stdr::random_access_range<fs::path const>);
 static_assert(!stdr::sized_range<fs::path const>);
+static_assert(!stdr::borrowed_range<fs::path const>);

libcxx/test/std/ranges/range.range/borrowed_range.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: gcc-10
+
+// template<class T>
+// concept borrowed_range;
+
+#include <ranges>
+
+struct NotRange {
+  int begin() const;
+  int end() const;
+};
+
+struct Range {
+  int *begin();
+  int *end();
+};
+
+struct ConstRange {
+  int *begin() const;
+  int *end() const;
+};
+
+struct BorrowedRange {
+  int *begin() const;
+  int *end() const;
+};
+
+template<>
+inline constexpr bool std::ranges::enable_borrowed_range<BorrowedRange> = true;
+
+static_assert(!std::ranges::borrowed_range<NotRange>);
+static_assert(!std::ranges::borrowed_range<NotRange&>);
+static_assert(!std::ranges::borrowed_range<const NotRange>);
+static_assert(!std::ranges::borrowed_range<const NotRange&>);
+static_assert(!std::ranges::borrowed_range<NotRange&&>);
+
+static_assert(!std::ranges::borrowed_range<Range>);
+static_assert( std::ranges::borrowed_range<Range&>);
+static_assert(!std::ranges::borrowed_range<const Range>);
+static_assert(!std::ranges::borrowed_range<const Range&>);
+static_assert(!std::ranges::borrowed_range<Range&&>);
+
+static_assert(!std::ranges::borrowed_range<ConstRange>);
+static_assert( std::ranges::borrowed_range<ConstRange&>);
+static_assert(!std::ranges::borrowed_range<const ConstRange>);
+static_assert( std::ranges::borrowed_range<const ConstRange&>);
+static_assert(!std::ranges::borrowed_range<ConstRange&&>);
+
+static_assert( std::ranges::borrowed_range<BorrowedRange>);
+static_assert( std::ranges::borrowed_range<BorrowedRange&>);
+static_assert( std::ranges::borrowed_range<const BorrowedRange>);
+static_assert( std::ranges::borrowed_range<const BorrowedRange&>);
+static_assert( std::ranges::borrowed_range<BorrowedRange&&>);

libcxx/test/std/re/re.results/range_concept_conformance.compile.pass.cpp

 
 namespace stdr = std::ranges;
 
 static_assert(std::same_as<stdr::iterator_t<std::cmatch>, std::cmatch::iterator>);
 static_assert(stdr::common_range<std::cmatch>);
 static_assert(stdr::random_access_range<std::cmatch>);
 static_assert(!stdr::view<std::cmatch>);
 static_assert(stdr::sized_range<std::cmatch>);
+static_assert(!stdr::borrowed_range<std::cmatch>);
 
 static_assert(std::same_as<stdr::iterator_t<std::cmatch const>, std::cmatch::const_iterator>);
 static_assert(stdr::common_range<std::cmatch const>);
 static_assert(stdr::random_access_range<std::cmatch const>);
 static_assert(!stdr::view<std::cmatch const>);
 static_assert(stdr::sized_range<std::cmatch const>);
+static_assert(!stdr::borrowed_range<std::cmatch const>);

libcxx/test/std/strings/basic.string/range_concept_conformance.compile.pass.cpp

 
 namespace stdr = std::ranges;
 
 static_assert(std::same_as<stdr::iterator_t<std::string>, std::string::iterator>);
 static_assert(stdr::common_range<std::string>);
 static_assert(stdr::random_access_range<std::string>);
 static_assert(!stdr::view<std::string>);
 static_assert(stdr::sized_range<std::string>);
+static_assert(!stdr::borrowed_range<std::string>);
 
 static_assert(std::same_as<stdr::iterator_t<std::string const>, std::string::const_iterator>);
 static_assert(stdr::common_range<std::string const>);
 static_assert(stdr::random_access_range<std::string const>);
 static_assert(!stdr::view<std::string const>);
 static_assert(stdr::sized_range<std::string const>);
+static_assert(!stdr::borrowed_range<std::string const>);

libcxx/test/std/strings/string.view/range_concept_conformance.compile.pass.cpp

 
 namespace stdr = std::ranges;
 
 static_assert(std::same_as<stdr::iterator_t<std::string_view>, std::string_view::iterator>);
 static_assert(stdr::common_range<std::string_view>);
 static_assert(stdr::random_access_range<std::string_view>);
 static_assert(!stdr::view<std::string_view>);
 static_assert(stdr::sized_range<std::string_view>);
+static_assert(stdr::borrowed_range<std::string_view>);
 
 static_assert(std::same_as<stdr::iterator_t<std::string_view const>, std::string_view::const_iterator>);
 static_assert(stdr::common_range<std::string_view const>);
 static_assert(stdr::random_access_range<std::string_view const>);
 static_assert(!stdr::view<std::string_view const>);
 static_assert(stdr::sized_range<std::string_view const>);
+static_assert(stdr::borrowed_range<std::string_view const>);