[libcxx][test] `movable` non-`view` rvalues become`viewable_range`s after P2415

[CaseyCarter]

Summary

Update many test cases appropriately, guarding with #ifdef _LIBCPP_VERSION since libc++ doesn't yet implement P2415.

[• Quuxplusone]

This strikes me as the wrong fix; the right fix would be for someone to implement P2415R2 in libc++. I volunteer.
However, @CaseyCarter, could you tell me whether it is correct to implement P2415R2 in C++20 or only in C++23? I could totally believe it's one of these additions to C++20 that happened in Q4 of 2021, but I'm not sure where to look to find that out officially.

[ldionne]

@CaseyCarter I suggest abandoning this in favour of https://reviews.llvm.org/D116894, which we will ship soon.

[CaseyCarter]

Superseded by D116894.

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

 
 // map
 
 #include <map>
 
 #include <concepts>
 #include <ranges>
 
+#include "test_macros.h"
+
 using range = std::map<int, int>;
 
 
 static_assert(std::same_as<std::ranges::iterator_t<range>, range::iterator>);
 static_assert(std::ranges::common_range<range>);
 static_assert(std::ranges::bidirectional_range<range>);
 static_assert(!std::ranges::view<range>);
 static_assert(!std::ranges::random_access_range<range>);
 static_assert(std::ranges::sized_range<range>);
 static_assert(!std::ranges::borrowed_range<range>);
+#ifdef _LIBCPP_VERSION
 static_assert(!std::ranges::viewable_range<range>);
+#else // ^^^ pre-P2415 / post-P2415
+static_assert(std::ranges::viewable_range<range>);
+#endif
 
 static_assert(std::same_as<std::ranges::iterator_t<range const>, range::const_iterator>);
 static_assert(std::ranges::common_range<range const>);
 static_assert(std::ranges::bidirectional_range<range const>);
 static_assert(!std::ranges::view<range const>);
 static_assert(!std::ranges::random_access_range<range const>);
 static_assert(std::ranges::sized_range<range const>);
 static_assert(!std::ranges::borrowed_range<range const>);
 static_assert(!std::ranges::viewable_range<range const>);

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

 
 // multimap
 
 #include <map>
 
 #include <concepts>
 #include <ranges>
 
+#include "test_macros.h"
+
 using range = std::multimap<int, int>;
 
 
 static_assert(std::same_as<std::ranges::iterator_t<range>, range::iterator>);
 static_assert(std::ranges::common_range<range>);
 static_assert(std::ranges::bidirectional_range<range>);
 static_assert(!std::ranges::view<range>);
 static_assert(!std::ranges::random_access_range<range>);
 static_assert(std::ranges::sized_range<range>);
 static_assert(!std::ranges::borrowed_range<range>);
+#ifdef _LIBCPP_VERSION
 static_assert(!std::ranges::viewable_range<range>);
+#else // ^^^ pre-P2415 / post-P2415
+static_assert(std::ranges::viewable_range<range>);
+#endif
 
 static_assert(std::same_as<std::ranges::iterator_t<range const>, range::const_iterator>);
 static_assert(std::ranges::common_range<range const>);
 static_assert(std::ranges::bidirectional_range<range const>);
 static_assert(!std::ranges::view<range const>);
 static_assert(!std::ranges::random_access_range<range const>);
 static_assert(std::ranges::sized_range<range const>);
 static_assert(!std::ranges::borrowed_range<range const>);
 static_assert(!std::ranges::viewable_range<range const>);

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

 
 // multiset
 
 #include <set>
 
 #include <concepts>
 #include <ranges>
 
+#include "test_macros.h"
+
 using range = std::multiset<int>;
 
 static_assert(std::same_as<std::ranges::iterator_t<range>, range::iterator>);
 static_assert(std::ranges::common_range<range>);
 static_assert(std::ranges::bidirectional_range<range>);
 static_assert(!std::ranges::view<range>);
 static_assert(!std::ranges::random_access_range<range>);
 static_assert(std::ranges::sized_range<range>);
 static_assert(!std::ranges::borrowed_range<range>);
+#ifdef _LIBCPP_VERSION
 static_assert(!std::ranges::viewable_range<range>);
+#else // ^^^ pre-P2415 / post-P2415
+static_assert(std::ranges::viewable_range<range>);
+#endif
 
 static_assert(std::same_as<std::ranges::iterator_t<range const>, range::const_iterator>);
 static_assert(std::ranges::common_range<range const>);
 static_assert(std::ranges::bidirectional_range<range const>);
 static_assert(!std::ranges::view<range const>);
 static_assert(!std::ranges::random_access_range<range const>);
 static_assert(std::ranges::sized_range<range const>);
 static_assert(!std::ranges::borrowed_range<range const>);
 static_assert(!std::ranges::viewable_range<range const>);

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

 
 // set
 
 #include <set>
 
 #include <concepts>
 #include <ranges>
 
+#include "test_macros.h"
+
 using range = std::set<int>;
 
 
 static_assert(std::same_as<std::ranges::iterator_t<range>, range::iterator>);
 static_assert(std::ranges::bidirectional_range<range>);
 static_assert(!std::ranges::random_access_range<range>);
 static_assert(std::ranges::common_range<range>);
 static_assert(std::ranges::input_range<range>);
 static_assert(!std::ranges::view<range>);
 static_assert(std::ranges::sized_range<range>);
 static_assert(!std::ranges::borrowed_range<range>);
+#ifdef _LIBCPP_VERSION
 static_assert(!std::ranges::viewable_range<range>);
+#else // ^^^ pre-P2415 / post-P2415
+static_assert(std::ranges::viewable_range<range>);
+#endif
 
 static_assert(std::same_as<std::ranges::iterator_t<range const>, range::const_iterator>);
 static_assert(std::ranges::bidirectional_range<range const>);
 static_assert(!std::ranges::random_access_range<range const>);
 static_assert(std::ranges::common_range<range const>);
 static_assert(std::ranges::input_range<range>);
 static_assert(!std::ranges::view<range const>);
 static_assert(std::ranges::sized_range<range const>);
 static_assert(!std::ranges::borrowed_range<range const>);
 static_assert(!std::ranges::viewable_range<range const>);

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

 
 // array
 
 #include <array>
 
 #include <concepts>
 #include <ranges>
 
+#include "test_macros.h"
+
 using range = std::array<int, 10>;
 
 
 static_assert(!std::ranges::view<range>);
 static_assert(std::same_as<std::ranges::iterator_t<range>, range::iterator>);
 static_assert(std::ranges::common_range<range>);
 static_assert(std::ranges::random_access_range<range>);
 static_assert(std::ranges::contiguous_range<range>);
 static_assert(std::ranges::sized_range<range>);
 static_assert(!std::ranges::borrowed_range<range>);
+#ifdef _LIBCPP_VERSION
 static_assert(!std::ranges::viewable_range<range>);
+#else // ^^^ pre-P2415 / post-P2415
+static_assert(std::ranges::viewable_range<range>);
+#endif
 
 static_assert(!std::ranges::view<range const>);
 static_assert(std::same_as<std::ranges::iterator_t<range const>, range::const_iterator>);
 static_assert(std::ranges::common_range<range const>);
 static_assert(std::ranges::random_access_range<range const>);
 static_assert(std::ranges::contiguous_range<range const>);
 static_assert(std::ranges::sized_range<range const>);
 static_assert(!std::ranges::borrowed_range<range const>);
 static_assert(!std::ranges::viewable_range<range const>);

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

 
 // deque
 
 #include <deque>
 
 #include <concepts>
 #include <ranges>
 
+#include "test_macros.h"
+
 using range = std::deque<int>;
 
 
 static_assert(std::same_as<std::ranges::iterator_t<range>, range::iterator>);
 static_assert(std::ranges::common_range<range>);
 static_assert(std::ranges::random_access_range<range>);
 static_assert(!std::ranges::contiguous_range<range>);
 static_assert(!std::ranges::view<range>);
 static_assert(std::ranges::sized_range<range>);
 static_assert(!std::ranges::borrowed_range<range>);
+#ifdef _LIBCPP_VERSION
 static_assert(!std::ranges::viewable_range<range>);
+#else // ^^^ pre-P2415 / post-P2415
+static_assert(std::ranges::viewable_range<range>);
+#endif
 
 static_assert(std::same_as<std::ranges::iterator_t<range const>, range::const_iterator>);
 static_assert(std::ranges::common_range<range const>);
 static_assert(std::ranges::random_access_range<range const>);
 static_assert(!std::ranges::contiguous_range<range const>);
 static_assert(!std::ranges::view<range const>);
 static_assert(std::ranges::sized_range<range const>);
 static_assert(!std::ranges::borrowed_range<range const>);
 static_assert(!std::ranges::viewable_range<range const>);

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

 
 // forward_list
 
 #include <forward_list>
 
 #include <concepts>
 #include <ranges>
 
+#include "test_macros.h"
+
 using range = std::forward_list<int>;
 
 
 static_assert(std::same_as<std::ranges::iterator_t<range>, range::iterator>);
 static_assert(std::ranges::common_range<range>);
 static_assert(std::ranges::forward_range<range>);
 static_assert(!std::ranges::bidirectional_range<range>);
 static_assert(!std::ranges::view<range>);
 static_assert(!std::ranges::sized_range<range>);
 static_assert(!std::ranges::borrowed_range<range>);
+#ifdef _LIBCPP_VERSION
 static_assert(!std::ranges::viewable_range<range>);
+#else // ^^^ pre-P2415 / post-P2415
+static_assert(std::ranges::viewable_range<range>);
+#endif
 
 static_assert(std::same_as<std::ranges::iterator_t<range const>, range::const_iterator>);
 static_assert(std::ranges::common_range<range const>);
 static_assert(std::ranges::forward_range<range const>);
 static_assert(!std::ranges::bidirectional_range<range const>);
 static_assert(!std::ranges::view<range const>);
 static_assert(!std::ranges::sized_range<range const>);
 static_assert(!std::ranges::borrowed_range<range const>);
 static_assert(!std::ranges::viewable_range<range const>);

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

 
 // list
 
 #include <list>
 
 #include <concepts>
 #include <ranges>
 
+#include "test_macros.h"
+
 using range = std::list<int>;
 
 
 static_assert(std::same_as<std::ranges::iterator_t<range>, range::iterator>);
 static_assert(std::ranges::common_range<range>);
 static_assert(std::ranges::bidirectional_range<range>);
 static_assert(!std::ranges::view<range>);
 static_assert(!std::ranges::random_access_range<range>);
 static_assert(std::ranges::sized_range<range>);
 static_assert(!std::ranges::borrowed_range<range>);
+#ifdef _LIBCPP_VERSION
 static_assert(!std::ranges::viewable_range<range>);
+#else // ^^^ pre-P2415 / post-P2415
+static_assert(std::ranges::viewable_range<range>);
+#endif
 
 static_assert(std::same_as<std::ranges::iterator_t<range const>, range::const_iterator>);
 static_assert(std::ranges::common_range<range const>);
 static_assert(std::ranges::bidirectional_range<range const>);
 static_assert(!std::ranges::view<range const>);
 static_assert(!std::ranges::random_access_range<range const>);
 static_assert(std::ranges::sized_range<range const>);
 static_assert(!std::ranges::borrowed_range<range const>);
 static_assert(!std::ranges::viewable_range<range const>);

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

 
 // vector
 
 #include <vector>
 
 #include <concepts>
 #include <ranges>
 
+#include "test_macros.h"
+
 using range = std::vector<bool>;
 
 
 static_assert(std::same_as<std::ranges::iterator_t<range>, range::iterator>);
 static_assert(std::ranges::common_range<range>);
 static_assert(std::ranges::random_access_range<range>);
 static_assert(!std::ranges::contiguous_range<range>);
 static_assert(!std::ranges::view<range>);
 static_assert(std::ranges::sized_range<range>);
 static_assert(!std::ranges::borrowed_range<range>);
+#ifdef _LIBCPP_VERSION
 static_assert(!std::ranges::viewable_range<range>);
+#else // ^^^ pre-P2415 / post-P2415
+static_assert(std::ranges::viewable_range<range>);
+#endif
 
 static_assert(std::same_as<std::ranges::iterator_t<range const>, range::const_iterator>);
 static_assert(std::ranges::common_range<range const>);
 static_assert(std::ranges::random_access_range<range const>);
 static_assert(!std::ranges::contiguous_range<range const>);
 static_assert(!std::ranges::view<range const>);
 static_assert(std::ranges::sized_range<range const>);
 static_assert(!std::ranges::borrowed_range<range const>);
 static_assert(!std::ranges::viewable_range<range const>);

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

 
 // vector
 
 #include <vector>
 
 #include <concepts>
 #include <ranges>
 
+#include "test_macros.h"
+
 using range = std::vector<int>;
 
 
 static_assert(std::same_as<std::ranges::iterator_t<range>, range::iterator>);
 static_assert(std::ranges::common_range<range>);
 static_assert(std::ranges::random_access_range<range>);
 static_assert(std::ranges::contiguous_range<range>);
 static_assert(!std::ranges::view<range>);
 static_assert(std::ranges::sized_range<range>);
 static_assert(!std::ranges::borrowed_range<range>);
+#ifdef _LIBCPP_VERSION
 static_assert(!std::ranges::viewable_range<range>);
+#else // ^^^ pre-P2415 / post-P2415
+static_assert(std::ranges::viewable_range<range>);
+#endif
 
 static_assert(std::same_as<std::ranges::iterator_t<range const>, range::const_iterator>);
 static_assert(std::ranges::common_range<range const>);
 static_assert(std::ranges::random_access_range<range const>);
 static_assert(std::ranges::contiguous_range<range const>);
 static_assert(!std::ranges::view<range const>);
 static_assert(std::ranges::sized_range<range const>);
 static_assert(!std::ranges::borrowed_range<range const>);
 static_assert(!std::ranges::viewable_range<range const>);

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

 
 // unordered_map
 
 #include <unordered_map>
 
 #include <concepts>
 #include <ranges>
 
+#include "test_macros.h"
+
 using range = std::unordered_map<int, int>;
 
 
 static_assert(std::same_as<std::ranges::iterator_t<range>, range::iterator>);
 static_assert(std::ranges::common_range<range>);
 static_assert(std::ranges::forward_range<range>);
 static_assert(!std::ranges::bidirectional_range<range>);
 static_assert(!std::ranges::view<range>);
 static_assert(std::ranges::sized_range<range>);
 static_assert(!std::ranges::borrowed_range<range>);
+#ifdef _LIBCPP_VERSION
 static_assert(!std::ranges::viewable_range<range>);
+#else // ^^^ pre-P2415 / post-P2415
+static_assert(std::ranges::viewable_range<range>);
+#endif
 
 static_assert(std::same_as<std::ranges::iterator_t<range const>, range::const_iterator>);
 static_assert(std::ranges::common_range<range const>);
 static_assert(std::ranges::forward_range<range const>);
 static_assert(!std::ranges::bidirectional_range<range const>);
 static_assert(!std::ranges::view<range const>);
 static_assert(std::ranges::sized_range<range const>);
 static_assert(!std::ranges::borrowed_range<range const>);
 static_assert(!std::ranges::viewable_range<range const>);

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

 
 // unordered_multimap
 
 #include <unordered_map>
 
 #include <concepts>
 #include <ranges>
 
+#include "test_macros.h"
+
 using range = std::unordered_multimap<int, int>;
 
 
 static_assert(std::same_as<std::ranges::iterator_t<range>, range::iterator>);
 static_assert(std::ranges::common_range<range>);
 static_assert(std::ranges::forward_range<range>);
 static_assert(!std::ranges::bidirectional_range<range>);
 static_assert(!std::ranges::view<range>);
 static_assert(std::ranges::sized_range<range>);
 static_assert(!std::ranges::borrowed_range<range>);
+#ifdef _LIBCPP_VERSION
 static_assert(!std::ranges::viewable_range<range>);
+#else // ^^^ pre-P2415 / post-P2415
+static_assert(std::ranges::viewable_range<range>);
+#endif
 
 static_assert(std::same_as<std::ranges::iterator_t<range const>, range::const_iterator>);
 static_assert(std::ranges::common_range<range const>);
 static_assert(std::ranges::forward_range<range const>);
 static_assert(!std::ranges::bidirectional_range<range const>);
 static_assert(!std::ranges::view<range const>);
 static_assert(std::ranges::sized_range<range const>);
 static_assert(!std::ranges::borrowed_range<range const>);
 static_assert(!std::ranges::viewable_range<range const>);

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

 
 // unordered_multiset
 
 #include <unordered_set>
 
 #include <concepts>
 #include <ranges>
 
+#include "test_macros.h"
+
 using range = std::unordered_multiset<int>;
 
 
 static_assert(std::same_as<std::ranges::iterator_t<range>, range::iterator>);
 static_assert(std::ranges::common_range<range>);
 static_assert(std::ranges::forward_range<range>);
 static_assert(!std::ranges::bidirectional_range<range>);
 static_assert(!std::ranges::view<range>);
 static_assert(std::ranges::sized_range<range>);
 static_assert(!std::ranges::borrowed_range<range>);
+#ifdef _LIBCPP_VERSION
 static_assert(!std::ranges::viewable_range<range>);
+#else // ^^^ pre-P2415 / post-P2415
+static_assert(std::ranges::viewable_range<range>);
+#endif
 
 static_assert(std::same_as<std::ranges::iterator_t<range const>, range::const_iterator>);
 static_assert(std::ranges::common_range<range const>);
 static_assert(std::ranges::forward_range<range const>);
 static_assert(!std::ranges::bidirectional_range<range const>);
 static_assert(!std::ranges::view<range const>);
 static_assert(std::ranges::sized_range<range const>);
 static_assert(!std::ranges::borrowed_range<range const>);
 static_assert(!std::ranges::viewable_range<range const>);

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

 
 // unordered_multiset
 
 #include <unordered_set>
 
 #include <concepts>
 #include <ranges>
 
+#include "test_macros.h"
+
 using range = std::unordered_set<int>;
 
 
 static_assert(std::same_as<std::ranges::iterator_t<range>, range::iterator>);
 static_assert(std::ranges::common_range<range>);
 static_assert(std::ranges::forward_range<range>);
 static_assert(!std::ranges::bidirectional_range<range>);
 static_assert(!std::ranges::view<range>);
 static_assert(std::ranges::sized_range<range>);
 static_assert(!std::ranges::borrowed_range<range>);
+#ifdef _LIBCPP_VERSION
 static_assert(!std::ranges::viewable_range<range>);
+#else // ^^^ pre-P2415 / post-P2415
+static_assert(std::ranges::viewable_range<range>);
+#endif
 
 static_assert(std::same_as<std::ranges::iterator_t<range const>, range::const_iterator>);
 static_assert(std::ranges::common_range<range const>);
 static_assert(std::ranges::forward_range<range const>);
 static_assert(!std::ranges::bidirectional_range<range const>);
 static_assert(!std::ranges::view<range const>);
 static_assert(std::ranges::sized_range<range const>);
 static_assert(!std::ranges::borrowed_range<range const>);
 static_assert(!std::ranges::viewable_range<range const>);

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

constexpr bool test() {
 
   {
     Range range(2);
     auto ref = std::views::all(range);
     ASSERT_SAME_TYPE(decltype(ref), std::ranges::ref_view<Range>);
     assert(std::ranges::begin(ref) == globalBuff + 2);
     assert(std::ranges::end(ref) == globalBuff + 8);
 
+#if _LIBCPP_VERSION
     static_assert(!std::is_invocable_v<decltype(std::views::all), Range>);
+#else // ^^^ before P2415 / after P2415 vvv
+    ASSERT_SAME_TYPE(decltype(std::views::all(std::move(range))), std::ranges::owning_view<Range>);
+#endif // _LIBCPP_VERSION
   }
 
   {
     const Range range(2);
     auto ref = std::views::all(range);
     static_assert(!noexcept(std::views::all(range)));
     ASSERT_SAME_TYPE(decltype(ref), std::ranges::ref_view<const Range>);
     assert(std::ranges::begin(ref) == globalBuff + 2);
     assert(std::ranges::end(ref) == globalBuff + 8);
   }
 
   {
     auto subrange = std::views::all(BorrowableRange(2));
-    static_assert(!noexcept(std::views::all(BorrowableRange(2))));
+    LIBCPP_STATIC_ASSERT(!noexcept(std::views::all(BorrowableRange(2))));
+#if _LIBCPP_VERSION
     ASSERT_SAME_TYPE(decltype(subrange), std::ranges::subrange<int*>);
+#else // ^^^ before P2415 / after P2415
+    ASSERT_SAME_TYPE(decltype(subrange), std::ranges::owning_view<BorrowableRange>);
+#endif // _LIBCPP_VERSION
     assert(std::ranges::begin(subrange) == globalBuff + 2);
     assert(std::ranges::end(subrange) == globalBuff + 8);
   }
 
   {
     auto subrange = std::views::all(RandomAccessRange());
+#if _LIBCPP_VERSION
     ASSERT_SAME_TYPE(decltype(subrange),
                      std::ranges::subrange<random_access_iterator<int*>, RandomAccessRange::sentinel>);
+#else // ^^^ before P2415 / after P2415
+    ASSERT_SAME_TYPE(decltype(subrange),
+                     std::ranges::owning_view<RandomAccessRange>);
+#endif // _LIBCPP_VERSION
     assert(std::ranges::begin(subrange).base() == globalBuff);
     assert(std::ranges::end(subrange) == std::ranges::begin(subrange) + 8);
   }
 
   // Check SFINAE friendliness of the call operator
   {
     static_assert(!std::is_invocable_v<decltype(std::views::all)>);
     static_assert(!std::is_invocable_v<decltype(std::views::all), RandomAccessRange, RandomAccessRange>);

libcxx/test/std/ranges/range.adaptors/range.all/all_t.compile.pass.cpp

 ASSERT_SAME_TYPE(std::views::all_t<View const&>, View);
 
 // Otherwise, when T is a reference to a range, returns ref_view<T>
 ASSERT_SAME_TYPE(std::views::all_t<Range&>, std::ranges::ref_view<Range>);
 ASSERT_SAME_TYPE(std::views::all_t<Range const&>, std::ranges::ref_view<Range const>);
 ASSERT_SAME_TYPE(std::views::all_t<BorrowableRange&>, std::ranges::ref_view<BorrowableRange>);
 ASSERT_SAME_TYPE(std::views::all_t<BorrowableRange const&>, std::ranges::ref_view<BorrowableRange const>);
 
+#ifdef _LIBCPP_VERSION
 // Otherwise, returns subrange<iterator_t<T>, sentinel_t<R>>
 ASSERT_SAME_TYPE(std::views::all_t<BorrowableRange>, std::ranges::subrange<forward_iterator<int*>, sentinel>);
 ASSERT_SAME_TYPE(std::views::all_t<BorrowableRange const>, std::ranges::subrange<forward_iterator<int const*>, sentinel>);
+#else // ^^^ before P2415 / after P2415 vvv
+ASSERT_SAME_TYPE(std::views::all_t<BorrowableRange>, std::ranges::owning_view<BorrowableRange>);
+static_assert(!std::ranges::viewable_range<BorrowableRange const>);
+#endif // _LIBCPP_VERSION

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

static_assert(std::same_as<
         decltype(std::ranges::common_view(r)),
         std::ranges::common_view<std::ranges::ref_view<Range>>
     >);
     // std::ranges::common_view(std::move(r)) invalid. RValue range must be borrowed.
     static_assert(std::same_as<
         decltype(std::ranges::common_view(br)),
         std::ranges::common_view<std::ranges::ref_view<BorrowedRange>>
     >);
+#ifdef _LIBCPP_VERSION
     static_assert(std::same_as<
         decltype(std::ranges::common_view(std::move(br))),
         std::ranges::common_view<std::ranges::subrange<
           int *, sentinel_wrapper<int *>, std::ranges::subrange_kind::unsized>>
     >);
+#else // ^^^ before P2415 / after P2415 vvv
+    static_assert(std::same_as<
+        decltype(std::ranges::common_view(std::move(br))),
+        std::ranges::common_view<std::ranges::owning_view<BorrowedRange>>
+    >);
+#endif // _LIBCPP_VERSION
 }

libcxx/test/std/ranges/range.adaptors/range.drop/ctad.compile.pass.cpp

 static_assert(std::same_as<decltype(ranges::drop_view(MoveOnlyView(), 0)), ranges::drop_view<MoveOnlyView>>);
 static_assert(std::same_as<decltype(ranges::drop_view(CopyableView(), 0)), ranges::drop_view<CopyableView>>);
 static_assert(std::same_as<decltype(ranges::drop_view(ForwardView(), 0)), ranges::drop_view<ForwardView>>);
 static_assert(std::same_as<decltype(ranges::drop_view(InputView(), 0)), ranges::drop_view<InputView>>);
 
 static_assert(std::same_as<decltype(ranges::drop_view(std::declval<ForwardRange&>(), 0)),
                            ranges::drop_view<ranges::ref_view<ForwardRange>>>);
 
+#ifdef _LIBCPP_VERSION
 static_assert(std::same_as<decltype(ranges::drop_view(BorrowableRange(), 0)),
                            ranges::drop_view<ranges::subrange<int*>>>);
+#else // ^^^ Before P2415 / After P2415 vvv
+static_assert(std::same_as<decltype(ranges::drop_view(BorrowableRange(), 0)),
+                           ranges::drop_view<ranges::owning_view<BorrowableRange>>>);
+#endif // _LIBCPP_VERSION

libcxx/test/std/ranges/range.adaptors/range.reverse/ctad.pass.cpp

BorrowedRange br;
     (void)x;
     // std::ranges::reverse_view(std::move(r)) is invalid. RValue range must be borrowed.
   }
   {
     std::same_as<std::ranges::reverse_view<std::ranges::ref_view<BorrowedRange>>> auto x = std::ranges::reverse_view(br);
     (void)x;
   }
   {
+#ifdef _LIBCPP_VERSION
     using Subrange = std::ranges::subrange<int *, sentinel_wrapper<int *>, std::ranges::subrange_kind::unsized>;
     std::same_as<std::ranges::reverse_view<Subrange>> auto x = std::ranges::reverse_view(std::move(br));
+#else // ^^^ Before P2415 / After P2415 vvv
+    std::same_as<std::ranges::reverse_view<std::ranges::owning_view<BorrowedRange>>> auto x =
+      std::ranges::reverse_view(std::move(br));
+#endif
     (void)x;
   }
 
   return 0;
 }

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

static_assert(std::same_as<
         decltype(std::ranges::take_view(r, 0)),
         std::ranges::take_view<std::ranges::ref_view<Range>>
     >);
     // std::ranges::take_view(std::move(r), 0) invalid. RValue range must be borrowed.
     static_assert(std::same_as<
         decltype(std::ranges::take_view(br, 0)),
         std::ranges::take_view<std::ranges::ref_view<BorrowedRange>>
     >);
+#ifdef _LIBCPP_VERSION
     static_assert(std::same_as<
         decltype(std::ranges::take_view(std::move(br), 0)),
         std::ranges::take_view<std::ranges::subrange<
           int *, sentinel_wrapper<int *>, std::ranges::subrange_kind::unsized>>
     >);
+#else // ^^^ before P2415 / after P2415
+    static_assert(std::same_as<
+        decltype(std::ranges::take_view(std::move(br), 0)),
+        std::ranges::take_view<std::ranges::owning_view<BorrowedRange>>
+    >);
+#endif // _LIBCPP_VERSION
 }

libcxx/test/std/ranges/range.adaptors/range.transform/ctad.compile.pass.cpp

 
 #include "test_macros.h"
 #include "types.h"
 
 static_assert(std::same_as<decltype(std::ranges::transform_view(InputView(), PlusOne())),
                            std::ranges::transform_view<InputView, PlusOne>>);
 static_assert(std::same_as<decltype(std::ranges::transform_view(std::declval<ForwardRange&>(), PlusOne())),
                            std::ranges::transform_view<std::ranges::ref_view<ForwardRange>, PlusOne>>);
+#ifdef _LIBCPP_VERSION
 static_assert(std::same_as<decltype(std::ranges::transform_view(BorrowableRange(), PlusOne())),
                            std::ranges::transform_view<std::ranges::subrange<int*>, PlusOne>>);
+#else // ^^^ before P2415 / after P2415 vvv
+static_assert(std::same_as<decltype(std::ranges::transform_view(BorrowableRange(), PlusOne())),
+                           std::ranges::transform_view<std::ranges::owning_view<BorrowableRange>, PlusOne>>);
+#endif // _LIBCPP_VERSION

libcxx/test/std/ranges/range.req/range.refinements/viewable_range.compile.pass.cpp

 
 // viewable_range<T> is not satisfied for (range=true, view=false, constructible_from=true, borrowed_range=false)
 struct T6 : test_range<cpp20_input_iterator> { };
 template<> constexpr bool std::ranges::enable_borrowed_range<T6> = false;
 static_assert(std::ranges::range<T6>);
 static_assert(!std::ranges::view<T6>);
 static_assert(std::constructible_from<T6, T6>);
 static_assert(!std::ranges::borrowed_range<T6>);
-
+#ifdef _LIBCPP_VERSION
 static_assert(!std::ranges::viewable_range<T6>);
+#else // ^^^ pre-P2415 / post-P2415 vvv
+static_assert(std::ranges::viewable_range<T6>);
+#endif // _LIBCPP_VERSION
 
 // viewable_range<T> is satisfied for (range=true, view=false, constructible_from=false, borrowed_range=true)
 struct T7 : test_range<cpp20_input_iterator> {
   T7(T7 const&) = delete;
 };
 static_assert(std::ranges::range<T7&>);
 static_assert(!std::ranges::view<std::remove_cvref_t<T7&>>);
 static_assert(!std::constructible_from<std::remove_cvref_t<T7&>, T7&>);

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

 
 // match_results
 
 #include <regex>
 
 #include <concepts>
 #include <ranges>
 
-
+#include "test_macros.h"
 
 static_assert(std::same_as<std::ranges::iterator_t<std::cmatch>, std::cmatch::iterator>);
 static_assert(std::ranges::common_range<std::cmatch>);
 static_assert(std::ranges::random_access_range<std::cmatch>);
 static_assert(std::ranges::contiguous_range<std::cmatch>);
 static_assert(!std::ranges::view<std::cmatch>);
 static_assert(std::ranges::sized_range<std::cmatch>);
 static_assert(!std::ranges::borrowed_range<std::cmatch>);
+#ifdef _LIBCPP_VERSION
 static_assert(!std::ranges::viewable_range<std::cmatch>);
+#else // ^^^ pre-P2415 / post-P2415
+static_assert(std::ranges::viewable_range<std::cmatch>);
+#endif
 
 static_assert(std::same_as<std::ranges::iterator_t<std::cmatch const>, std::cmatch::const_iterator>);
 static_assert(std::ranges::common_range<std::cmatch const>);
 static_assert(std::ranges::random_access_range<std::cmatch const>);
 static_assert(std::ranges::contiguous_range<std::cmatch const>);
 static_assert(!std::ranges::view<std::cmatch const>);
 static_assert(std::ranges::sized_range<std::cmatch const>);
 static_assert(!std::ranges::borrowed_range<std::cmatch const>);
 static_assert(!std::ranges::viewable_range<std::cmatch const>);

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

 
 // string
 
 #include <string>
 
 #include <concepts>
 #include <ranges>
 
-
+#include "test_macros.h"
 
 static_assert(std::same_as<std::ranges::iterator_t<std::string>, std::string::iterator>);
 static_assert(std::ranges::common_range<std::string>);
 static_assert(std::ranges::random_access_range<std::string>);
 static_assert(std::ranges::contiguous_range<std::string>);
 static_assert(!std::ranges::view<std::string>);
 static_assert(std::ranges::sized_range<std::string>);
 static_assert(!std::ranges::borrowed_range<std::string>);
+#ifdef _LIBCPP_VERSION
 static_assert(!std::ranges::viewable_range<std::string>);
+#else // ^^^ pre-P2415 / post-P2415
+static_assert(std::ranges::viewable_range<std::string>);
+#endif
 
 static_assert(std::same_as<std::ranges::iterator_t<std::string const>, std::string::const_iterator>);
 static_assert(std::ranges::common_range<std::string const>);
 static_assert(std::ranges::random_access_range<std::string const>);
 static_assert(std::ranges::contiguous_range<std::string const>);
 static_assert(!std::ranges::view<std::string const>);
 static_assert(std::ranges::sized_range<std::string const>);
 static_assert(!std::ranges::borrowed_range<std::string const>);
 static_assert(!std::ranges::viewable_range<std::string const>);