This is an archive of the discontinued LLVM Phabricator instance.

Differential D118164

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

Authored by • Quuxplusone on Jan 25 2022, 10:03 AM.

Details

Reviewers
ldionne
Mordante
philnik
var-const
Group Reviewers
Restricted Project
Commits
rG9021f3682c97: [libc++] [ranges] ref_view and empty_view are borrowed ranges. Normalize…
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.

Diff Detail

Event Timeline

• Quuxplusone requested review of this revision.Jan 25 2022, 10:03 AM
• Quuxplusone created this revision.
Herald added a reviewer: Restricted Project. · View Herald TranscriptJan 25 2022, 10:03 AM
Herald added a subscriber: libcxx-commits. · View Herald Transcript
Harbormaster completed remote builds in B145548: Diff 402954.Jan 25 2022, 12:08 PM
ldionne requested changes to this revision.Jan 25 2022, 12:19 PM

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
This revision now requires changes to proceed.Jan 25 2022, 12:19 PM
• Quuxplusone marked an inline comment as done.Jan 25 2022, 1:19 PM
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 updated this revision to Diff 403099.Jan 25 2022, 6:24 PM

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

Harbormaster completed remote builds in B145649: Diff 403099.Jan 25 2022, 8:07 PM
ldionne accepted this revision.Jan 27 2022, 8:32 AM
This revision is now accepted and ready to land.Jan 27 2022, 8:32 AM
This revision was landed with ongoing or failed builds.Jan 27 2022, 11:22 AM
Closed by commit rG9021f3682c97: [libc++] [ranges] ref_view and empty_view are borrowed ranges. Normalize… (authored by • arthur.j.odwyer). · Explain Why
This revision was automatically updated to reflect the committed changes.
• arthur.j.odwyer added a commit: rG9021f3682c97: [libc++] [ranges] ref_view and empty_view are borrowed ranges. Normalize….
• Quuxplusone mentioned this in D117817: [libc++][ranges] Implement ranges::mismatch.Jan 31 2022, 11:17 AM

Revision Contents

PathSize
libcxx/
include/
__ranges/
4 lines
3 lines
test/
std/
ranges/
range.adaptors/
range.all/
range.owning.view/
18 lines
range.all/
range.ref.view/
range.common.view/
22 lines
range.reverse/
24 lines
range.take/
24 lines
range.adaptors/
range.all/
range.ref.view/
range.utility/
range.subrange/
borrowing.compile.pass.cpp
enable_borrowed_range.compile.pass.cpp
13 lines
range.adaptors/
range.empty/
range.utility/
range.subrange/
borrowing.compile.pass.cpp
enable_borrowed_range.compile.pass.cpp
14 lines
range.factories/
range.iota.view/
12 lines
range.factories/
range.single.view/
range.utility/
range.subrange/
borrowing.compile.pass.cpp
enable_borrowed_range.compile.pass.cpp
13 lines
range.utility/
range.subrange/
20 lines
support/
17 lines

Diff 403733

libcxx/include/__ranges/empty_view.h

// -*- C++ -*- // -*- C++ -*-
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef _LIBCPP___RANGES_EMPTY_VIEW_H #ifndef _LIBCPP___RANGES_EMPTY_VIEW_H
#define _LIBCPP___RANGES_EMPTY_VIEW_H #define _LIBCPP___RANGES_EMPTY_VIEW_H
#include <__config> #include <__config>
#include <__ranges/enable_borrowed_range.h>
#include <__ranges/view_interface.h> #include <__ranges/view_interface.h>
#include <type_traits> #include <type_traits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header #pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if !defined(_LIBCPP_HAS_NO_RANGES) #if !defined(_LIBCPP_HAS_NO_RANGES)
namespace ranges { namespace ranges {
template<class _Tp> template<class _Tp>
requires is_object_v<_Tp> requires is_object_v<_Tp>
class empty_view : public view_interface<empty_view<_Tp>> { class empty_view : public view_interface<empty_view<_Tp>> {
public: public:
_LIBCPP_HIDE_FROM_ABI static constexpr _Tp* begin() noexcept { return nullptr; } _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* end() noexcept { return nullptr; }
_LIBCPP_HIDE_FROM_ABI static constexpr _Tp* data() 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 size_t size() noexcept { return 0; }
_LIBCPP_HIDE_FROM_ABI static constexpr bool empty() noexcept { return true; } _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 } // namespace ranges
#endif // !defined(_LIBCPP_HAS_NO_RANGES) #endif // !defined(_LIBCPP_HAS_NO_RANGES)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___RANGES_EMPTY_VIEW_H #endif // _LIBCPP___RANGES_EMPTY_VIEW_H

libcxx/include/__ranges/ref_view.h

Show All 12 Lines
#include <__iterator/concepts.h> #include <__iterator/concepts.h>
#include <__iterator/incrementable_traits.h> #include <__iterator/incrementable_traits.h>
#include <__iterator/iterator_traits.h> #include <__iterator/iterator_traits.h>
#include <__memory/addressof.h> #include <__memory/addressof.h>
#include <__ranges/access.h> #include <__ranges/access.h>
#include <__ranges/concepts.h> #include <__ranges/concepts.h>
#include <__ranges/data.h> #include <__ranges/data.h>
#include <__ranges/empty.h> #include <__ranges/empty.h>
#include <__ranges/enable_borrowed_range.h>
#include <__ranges/size.h> #include <__ranges/size.h>
#include <__ranges/view_interface.h> #include <__ranges/view_interface.h>
#include <__utility/forward.h> #include <__utility/forward.h>
#include <concepts> #include <concepts>
#include <type_traits> #include <type_traits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header #pragma GCC system_header
Show All 40 Linespublic:
constexpr auto data() const constexpr auto data() const
requires contiguous_range<_Range> requires contiguous_range<_Range>
{ return ranges::data(*__range_); } { return ranges::data(*__range_); }
}; };
template<class _Range> template<class _Range>
ref_view(_Range&) -> ref_view<_Range>; ref_view(_Range&) -> ref_view<_Range>;
template<class _Tp>
inline constexpr bool enable_borrowed_range<ref_view<_Tp>> = true;
} // namespace ranges } // namespace ranges
#endif // !defined(_LIBCPP_HAS_NO_RANGES) #endif // !defined(_LIBCPP_HAS_NO_RANGES)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___RANGES_REF_VIEW_H #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. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03, c++11, c++14, c++17 // UNSUPPORTED: c++03, c++11, c++14, c++17
// UNSUPPORTED: libcpp-no-concepts // UNSUPPORTED: libcpp-no-concepts
// UNSUPPORTED: libcpp-has-no-incomplete-ranges // UNSUPPORTED: libcpp-has-no-incomplete-ranges
// template<class T> // template<class T>
// inline constexpr bool enable_borrowed_range<owning_view<T>> = enable_borrowed_range<T>; // inline constexpr bool enable_borrowed_range<owning_view<T>> = enable_borrowed_range<T>;
#include <ranges> #include <ranges>
#include <cassert>
struct Range { #include "test_range.h"
int *begin() const;
int *end() const;
};
struct BorrowableRange { static_assert( std::ranges::borrowed_range<std::ranges::owning_view<BorrowedView>>);
int *begin() const; static_assert(!std::ranges::borrowed_range<std::ranges::owning_view<NonBorrowedView>>);
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>>);

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

  • This file was copied from libcxx/test/std/ranges/range.utility/range.subrange/enable_borrowed_range.compile.pass.cpp.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03, c++11, c++14, c++17 // UNSUPPORTED: c++03, c++11, c++14, c++17
// UNSUPPORTED: libcpp-no-concepts // UNSUPPORTED: libcpp-no-concepts
// UNSUPPORTED: libcpp-has-no-incomplete-ranges // 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 <ranges>
#include "test_iterators.h" #include "test_range.h"
namespace ranges = std::ranges; static_assert(std::ranges::borrowed_range<std::ranges::ref_view<BorrowedRange>>);
static_assert(std::ranges::borrowed_range<std::ranges::ref_view<BorrowedView>>);
static_assert(ranges::borrowed_range<ranges::subrange<int*>>); static_assert(std::ranges::borrowed_range<std::ranges::ref_view<NonBorrowedView>>);
ldionneUnsubmitted
Done
ReplyInline Actions
#include <ranges>
- static_assert( std::ranges::borrowed_range<std::ranges::ref_view<std::ranges::single_view<int>>>);
- static_assert( std::ranges::borrowed_range<std::ranges::ref_view<std::ranges::empty_view<int>>>);
+ static_assert(std::ranges::borrowed_range<std::ranges::ref_view<std::ranges::single_view<int>>>);
+ static_assert(std::ranges::borrowed_range<std::ranges::ref_view<std::ranges::empty_view<int>>>);
ldionne:
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>>);

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

  • This file was moved from libcxx/test/std/ranges/range.adaptors/range.ref.view.pass.cpp.
The contents of this file were not changed.

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

  • This file was copied from libcxx/test/std/ranges/range.utility/range.subrange/enable_borrowed_range.compile.pass.cpp.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03, c++11, c++14, c++17 // UNSUPPORTED: c++03, c++11, c++14, c++17
// UNSUPPORTED: libcpp-no-concepts // UNSUPPORTED: libcpp-no-concepts
// UNSUPPORTED: libcpp-has-no-incomplete-ranges // 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 <ranges>
#include "test_iterators.h" #include "test_range.h"
namespace ranges = std::ranges; static_assert(std::ranges::borrowed_range<std::ranges::empty_view<int>>);
static_assert(std::ranges::borrowed_range<std::ranges::empty_view<int*>>);
static_assert(ranges::borrowed_range<ranges::subrange<int*>>); static_assert(std::ranges::borrowed_range<std::ranges::empty_view<BorrowedView>>);
static_assert(ranges::borrowed_range<ranges::subrange<int*, int const*>>); static_assert(std::ranges::borrowed_range<std::ranges::empty_view<NonBorrowedView>>);
static_assert(ranges::borrowed_range<ranges::subrange<int*, sentinel_wrapper<int*>, ranges::subrange_kind::unsized>>);

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

  • This file was moved to libcxx/test/std/ranges/range.adaptors/range.all/range.ref.view/range.ref.view.pass.cpp.

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

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

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

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

  • This file was moved from libcxx/test/std/ranges/range.utility/range.subrange/enable_borrowed_range.compile.pass.cpp.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03, c++11, c++14, c++17 // UNSUPPORTED: c++03, c++11, c++14, c++17
// UNSUPPORTED: libcpp-no-concepts // UNSUPPORTED: libcpp-no-concepts
// UNSUPPORTED: libcpp-has-no-incomplete-ranges // UNSUPPORTED: libcpp-has-no-incomplete-ranges
// class std::ranges::subrange; // single_view does not specialize enable_borrowed_range
#include <ranges> #include <ranges>
#include "test_iterators.h" #include "test_range.h"
namespace ranges = std::ranges; static_assert(!std::ranges::borrowed_range<std::ranges::single_view<int>>);
static_assert(!std::ranges::borrowed_range<std::ranges::single_view<int*>>);
static_assert(ranges::borrowed_range<ranges::subrange<int*>>); static_assert(!std::ranges::borrowed_range<std::ranges::single_view<BorrowedView>>);
static_assert(ranges::borrowed_range<ranges::subrange<int*, int const*>>); static_assert(!std::ranges::borrowed_range<std::ranges::single_view<NonBorrowedView>>);
ldionneUnsubmitted
Done
ReplyInline Actions
#include <ranges>
- static_assert( std::ranges::borrowed_range<std::ranges::ref_view<std::ranges::single_view<int>>>);
- static_assert( std::ranges::borrowed_range<std::ranges::ref_view<std::ranges::empty_view<int>>>);
+ static_assert(std::ranges::borrowed_range<std::ranges::ref_view<std::ranges::single_view<int>>>);
+ static_assert(std::ranges::borrowed_range<std::ranges::ref_view<std::ranges::empty_view<int>>>);
ldionne:
static_assert(ranges::borrowed_range<ranges::subrange<int*, sentinel_wrapper<int*>, ranges::subrange_kind::unsized>>);

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

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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/std/ranges/range.utility/range.subrange/enable_borrowed_range.compile.pass.cpp

  • This file was deleted after being copied to libcxx/test/std/ranges/range.adaptors/range.all/range.ref.view/borrowing.compile.pass.cpp, libcxx/test/std/ranges/range.adaptors/range.empty/borrowing.compile.pass.cpp, libcxx/test/std/ranges/range.factories/range.single.view/borrowing.compile.pass.cpp.

libcxx/test/support/test_range.h

Show First 20 Lines • Show All 56 Lines • ▼ Show 20 Lines
requires std::input_or_output_iterator<I<int*> > requires std::input_or_output_iterator<I<int*> >
struct test_view : std::ranges::view_base { struct test_view : std::ranges::view_base {
I<int*> begin(); I<int*> begin();
I<int const*> begin() const; I<int const*> begin() const;
sentinel end(); sentinel end();
sentinel end() const; 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 #endif // LIBCXX_TEST_SUPPORT_TEST_RANGE_H