[libc++][ranges] Implement `lazy_split_view`.

[var-const]

Summary

Note that this class was called just split_view in the original One
Ranges Proposal and was renamed to lazy_split_view by
P2210.

[Mordante]

I had a look at the code, however I feel I'm not the most qualified person to review this code. So I left comment, but I leave the approval to somebody more familiar with this part of ranges.

libcxx/include/__ranges/lazy_split_view.h

9

Nit: we usually have a blank line before the include guard.

67

This function should be marked _LIBCPP_HIDE_FROM_ABI, similar for most functions in this patch.

224

The LLVM coding-style prefers to omit curly-braces when there's only one statement in the branch.
(I noticed the same in other parts of this review.)

260

I miss the public iterator_category.

310

Please move the return on its own line, since that's the LLVM style. (I know this matches the Standard wording.)

libcxx/test/std/ranges/range.adaptors/range.lazy.split/adaptor.pass.cpp

10

This is no longer required, same for the other headers. (It was when you uploaded the patch.)

libcxx/test/std/ranges/range.adaptors/range.lazy.split/ctor.range.pass.cpp

26

This looks odd D&& d which is moved instead of forwarded. When this is intended please add comment explaining why this is intended.

libcxx/test/std/ranges/range.adaptors/range.lazy.split/general.pass.cpp

75

How do you feel about using `[[maybe_unused]] instead?

340

Is '\0' a valid separator?

393

I think it would be nice to also test with wchar_t, char(8|16|32)_t.

libcxx/test/std/ranges/range.adaptors/range.lazy.split/range.lazy.split.outer/ctor.copy.pass.cpp

15

What is the purpose of these empty tests? When intended please add comment why it's intended.

libcxx/test/std/ranges/range.adaptors/range.lazy.split/types.h

103

This looks copy pasted, please replace TEST_CONSTEXPR.* with constexpr.
(I assume it's not possible to use the original.)

libcxx/test/support/test_iterators.h

519

This is no longer required. (It was when you uploaded the patch.)

[var-const]

@Mordante Thank you for the review, and sorry about the confusion with two patches. Addressed most of the comments in D107500.

libcxx/include/__ranges/lazy_split_view.h

67

Done (I might have missed something, but at least most of them should be now marked).

224

I strongly dislike the LLVM style on this point. I don't think a single closing brace adds any significant line noise (the opening brace, being on the same line as the if or else condition, is clearly negligible) but it makes visually parsing code easier and protects against potential bugs. Personally, I would only use if without braces if the body is short enough to be on the same line. I'd rather keep this as is unless you feel strongly about it.

260

It's inherited from __inner_iterator_category which was mistakenly inherited privately. Fixed now.

libcxx/test/std/ranges/range.adaptors/range.lazy.split/adaptor.pass.cpp

10

Thanks, removed those.

libcxx/test/std/ranges/range.adaptors/range.lazy.split/ctor.range.pass.cpp

26

No longer applicable (the concept is replaced by using is_constructible_from).

libcxx/test/std/ranges/range.adaptors/range.lazy.split/general.pass.cpp

75

Done. FWIW, I don't like how verbose it is, but the fact that it can be applied to the same line is nice.

340

Great suggestion, added a test. I think any character is a valid separator.

393

Added a single test case for each of those character types, is that sufficient?

libcxx/test/std/ranges/range.adaptors/range.lazy.split/range.lazy.split.outer/ctor.copy.pass.cpp

15

Sorry, I had a comment about this in the main patch but not here -- basically, I uploaded the patch for initial review while the tests were not finished yet, these are just placeholders for unfinished tests. All the tests (that I'm aware of) are implemented now, PTAL.

libcxx/test/support/test_iterators.h

519

Thanks!

[Mordante]

libcxx/include/__ranges/lazy_split_view.h

224

I initially also disliked it, but it has kind of grown on me. At least nowadays compilers can warn about the misleading indention and when using clang-format the indention is always right.

Since we already use both styles in libc++ I don't feel too strongly about it. But other reviewers might disagree.

libcxx/test/std/ranges/range.adaptors/range.lazy.split/general.pass.cpp

340

I also assume every character is valid. But this is a nice corner case.

393

Yes that looks sufficient. I see a small issue, but will post that in D107500.

libcxx/docs/Status/RangesPaper.csv

 `[range.single] <https://wg21.link/range.single>`_,`single_view <https://llvm.org/D106840>`_,[view.interface],Zoe Carver,✅
 `[range.iota] <https://wg21.link/range.iota>`_,`iota_view <https://llvm.org/D107396>`_,[range.all],Zoe Carver,✅
 `[range.all] <https://wg21.link/range.all>`_,`view::all <https://llvm.org/D102028>`_,"[range.subrange], [range.view.ref]",Zoe Carver,✅
 `[range.ref.view] <https://wg21.link/range.ref.view>`_,`ref_view <https://llvm.org/D102020>`_,[view.interface],Zoe Carver,✅
 `[range.filter] <https://wg21.link/range.filter>`_,`filter_view <https://llvm.org/D109086>`_,[range.all],Louis Dionne,Under review
 `[range.transform] <https://wg21.link/range.transform>`_,`transform_view <https://llvm.org/D103056>`_,[range.all],Zoe Carver,✅
 `[range.take] <https://wg21.link/range.take>`_,`take_view <https://llvm.org/D106507>`_,[range.all],Zoe Carver,✅
 `[range.join] <https://wg21.link/range.join>`_,`join_view <https://llvm.org/D107671>`_,[range.all],Zoe Carver,✅
-`[range.split] <https://wg21.link/range.split>`_,`split_view (renamed to lazy_split_view by P2210) <https://llvm.org/D107500>`_,[range.all],Zoe Carver,In progress
+`[range.split] <https://wg21.link/range.split>`_,`split_view (renamed to lazy_split_view by P2210) <https://llvm.org/D107500>`_,[range.all],Zoe Carver and Konstantin Varlamov,✅
 `[range.counted] <https://wg21.link/range.counted>`_,`view::counted <https://llvm.org/D106923>`_,[range.subrange],Zoe Carver,✅
 `[range.common] <https://wg21.link/range.common>`_,`common_view <https://llvm.org/D105753>`_,[range.all],Zoe Carver,✅
 `[range.reverse] <https://wg21.link/range.reverse>`_,`reverse_view <https://llvm.org/D107096>`_,[range.all],Zoe Carver,✅

libcxx/include/CMakeLists.txt

set(files
   __ranges/data.h
   __ranges/drop_view.h
   __ranges/empty.h
   __ranges/empty_view.h
   __ranges/enable_borrowed_range.h
   __ranges/enable_view.h
   __ranges/iota_view.h
   __ranges/join_view.h
+  __ranges/lazy_split_view.h
   __ranges/non_propagating_cache.h
   __ranges/owning_view.h
   __ranges/range_adaptor.h
   __ranges/rbegin.h
   __ranges/ref_view.h
   __ranges/rend.h
   __ranges/reverse_view.h
   __ranges/single_view.h

libcxx/include/__ranges/lazy_split_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_LAZY_SPLIT_VIEW_H
+#define _LIBCPP___RANGES_LAZY_SPLIT_VIEW_H
+
+#include <__algorithm/find.h>
+#include <__algorithm/mismatch.h>
+#include <__concepts/constructible.h>
+#include <__config>
+#include <__functional/ranges_operations.h>
+#include <__iterator/concepts.h>
+#include <__iterator/default_sentinel.h>
+#include <__iterator/incrementable_traits.h>
+#include <__iterator/indirectly_comparable.h>
+#include <__iterator/iterator_traits.h>
+#include <__iterator/iter_swap.h>
+#include <__memory/addressof.h>
+#include <__ranges/access.h>
+#include <__ranges/all.h>
+#include <__ranges/concepts.h>
+#include <__ranges/non_propagating_cache.h>
+#include <__ranges/range_adaptor.h>
+#include <__ranges/single_view.h>
+#include <__ranges/view_interface.h>
+#include <__utility/move.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 <auto> struct __require_constant;
+
+template <class _Range>
+concept __tiny_range =
+  sized_range<_Range> &&
+  requires { typename __require_constant<remove_reference_t<_Range>::size()>; } &&
+  (remove_reference_t<_Range>::size() <= 1);
+
+template <input_range _View, forward_range _Pattern>
+  requires view<_View> && view<_Pattern> &&
+            indirectly_comparable<iterator_t<_View>, iterator_t<_Pattern>, ranges::equal_to> &&
+            (forward_range<_View> || __tiny_range<_Pattern>)
+class lazy_split_view : public view_interface<lazy_split_view<_View, _Pattern>> {
+
+  _View __base_ = _View();
+  _Pattern __pattern_ = _Pattern();
+
+  using _MaybeCurrent = _If<!forward_range<_View>, __non_propagating_cache<iterator_t<_View>>, __empty_cache>;
+  _LIBCPP_NO_UNIQUE_ADDRESS _MaybeCurrent __current_;
+
+  template <bool> struct __outer_iterator;
+  template <bool> struct __inner_iterator;
+
+public:
+  lazy_split_view()
+    requires default_initializable<_View> && default_initializable<_Pattern> = default;
+
+  constexpr lazy_split_view(_View __base, _Pattern __pattern)
+    : __base_(std::move(__base)), __pattern_(std::move(__pattern)) {}
+
+  template <input_range _Range>
+    requires constructible_from<_View, views::all_t<_Range>> &&
+              constructible_from<_Pattern, single_view<range_value_t<_Range>>>
+  constexpr lazy_split_view(_Range&& __r, range_value_t<_Range> __e)
+    : __base_(views::all(std::forward<_Range>(__r)))
+    , __pattern_(ranges::single_view(std::move(__e))) {}
+
+  constexpr _View base() const& requires copy_constructible<_View> { return __base_; }
+  constexpr _View base() && { return std::move(__base_); }
+
+  constexpr auto begin() {
+    if constexpr (forward_range<_View>) {
+      return __outer_iterator<__simple_view<_View> && __simple_view<_Pattern>>{*this, ranges::begin(__base_)};
+    } else {
+      *__current_ = ranges::begin(__base_);
+      return __outer_iterator<false>{*this};
+    }
+  }
+
+  constexpr auto begin() const requires forward_range<_View> && forward_range<const _View> {
+    return __outer_iterator<true>{*this, ranges::begin(__base_)};
+  }
+
+  constexpr auto end() requires forward_range<_View> && common_range<_View> {
+    return __outer_iterator<__simple_view<_View> && __simple_view<_Pattern>>{*this, ranges::end(__base_)};
+  }
+
+  constexpr auto end() const {
+    if constexpr (forward_range<_View> && forward_range<const _View> && common_range<const _View>) {
+      return __outer_iterator<true>{*this, ranges::end(__base_)};
+    } else {
+      return default_sentinel;
+    }
+  }
+
+private:
+
+  template <class>
+  struct __outer_iterator_category {};
+
+  template <forward_range _Tp>
+  struct __outer_iterator_category<_Tp> {
+    using iterator_category = input_iterator_tag;
+  };
+
+  template <bool _Const> struct __outer_iterator : __outer_iterator_category<__maybe_const<_Const, _View>> {
+  private:
+    template <bool>
+    friend class __inner_iterator;
+
+    using _Parent = __maybe_const<_Const, lazy_split_view>;
+    using _Base = __maybe_const<_Const, _View>;
+
+    _Parent* __parent_ = nullptr;
+    using _MaybeCurrent = _If<forward_range<_View>, iterator_t<_Base>, __empty_cache>;
+    _LIBCPP_NO_UNIQUE_ADDRESS _MaybeCurrent __current_ = _MaybeCurrent();
+    bool __trailing_empty_ = false;
+
+    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
+    constexpr auto& __current() {
+      if constexpr (forward_range<_Base>) {
+        return __current_;
+      } else {
+        return *__parent_->__current_;
+      }
+    }
+
+    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
+    constexpr auto& __current() const {
+      if constexpr (forward_range<_Base>) {
+        return __current_;
+      } else {
+        return *__parent_->__current_;
+      }
+    }
+
+  public:
+    using iterator_concept = conditional_t<forward_range<_Base>, forward_iterator_tag, input_iterator_tag>;
+    using difference_type = range_difference_t<_Base>;
+
+    struct value_type : view_interface<value_type> {
+    private:
+      __outer_iterator __i_ = __outer_iterator();
+
+    public:
+      value_type() = default;
+      constexpr explicit value_type(__outer_iterator __i)
+        : __i_(std::move(__i)) {}
+
+      constexpr __inner_iterator<_Const> begin() const { return __inner_iterator<_Const>{__i_}; }
+      constexpr default_sentinel_t end() const { return default_sentinel; }
+    };
+
+    __outer_iterator() = default;
+
+    constexpr explicit __outer_iterator(_Parent& __parent)
+      requires (!forward_range<_Base>)
+      : __parent_(std::addressof(__parent)) {}
+
+    constexpr __outer_iterator(_Parent& __parent, iterator_t<_Base> __current)
+      requires forward_range<_Base>
+      : __parent_(std::addressof(__parent)), __current_(std::move(__current)) {}
+
+    constexpr __outer_iterator(__outer_iterator<!_Const> __i)
+      requires _Const && convertible_to<iterator_t<_View>, iterator_t<_Base>>
+      : __parent_(__i.__parent_), __current_(std::move(__i.__current_)) {}
+
+    constexpr value_type operator*() const { return value_type{*this}; }
+
+    constexpr __outer_iterator& operator++() {
+      const auto __end = ranges::end(__parent_->__base_);
+      if (__current() == __end) {
+        __trailing_empty_ = false;
+        return *this;
+      }
+
+      const auto [__pbegin, __pend] = ranges::subrange{__parent_->__pattern_};
+      if (__pbegin == __pend) {
+        ++__current();
+
+      } else if constexpr (__tiny_range<_Pattern>) {
+        // TODO(varconst): should be `ranges::find`.
+        __current() = std::find(std::move(__current()), __end, *__pbegin);
+        if (__current() != __end) {
+          ++__current();
+          if (__current() == __end)
+            __trailing_empty_ = true;
+        }
+
+      } else {
+        do {
+          // TODO(varconst): should be `ranges::mismatch`.
+          const auto [__b, __p] = std::mismatch(__current(), __end, __pbegin, __pend);
+          if (__p == __pend) {
+            __current() = __b;
+            if (__current() == __end) {
+              __trailing_empty_ = true;
+            }
+            break; // The pattern matched; skip it.
+          }
+        } while (++__current() != __end);
+      }
+
+      return *this;
+    }
+
+    constexpr decltype(auto) operator++(int) {
+      if constexpr (forward_range<_Base>) {
+        auto __tmp = *this;
+        ++*this;
+        return __tmp;
+      } else {
+        ++*this;
+      }
+    }
+
+    friend constexpr bool operator==(const __outer_iterator& __x, const __outer_iterator& __y)
+      requires forward_range<_Base>
+    {
+      return __x.__current_ == __y.__current_ && __x.__trailing_empty_ == __y.__trailing_empty_;
+    }
+
+    friend constexpr bool operator==(const __outer_iterator& __x, default_sentinel_t) {
+      return __x.__current() == ranges::end(__x.__parent_->__base_) && !__x.__trailing_empty_;
+    }
+  };
+
+  template <class>
+  struct __inner_iterator_category {};
+
+  template <forward_range _Tp>
+  struct __inner_iterator_category<_Tp> {
+    using iterator_category = _If<
+      derived_from<typename iterator_traits<iterator_t<_Tp>>::iterator_category, forward_iterator_tag>,
+      forward_iterator_tag,
+      typename iterator_traits<iterator_t<_Tp>>::iterator_category
+    >;
+  };
+
+  template <bool _Const> struct __inner_iterator : private __inner_iterator_category<__maybe_const<_Const, _View>> {
+  private:
+    using _Base = __maybe_const<_Const, _View>;
+    __outer_iterator<_Const> __i_ = __outer_iterator<_Const>();
+    bool __incremented_ = false;
+
+  public:
+    using iterator_concept = typename __outer_iterator<_Const>::iterator_concept;
+    using value_type = range_value_t<_Base>;
+    using difference_type = range_difference_t<_Base>;
+
+    __inner_iterator() = default;
+
+    constexpr explicit __inner_iterator(__outer_iterator<_Const> __i)
+      : __i_(std::move(__i)) {}
+
+    constexpr const iterator_t<_Base>& base() const& noexcept { return __i_.__current(); }
+    constexpr iterator_t<_Base> base() &&
+      requires forward_range<_View> { return std::move(__i_.__current()); }
+
+    constexpr decltype(auto) operator*() const { return *__i_.__current(); }
+
+    constexpr __inner_iterator& operator++() {
+      __incremented_ = true;
+
+      if constexpr (!forward_range<_Base>) {
+        if constexpr (_Pattern::size() == 0) {
+          return *this;
+        }
+      }
+
+      ++__i_.__current();
+      return *this;
+    }
+
+    constexpr decltype(auto) operator++(int) {
+      if constexpr (forward_range<_Base>) {
+        auto __tmp = *this;
+        ++*this;
+        return __tmp;
+
+      } else {
+        ++*this;
+      }
+    }
+
+    friend constexpr bool operator==(const __inner_iterator& __x, const __inner_iterator& __y)
+      requires forward_range<_Base>
+    {
+      return __x.__i_.__current() == __y.__i_.__current();
+    }
+
+    friend constexpr bool operator==(const __inner_iterator& __x, default_sentinel_t) {
+      auto [__pcur, __pend] = ranges::subrange{__x.__i_.__parent_->__pattern_};
+      const auto __end = ranges::end(__x.__i_.__parent_->__base_);
+
+      if constexpr (__tiny_range<_Pattern>) {
+        const auto& __cur = __x.__i_.__current();
+        if (__cur == __end) return true;
+        if (__pcur == __pend)  return __x.__incremented_;
+
+        return *__cur == *__pcur;
+
+      } else {
+        auto __cur = __x.__i_.__current();
+        if (__cur == __end) return true;
+        if (__pcur == __pend)  return __x.__incremented_;
+
+        do {
+          if (*__cur != *__pcur) return false;
+          if (++__pcur == __pend) return true;
+        } while (++__cur != __end);
+
+        return false;
+      }
+    }
+
+    friend constexpr decltype(auto) iter_move(const __inner_iterator& __i)
+      noexcept(noexcept(ranges::iter_move(__i.__i_.__current()))) {
+      return ranges::iter_move(__i.__i_.__current());
+    }
+
+    friend constexpr void iter_swap(const __inner_iterator& __x, const __inner_iterator& __y)
+      noexcept(noexcept(ranges::iter_swap(__x.__i_.__current(), __y.__i_.__current())))
+      requires indirectly_swappable<iterator_t<_Base>> {
+      ranges::iter_swap(__x.__i_.__current(), __y.__i_.__current());
+    }
+  };
+
+};
+
+template <class _Range, class _Pattern>
+lazy_split_view(_Range&&, _Pattern&&) -> lazy_split_view<views::all_t<_Range>, views::all_t<_Pattern>>;
+
+template <input_range _Range>
+lazy_split_view(_Range&&, range_value_t<_Range>)
+  -> lazy_split_view<views::all_t<_Range>, single_view<range_value_t<_Range>>>;
+
+namespace views {
+namespace __lazy_split_view {
+struct __fn : __range_adaptor_closure<__fn> {
+  template <class _Range, class _Pattern>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
+  constexpr auto operator()(_Range&& __range, _Pattern&& __pattern) const
+  noexcept(  noexcept(lazy_split_view(std::forward<_Range>(__range), std::forward<_Pattern>(__pattern))))
+    -> decltype(      lazy_split_view(std::forward<_Range>(__range), std::forward<_Pattern>(__pattern)))
+    { return          lazy_split_view(std::forward<_Range>(__range), std::forward<_Pattern>(__pattern)); }
+
+  template <class _Pattern>
+    requires constructible_from<decay_t<_Pattern>, _Pattern>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
+  constexpr auto operator()(_Pattern&& __pattern) const
+  noexcept(is_nothrow_constructible_v<decay_t<_Pattern>, _Pattern>) {
+    return __range_adaptor_closure_t(std::__bind_back(*this, std::forward<_Pattern>(__pattern)));
+  }
+};
+} // namespace __lazy_split_view
+
+inline namespace __cpo {
+  inline constexpr auto lazy_split = __lazy_split_view::__fn{};
+} // namespace __cpo
+} // namespace views
+
+} // namespace ranges
+
+#endif // !defined(_LIBCPP_HAS_NO_RANGES)
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___RANGES_LAZY_SPLIT_VIEW_H

libcxx/include/module.modulemap

module __ranges {
       module data                   { private header "__ranges/data.h" }
       module drop_view              { private header "__ranges/drop_view.h" }
       module empty                  { private header "__ranges/empty.h" }
       module empty_view             { private header "__ranges/empty_view.h" }
       module enable_borrowed_range  { private header "__ranges/enable_borrowed_range.h" }
       module enable_view            { private header "__ranges/enable_view.h" }
       module iota_view              { private header "__ranges/iota_view.h" }
       module join_view              { private header "__ranges/join_view.h" }
+      module lazy_split_view        { private header "__ranges/lazy_split_view.h" }
       module non_propagating_cache  { private header "__ranges/non_propagating_cache.h" }
       module owning_view            { private header "__ranges/owning_view.h" }
       module range_adaptor          { private header "__ranges/range_adaptor.h" }
       module rbegin                 { private header "__ranges/rbegin.h" }
       module ref_view               { private header "__ranges/ref_view.h" }
       module rend                   { private header "__ranges/rend.h" }
       module reverse_view           { private header "__ranges/reverse_view.h" }
       module single_view            { private header "__ranges/single_view.h" }

libcxx/include/ranges

// [range.reverse], reverse view
 
   template<class W, class Bound>
     inline constexpr bool enable_borrowed_range<iota_view<W, Bound>> = true;
 
   // [range.join], join view
   template<input_range V>
     requires view<V> && input_range<range_reference_t<V>>
   class join_view;
+
+  // [range.lazy.split], lazy split view
+  template<class R>
+    concept tiny-range = see below;   // exposition only
+
+  template<input_range V, forward_range Pattern>
+    requires view<V> && view<Pattern> &&
+             indirectly_comparable<iterator_t<V>, iterator_t<Pattern>, ranges::equal_to> &&
+             (forward_range<V> || tiny-range<Pattern>)
+  class lazy_split_view;
+
+  namespace views {
+    inline constexpr unspecified lazy_split = unspecified;
+  }
 }
 
 namespace std {
   namespace views = ranges::views;
 
   template<class T> struct tuple_size;
   template<size_t I, class T> struct tuple_element;
 

 #include <__ranges/data.h>
 #include <__ranges/drop_view.h>
 #include <__ranges/empty.h>
 #include <__ranges/empty_view.h>
 #include <__ranges/enable_borrowed_range.h>
 #include <__ranges/enable_view.h>
 #include <__ranges/iota_view.h>
 #include <__ranges/join_view.h>
+#include <__ranges/lazy_split_view.h>
 #include <__ranges/rbegin.h>
 #include <__ranges/ref_view.h>
 #include <__ranges/rend.h>
 #include <__ranges/reverse_view.h>
 #include <__ranges/single_view.h>
 #include <__ranges/size.h>
 #include <__ranges/subrange.h>
 #include <__ranges/take_view.h>

libcxx/test/libcxx/diagnostics/detail.headers/ranges/lazy_split_view.module.verify.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
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__ranges/lazy_split_view.h'}}
+#include <__ranges/lazy_split_view.h>

libcxx/test/std/ranges/range.adaptors/range.lazy.split/adaptor.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
+
+// std::views::lazy_split
+
+#include <ranges>
+
+#include <array>
+#include <cassert>
+#include <concepts>
+#include <string_view>
+#include <utility>
+
+#include "test_iterators.h"
+#include "types.h"
+
+template <class View, class T>
+concept CanBePiped = requires (View&& view, T&& t) {
+  { std::forward<View>(view) | std::forward<T>(t) };
+};
+
+static_assert(std::same_as<decltype(std::views::lazy_split), decltype(std::ranges::views::lazy_split)>);
+
+struct SomeView : std::ranges::view_base {
+  const std::string_view* v_;
+  constexpr SomeView(const std::string_view& v) : v_(&v) {}
+  constexpr auto begin() const { return v_->begin(); }
+  constexpr auto end() const { return v_->end(); }
+};
+
+constexpr bool test() {
+  using namespace std::string_view_literals;
+
+  constexpr std::string_view input = "abc";
+  constexpr std::string_view sep = "a";
+
+  // Test that std::views::lazy_split is a range adaptor.
+
+  // Test `views::lazy_split(input, sep)`.
+  {
+    SomeView view(input);
+
+    using Result = std::ranges::lazy_split_view<SomeView, std::string_view>;
+    std::same_as<Result> auto result = std::views::lazy_split(view, sep);
+    assert(result.base().begin() == input.begin());
+    assert(result.base().end() == input.end());
+  }
+
+  // Test `views::lazy_split(sep)(input)`.
+  {
+    SomeView view(input);
+
+    using Result = std::ranges::lazy_split_view<SomeView, std::string_view>;
+    std::same_as<Result> auto result = std::views::lazy_split(sep)(view);
+    assert(result.base().begin() == input.begin());
+    assert(result.base().end() == input.end());
+  }
+
+  // Test `view | views::lazy_split`.
+  {
+    SomeView view(input);
+
+    using Result = std::ranges::lazy_split_view<SomeView, std::string_view>;
+    std::same_as<Result> auto result = view | std::views::lazy_split(sep);
+    assert(result.base().begin() == input.begin());
+    assert(result.base().end() == input.end());
+  }
+
+  // Test `adaptor | views::lazy_split`.
+  {
+    SomeView view(input);
+    auto f = [](char c) { return c; };
+    auto partial = std::views::transform(f) | std::views::lazy_split(sep);
+
+    using Result = std::ranges::lazy_split_view<std::ranges::transform_view<SomeView, decltype(f)>, std::string_view>;
+    std::same_as<Result> auto result = partial(view);
+    assert(result.base().base().begin() == input.begin());
+    assert(result.base().base().end() == input.end());
+  }
+
+  // Test `views::lazy_split | adaptor`.
+  {
+    SomeView view(input);
+    auto f = [](auto v) { return v; };
+    auto partial = std::views::lazy_split(sep) | std::views::transform(f);
+
+    using Result = std::ranges::transform_view<std::ranges::lazy_split_view<SomeView, std::string_view>, decltype(f)>;
+    std::same_as<Result> auto result = partial(view);
+    assert(result.base().base().begin() == input.begin());
+    assert(result.base().base().end() == input.end());
+  }
+
+  // Check SFINAE friendliness.
+  {
+    struct NotAView { };
+
+    static_assert(!std::is_invocable_v<decltype(std::views::lazy_split)>);
+    static_assert(!std::is_invocable_v<decltype(std::views::lazy_split), SomeView, NotAView>);
+    static_assert(!std::is_invocable_v<decltype(std::views::lazy_split), NotAView, SomeView>);
+    static_assert( std::is_invocable_v<decltype(std::views::lazy_split), SomeView, SomeView>);
+
+    static_assert( CanBePiped<SomeView&,    decltype(std::views::lazy_split)>);
+    static_assert( CanBePiped<char(&)[10],  decltype(std::views::lazy_split)>);
+    static_assert(!CanBePiped<char(&&)[10], decltype(std::views::lazy_split)>);
+    static_assert(!CanBePiped<NotAView,     decltype(std::views::lazy_split)>);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.lazy.split/base.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
+
+// constexpr View base() const& requires copy_constructible<_View>;
+// constexpr View base() &&;
+
+#include <ranges>
+
+#include <cassert>
+#include <string_view>
+#include <utility>
+#include "types.h"
+
+template <class View>
+concept CanCallLvalueBase = requires(View& v) { v.base(); };
+template <class View>
+concept CanCallRvalueBase = requires(View& v) { std::move(v).base(); };
+
+static_assert( CanCallLvalueBase<std::ranges::lazy_split_view<CopyableView, ForwardView>>);
+static_assert(!CanCallLvalueBase<std::ranges::lazy_split_view<MoveOnlyView, ForwardView>>);
+static_assert( CanCallRvalueBase<std::ranges::lazy_split_view<CopyableView, ForwardView>>);
+static_assert( CanCallRvalueBase<std::ranges::lazy_split_view<MoveOnlyView, ForwardView>>);
+
+constexpr bool test() {
+  // Copyable input -- both lvalue and rvalue overloads of `base` are available.
+  {
+    constexpr std::string_view str = "abc def";
+    std::ranges::lazy_split_view<std::string_view, std::string_view> v(str, " ");
+
+    static_assert(std::same_as<decltype(v.base()), std::string_view>);
+    assert(v.base() == str);
+
+    static_assert(std::same_as<decltype(std::move(v).base()), std::string_view>);
+    assert(std::move(v).base() == str);
+  }
+
+  // Move-only input -- only the rvalue overload of `base` is available.
+  {
+    std::ranges::lazy_split_view<MoveOnlyView, ForwardView> v;
+    assert(std::move(v).base() == MoveOnlyView());
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.lazy.split/begin.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
+
+// constexpr auto begin();
+// constexpr auto begin() const requires forward_range<View> && forward_range<const View>;
+
+#include <ranges>
+
+#include <cassert>
+#include <utility>
+#include "test_iterators.h"
+#include "types.h"
+
+template <class View, class Expected>
+concept OuterIterConceptSameAs =
+    std::same_as<typename decltype(std::declval<View>().begin())::iterator_concept, Expected>;
+
+template <class View, class Expected>
+concept InnerIterValueTypeSameAs = requires (View v) {
+  { *(*v.begin()).begin() } -> std::same_as<Expected>;
+};
+
+template <class View>
+concept ConstBeginDisabled = !requires (const View v) {
+  { (*v.begin()) };
+};
+
+constexpr bool test() {
+  // non-const: forward_range<View> && simple-view<View> -> outer-iterator<Const = true>
+  // const: forward_range<View> && forward_range<const View> -> outer-iterator<Const = true>
+  {
+    using V = ForwardView;
+    using P = V;
+
+    static_assert(std::ranges::forward_range<V>);
+    static_assert(std::ranges::forward_range<const V>);
+    LIBCPP_STATIC_ASSERT(std::ranges::__simple_view<V>);
+    LIBCPP_STATIC_ASSERT(std::ranges::__simple_view<P>);
+
+    std::ranges::lazy_split_view<V, P> v;
+    static_assert(OuterIterConceptSameAs<decltype(v), std::forward_iterator_tag>);
+    static_assert(InnerIterValueTypeSameAs<decltype(v), const char&>);
+
+    const std::ranges::lazy_split_view<V, P> cv;
+    static_assert(OuterIterConceptSameAs<decltype(cv), std::forward_iterator_tag>);
+    static_assert(InnerIterValueTypeSameAs<decltype(cv), const char&>);
+  }
+
+  // non-const: forward_range<View> && !simple-view<View> -> outer-iterator<Const = false>
+  // const: forward_range<View> && forward_range<const View> -> outer-iterator<Const = true>
+  {
+    using V = ForwardDiffView;
+    using P = V;
+
+    static_assert(std::ranges::forward_range<V>);
+    static_assert(std::ranges::forward_range<const V>);
+    LIBCPP_STATIC_ASSERT(!std::ranges::__simple_view<V>);
+    LIBCPP_STATIC_ASSERT(!std::ranges::__simple_view<P>);
+
+    std::ranges::lazy_split_view<V, P> v;
+    static_assert(OuterIterConceptSameAs<decltype(v), std::forward_iterator_tag>);
+    static_assert(InnerIterValueTypeSameAs<decltype(v), char&>);
+
+    const std::ranges::lazy_split_view<V, P> cv;
+    static_assert(OuterIterConceptSameAs<decltype(cv), std::forward_iterator_tag>);
+    static_assert(InnerIterValueTypeSameAs<decltype(cv), const char&>);
+  }
+
+  // non-const: forward_range<View> && !simple-view<View> -> outer-iterator<Const = false>
+  // const: forward_range<View> && !forward_range<const View> -> disabled
+  {
+    using V = ForwardOnlyIfNonConstView;
+    using P = V;
+
+    static_assert(std::ranges::forward_range<V>);
+    static_assert(!std::ranges::forward_range<const V>);
+    LIBCPP_STATIC_ASSERT(!std::ranges::__simple_view<V>);
+    LIBCPP_STATIC_ASSERT(!std::ranges::__simple_view<P>);
+
+    std::ranges::lazy_split_view<V, P> v;
+    static_assert(OuterIterConceptSameAs<decltype(v), std::forward_iterator_tag>);
+    static_assert(InnerIterValueTypeSameAs<decltype(v), const char&>);
+
+    static_assert(ConstBeginDisabled<decltype(v)>);
+  }
+
+  // non-const: !forward_range<View> && tiny-range<Pattern> -> outer-iterator<Const = false>
+  // const: !forward_range<View> -> disabled
+  {
+    using V = InputView;
+    using P = ForwardTinyView;
+
+    static_assert(!std::ranges::forward_range<V>);
+    static_assert(std::ranges::forward_range<P>);
+
+    std::ranges::lazy_split_view<V, P> v;
+    static_assert(OuterIterConceptSameAs<decltype(v), std::input_iterator_tag>);
+    static_assert(InnerIterValueTypeSameAs<decltype(v), int&>);
+
+    static_assert(ConstBeginDisabled<decltype(v)>);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.lazy.split/ctad.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 R, class P>
+// lazy_split_view(R&&, P&&) -> lazy_split_view<views::all_t<R>, views::all_t<P>>;
+//
+// template <input_range R>
+// lazy_split_view(R&&, range_value_t<R>) -> lazy_split_view<views::all_t<R>, single_view<range_value_t<R>>>;
+
+#include <ranges>
+
+#include <concepts>
+#include <type_traits>
+#include <utility>
+#include "types.h"
+
+template <class I1, class I2, class Expected>
+constexpr void test() {
+  I1 i1{};
+  I2 i2{};
+
+  std::ranges::lazy_split_view v(std::move(i1), std::move(i2));
+  using O = decltype(std::move(v).base());
+  static_assert(std::same_as<O, Expected>);
+}
+
+constexpr void testCtad() {
+  // (Range, Pattern)
+  test<ForwardView, ForwardView, ForwardView>();
+  test<ForwardRange, ForwardRange, std::ranges::views::all_t<ForwardRange>>();
+
+  // (Range, RangeElement)
+  test<ForwardRange, char, std::ranges::views::all_t<ForwardRange>>();
+  test<InputRange, char, std::ranges::views::all_t<InputRange>>();
+
+  // (Range, RangeElement) with implicit conversion.
+  test<ForwardRange, bool, std::ranges::views::all_t<ForwardRange>>();
+  test<InputRange, bool, std::ranges::views::all_t<InputRange>>();
+
+  // Note: CTAD from (InputRange, TinyForwardRange) doesn't work -- the deduction guide wraps the pattern in
+  // `views::all_t`, resulting in `views::owning_view<TinyForwardRange>`. That type would never satisfy `tiny-range`
+  // because `views::owning_view` contains a member function `size()` that shadows the static `size()` in
+  // `TinyForwardRange`.
+}

libcxx/test/std/ranges/range.adaptors/range.lazy.split/ctor.default.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
+
+//  lazy_split_view() requires default_initializable<V> && default_initializable<P> = default;
+
+#include <ranges>
+
+#include <cassert>
+#include "test_macros.h"
+#include "types.h"
+
+static_assert( std::is_default_constructible_v<std::ranges::lazy_split_view<ForwardView, ForwardView>>);
+static_assert(!std::is_default_constructible_v<std::ranges::lazy_split_view<NoDefaultCtorForwardView, ForwardView>>);
+static_assert(!std::is_default_constructible_v<std::ranges::lazy_split_view<ForwardView, NoDefaultCtorForwardView>>);
+
+LIBCPP_STATIC_ASSERT( std::is_nothrow_default_constructible_v<std::ranges::lazy_split_view<ForwardView, ForwardView>>);
+static_assert(!std::is_nothrow_default_constructible_v<ThrowingDefaultCtorForwardView>);
+static_assert(!std::is_nothrow_default_constructible_v<
+    std::ranges::lazy_split_view<ThrowingDefaultCtorForwardView, ForwardView>>);
+
+constexpr bool test() {
+  std::ranges::lazy_split_view<CopyableView, ForwardView> v;
+  assert(v.base() == CopyableView());
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.lazy.split/ctor.range.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 <input_range Range>
+//   requires constructible_from<View, views::all_t<Range>> &&
+//             constructible_from<Pattern, single_view<range_value_t<Range>>>
+// constexpr lazy_split_view(Range&& r, range_value_t<Range> e);
+
+#include <ranges>
+
+#include <cassert>
+#include <string_view>
+#include <utility>
+#include "types.h"
+
+template <class V, class P, class R, class D>
+concept CanConstruct = requires(R&& r, D&& d) {
+  std::ranges::lazy_split_view<V, P>(std::forward<R>(r), std::move(d));
+};
+
+static_assert( CanConstruct<std::string_view, std::string_view, std::string_view, char>);
+static_assert( CanConstruct<std::string_view, std::string_view, char(&)[5], char>);
+
+struct Empty {};
+static_assert(!CanConstruct<std::string_view, std::string_view, Empty, std::string_view>);
+static_assert(!CanConstruct<std::string_view, std::string_view, std::string_view, Empty>);
+
+constexpr bool test() {
+  decltype(auto) str = "abc def";
+  std::ranges::lazy_split_view<std::string_view, std::string_view> v(str, ' ');
+  assert(v.base() == std::string_view(str, sizeof(str)));
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.lazy.split/ctor.view.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
+
+// constexpr lazy_split_view(View base, Pattern pattern);
+
+#include <ranges>
+
+#include <cassert>
+#include <string_view>
+
+constexpr bool test() {
+  constexpr std::string_view str = "abc def";
+  std::ranges::lazy_split_view<std::string_view, std::string_view> v(str, " ");
+  assert(v.base() == str);
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.lazy.split/end.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
+
+// constexpr auto end() requires forward_range<View> && common_range<View>;
+// constexpr auto end() const;
+
+#include <ranges>
+
+#include <cassert>
+#include <utility>
+#include "test_iterators.h"
+#include "types.h"
+
+template <class View, class Expected>
+concept OuterIterConceptSameAs =
+    std::same_as<typename decltype(std::declval<View>().end())::iterator_concept, Expected>;
+
+template <class View, class Expected>
+concept InnerIterValueTypeSameAs = requires (View v) {
+  { *(*v.end()).begin() } -> std::same_as<Expected>;
+};
+
+struct ForwardViewCommonIfConst : std::ranges::view_base {
+  std::string_view view_;
+  constexpr explicit ForwardViewCommonIfConst() = default;
+  constexpr ForwardViewCommonIfConst(const char* ptr) : view_(ptr) {}
+  constexpr ForwardViewCommonIfConst(std::string_view v) : view_(v) {}
+  constexpr ForwardViewCommonIfConst(ForwardViewCommonIfConst&&) = default;
+  constexpr ForwardViewCommonIfConst& operator=(ForwardViewCommonIfConst&&) = default;
+  constexpr ForwardViewCommonIfConst(const ForwardViewCommonIfConst&) = default;
+  constexpr ForwardViewCommonIfConst& operator=(const ForwardViewCommonIfConst&) = default;
+  constexpr forward_iterator<char*> begin() { return forward_iterator<char*>(nullptr); }
+  constexpr std::default_sentinel_t end()  { return std::default_sentinel; }
+  constexpr forward_iterator<const char*> begin() const { return forward_iterator<const char*>(view_.begin()); }
+  constexpr forward_iterator<const char*> end() const { return forward_iterator<const char*>(view_.end()); }
+};
+bool operator==(forward_iterator<char*>, std::default_sentinel_t) { return false; }
+
+struct ForwardViewNonCommonRange : std::ranges::view_base {
+  std::string_view view_;
+  constexpr explicit ForwardViewNonCommonRange() = default;
+  constexpr ForwardViewNonCommonRange(const char* ptr) : view_(ptr) {}
+  constexpr ForwardViewNonCommonRange(std::string_view v) : view_(v) {}
+  constexpr ForwardViewNonCommonRange(ForwardViewNonCommonRange&&) = default;
+  constexpr ForwardViewNonCommonRange& operator=(ForwardViewNonCommonRange&&) = default;
+  constexpr ForwardViewNonCommonRange(const ForwardViewNonCommonRange&) = default;
+  constexpr ForwardViewNonCommonRange& operator=(const ForwardViewNonCommonRange&) = default;
+  constexpr forward_iterator<char*> begin() { return forward_iterator<char*>(nullptr); }
+  constexpr std::default_sentinel_t end()  { return std::default_sentinel; }
+  constexpr forward_iterator<const char*> begin() const { return forward_iterator<const char*>(view_.begin()); }
+  constexpr std::default_sentinel_t end() const { return std::default_sentinel; }
+};
+bool operator==(forward_iterator<const char*>, std::default_sentinel_t) { return false; }
+
+constexpr bool test() {
+  // non-const: forward_range<V> && simple_view<V> && simple_view<P> -> outer-iterator<Const = true>
+  // const: forward_range<V> && common_range<V> -> outer-iterator<Const = true>
+  {
+    using V = ForwardView;
+    using P = V;
+
+    static_assert(std::ranges::forward_range<V>);
+    static_assert(std::ranges::common_range<const V>);
+    LIBCPP_STATIC_ASSERT(std::ranges::__simple_view<V>);
+    LIBCPP_STATIC_ASSERT(std::ranges::__simple_view<P>);
+
+    std::ranges::lazy_split_view<V, P> v;
+    static_assert(OuterIterConceptSameAs<decltype(v), std::forward_iterator_tag>);
+    static_assert(InnerIterValueTypeSameAs<decltype(v), const char&>);
+
+    const std::ranges::lazy_split_view<V, P> cv;
+    static_assert(OuterIterConceptSameAs<decltype(cv), std::forward_iterator_tag>);
+    static_assert(InnerIterValueTypeSameAs<decltype(cv), const char&>);
+  }
+
+  // non-const: forward_range<V> && common_range<V> && simple_view<V> && !simple_view<P> -> outer-iterator<Const=false>
+  // const: forward_range<V> && forward_range<const V> && common_range<const V> -> outer-iterator<Const = false>
+  {
+    using V = ForwardView;
+    using P = ForwardNonSimpleView;
+
+    static_assert(std::ranges::forward_range<V>);
+    static_assert(std::ranges::common_range<V>);
+    LIBCPP_STATIC_ASSERT(std::ranges::__simple_view<V>);
+    LIBCPP_STATIC_ASSERT(!std::ranges::__simple_view<P>);
+    static_assert(std::ranges::forward_range<const V>);
+    static_assert(std::ranges::common_range<const V>);
+
+    std::ranges::lazy_split_view<V, P> v;
+    static_assert(OuterIterConceptSameAs<decltype(v), std::forward_iterator_tag>);
+    static_assert(InnerIterValueTypeSameAs<decltype(v), const char&>);
+
+    const std::ranges::lazy_split_view<V, P> cv;
+    static_assert(OuterIterConceptSameAs<decltype(cv), std::forward_iterator_tag>);
+    static_assert(InnerIterValueTypeSameAs<decltype(cv), const char&>);
+  }
+
+  // non-const: forward_range<V> && !common_range<V> -> disabled
+  // const: forward_range<V> && forward_range<const V> && common_range<const V> -> outer-iterator<Const = true>
+  {
+    using V = ForwardViewCommonIfConst;
+    using P = V;
+
+    static_assert(std::ranges::forward_range<V>);
+    static_assert(!std::ranges::common_range<V>);
+    static_assert(std::ranges::forward_range<const V>);
+    static_assert(std::ranges::common_range<const V>);
+
+    std::ranges::lazy_split_view<V, P> v;
+    static_assert(OuterIterConceptSameAs<decltype(v), std::forward_iterator_tag>);
+    static_assert(InnerIterValueTypeSameAs<decltype(v), const char&>);
+
+    const std::ranges::lazy_split_view<V, P> cv;
+    static_assert(OuterIterConceptSameAs<decltype(cv), std::forward_iterator_tag>);
+    static_assert(InnerIterValueTypeSameAs<decltype(cv), const char&>);
+  }
+
+  // non-const: forward_range<V> && !common_range<V> -> disabled
+  // const: forward_range<V> && forward_range<const V> && !common_range<const V> -> outer-iterator<Const = false>
+  {
+    using V = ForwardViewNonCommonRange;
+    using P = V;
+
+    static_assert(std::ranges::forward_range<V>);
+    static_assert(!std::ranges::common_range<V>);
+    static_assert(std::ranges::forward_range<const V>);
+    static_assert(!std::ranges::common_range<const V>);
+
+    std::ranges::lazy_split_view<V, P> v;
+    static_assert(std::same_as<decltype(v.end()), std::default_sentinel_t>);
+
+    const std::ranges::lazy_split_view<V, P> cv;
+    static_assert(std::same_as<decltype(cv.end()), std::default_sentinel_t>);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.lazy.split/general.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::lazy_split_view;
+
+#include <ranges>
+
+#include <algorithm>
+#include <array>
+#include <cassert>
+#include <string_view>
+#include <utility>
+
+template <class L, class R>
+constexpr bool eq(const L& left, const R& right) {
+  auto l = left.begin();
+  auto r = right.begin();
+
+  for (; l != left.end(); ++l, ++r) {
+    if (r == right.end()) {
+      auto next = l;
+      ++next;
+      return *l == '\0' && next == left.end();
+    }
+    if (*l != *r) return false;
+  }
+
+  return r == right.end();
+}
+
+template <class T, size_t N, class Separator, class U, size_t M>
+constexpr bool test(const T (&input)[N], Separator separator, std::array<U, M> expected) {
+  std::ranges::lazy_split_view v(input, separator);
+
+  return std::equal(v.begin(), v.end(), expected.begin(), expected.end(),
+      [](const auto& split_value, const auto& expected_value) {
+        // TODO(varconst): use `std::ranges::equal`.
+        return eq(split_value, expected_value);
+  });
+}
+
+template <class T, size_t N, class Separator, class U, size_t M>
+constexpr bool test_with_piping(const T (&input)[N], Separator separator, std::array<U, M> expected) {
+  auto expected_it = expected.begin();
+  for (auto e : input | std::ranges::views::lazy_split(separator)) {
+    // TODO(varconst): use `std::ranges::equal`.
+    if (expected_it == expected.end()) return false;
+
+    if (!eq(e, *expected_it)) return false;
+    ++expected_it;
+  }
+
+  return expected_it == expected.end();
+}
+
+constexpr bool test_l_r_values() {
+  using namespace std::string_view_literals;
+
+  // Both lvalues and rvalues can be used as input.
+  {
+    // Lvalues.
+    {
+      std::string_view input = "abc";
+      std::string_view sep = " ";
+      std::ranges::lazy_split_view v(input, sep);
+      (void)v;
+    }
+
+    // Const lvalues.
+    {
+      const std::string_view input = "abc";
+      const std::string_view sep = " ";
+      std::ranges::lazy_split_view v(input, sep);
+      (void)v;
+    }
+
+    // Rvalues.
+    {
+      std::ranges::lazy_split_view v("abc"sv, " "sv);
+      (void)v;
+    }
+
+    // Const rvalues.
+    {
+      const std::string_view input = "abc";
+      const std::string_view sep = " ";
+      std::ranges::lazy_split_view v(std::move(input), std::move(sep));
+      (void)v;
+    }
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  using namespace std::string_view_literals;
+
+  constexpr char short_sep = ' ';
+  constexpr std::string_view long_sep = "12";
+
+  // One separator.
+  {
+    {
+      decltype(auto) input = "abc def";
+      constexpr std::array expected = {"abc"sv, "def"sv};
+
+      assert(test(input, short_sep, expected));
+      static_assert(test(input, short_sep, expected));
+      assert(test_with_piping(input, short_sep, expected));
+      static_assert(test_with_piping(input, short_sep, expected));
+    }
+
+    {
+      decltype(auto) input = "abc12def";
+      constexpr std::array expected = {"abc"sv, "def"sv};
+
+      assert(test(input, long_sep, expected));
+      static_assert(test(input, long_sep, expected));
+      assert(test_with_piping(input, long_sep, expected));
+      static_assert(test_with_piping(input, long_sep, expected));
+    }
+  }
+
+  // Several separators in a row.
+  {
+    {
+      decltype(auto) input = "abc    def";
+      constexpr std::array expected = {"abc"sv, ""sv, ""sv, ""sv, "def"sv};
+
+      assert(test(input, short_sep, expected));
+      static_assert(test(input, short_sep, expected));
+      assert(test_with_piping(input, short_sep, expected));
+      static_assert(test_with_piping(input, short_sep, expected));
+    }
+
+    {
+      decltype(auto) input = "abc12121212def";
+      constexpr std::array expected = {"abc"sv, ""sv, ""sv, ""sv, "def"sv};
+
+      assert(test(input, long_sep, expected));
+      static_assert(test(input, long_sep, expected));
+      assert(test_with_piping(input, long_sep, expected));
+      static_assert(test_with_piping(input, long_sep, expected));
+    }
+  }
+
+  // Trailing separator.
+  {
+    {
+      decltype(auto) input = "abc def ";
+      constexpr std::array expected = {"abc"sv, "def"sv, ""sv};
+
+      assert(test(input, short_sep, expected));
+      static_assert(test(input, short_sep, expected));
+      assert(test_with_piping(input, short_sep, expected));
+      static_assert(test_with_piping(input, short_sep, expected));
+    }
+
+    {
+      decltype(auto) input = "abc12def12";
+      constexpr std::array expected = {"abc"sv, "def"sv, ""sv};
+
+      assert(test(input, long_sep, expected));
+      static_assert(test(input, long_sep, expected));
+      assert(test_with_piping(input, long_sep, expected));
+      static_assert(test_with_piping(input, long_sep, expected));
+    }
+  }
+
+  // Leading separator.
+  {
+    {
+      decltype(auto) input = " abc def";
+      constexpr std::array expected = {""sv, "abc"sv, "def"sv};
+
+      assert(test(input, short_sep, expected));
+      static_assert(test(input, short_sep, expected));
+      assert(test_with_piping(input, short_sep, expected));
+      static_assert(test_with_piping(input, short_sep, expected));
+    }
+
+    {
+      decltype(auto) input = "12abc12def";
+      constexpr std::array expected = {""sv, "abc"sv, "def"sv};
+
+      assert(test(input, long_sep, expected));
+      static_assert(test(input, long_sep, expected));
+      assert(test_with_piping(input, long_sep, expected));
+      static_assert(test_with_piping(input, long_sep, expected));
+    }
+  }
+
+  // No separator.
+  {
+    {
+      decltype(auto) input = "abc";
+      constexpr std::array expected = {"abc"sv};
+
+      assert(test(input, short_sep, expected));
+      static_assert(test(input, short_sep, expected));
+      assert(test_with_piping(input, short_sep, expected));
+      static_assert(test_with_piping(input, short_sep, expected));
+    }
+
+    {
+      decltype(auto) input = "abc";
+      constexpr std::array expected = {"abc"sv};
+
+      assert(test(input, long_sep, expected));
+      static_assert(test(input, long_sep, expected));
+      assert(test_with_piping(input, long_sep, expected));
+      static_assert(test_with_piping(input, long_sep, expected));
+    }
+  }
+
+  // Empty string.
+  {
+    {
+      decltype(auto) input = "";
+      constexpr std::array expected = {""sv};
+
+      assert(test(input, short_sep, expected));
+      static_assert(test(input, short_sep, expected));
+      assert(test_with_piping(input, short_sep, expected));
+      static_assert(test_with_piping(input, short_sep, expected));
+    }
+
+    {
+      decltype(auto) input = "";
+      constexpr std::array expected = {""sv};
+
+      assert(test(input, long_sep, expected));
+      static_assert(test(input, long_sep, expected));
+      assert(test_with_piping(input, long_sep, expected));
+      static_assert(test_with_piping(input, long_sep, expected));
+    }
+  }
+
+  // Input consisting of a single separator.
+  {
+    {
+      decltype(auto) input = " ";
+      constexpr std::array expected = {""sv, ""sv};
+
+      assert(test(input, short_sep, expected));
+      static_assert(test(input, short_sep, expected));
+      assert(test_with_piping(input, short_sep, expected));
+      static_assert(test_with_piping(input, short_sep, expected));
+    }
+
+    {
+      decltype(auto) input = "12";
+      constexpr std::array expected = {""sv, ""sv};
+
+      assert(test(input, long_sep, expected));
+      static_assert(test(input, long_sep, expected));
+      assert(test_with_piping(input, long_sep, expected));
+      static_assert(test_with_piping(input, long_sep, expected));
+    }
+  }
+
+  // Input consisting of only separators.
+  {
+    {
+      decltype(auto) input = "   ";
+      constexpr std::array expected = {""sv, ""sv, ""sv, ""sv};
+
+      assert(test(input, short_sep, expected));
+      static_assert(test(input, short_sep, expected));
+      assert(test_with_piping(input, short_sep, expected));
+      static_assert(test_with_piping(input, short_sep, expected));
+    }
+
+    {
+      decltype(auto) input = "121212";
+      constexpr std::array expected = {""sv, ""sv, ""sv, ""sv};
+
+      assert(test(input, long_sep, expected));
+      static_assert(test(input, long_sep, expected));
+      assert(test_with_piping(input, long_sep, expected));
+      static_assert(test_with_piping(input, long_sep, expected));
+    }
+  }
+
+  // Many redundant separators.
+  {
+    {
+      decltype(auto) input = "  abc   def  ";
+      constexpr std::array expected = {""sv, ""sv, "abc"sv, ""sv, ""sv, "def"sv, ""sv, ""sv};
+
+      assert(test(input, short_sep, expected));
+      static_assert(test(input, short_sep, expected));
+      assert(test_with_piping(input, short_sep, expected));
+      static_assert(test_with_piping(input, short_sep, expected));
+    }
+
+    {
+      decltype(auto) input = "1212abc121212def1212";
+      constexpr std::array expected = {""sv, ""sv, "abc"sv, ""sv, ""sv, "def"sv, ""sv, ""sv};
+
+      assert(test(input, long_sep, expected));
+      static_assert(test(input, long_sep, expected));
+      assert(test_with_piping(input, long_sep, expected));
+      static_assert(test_with_piping(input, long_sep, expected));
+    }
+  }
+
+  // Separators after every character.
+  {
+    {
+      decltype(auto) input = " a b c ";
+      constexpr std::array expected = {""sv, "a"sv, "b"sv, "c"sv, ""sv};
+
+      assert(test(input, short_sep, expected));
+      static_assert(test(input, short_sep, expected));
+      assert(test_with_piping(input, short_sep, expected));
+      static_assert(test_with_piping(input, short_sep, expected));
+    }
+
+    {
+      decltype(auto) input = "12a12b12c12";
+      constexpr std::array expected = {""sv, "a"sv, "b"sv, "c"sv, ""sv};
+
+      assert(test(input, long_sep, expected));
+      static_assert(test(input, long_sep, expected));
+      assert(test_with_piping(input, long_sep, expected));
+      static_assert(test_with_piping(input, long_sep, expected));
+    }
+  }
+
+  // Empty separator.
+  {
+    {
+      constexpr std::string_view empty_sep = "";
+
+      decltype(auto) input = "abc";
+      constexpr std::array expected = {"a"sv, "b"sv, "c"sv, ""sv};
+
+      assert(test(input, empty_sep, expected));
+      static_assert(test(input, empty_sep, expected));
+      assert(test_with_piping(input, empty_sep, expected));
+      static_assert(test_with_piping(input, empty_sep, expected));
+    }
+  }
+
+  // Overlap between the separator and the string.
+  {
+    {
+      constexpr std::string_view overlapping_sep = "ab";
+
+      decltype(auto) input = "aabaaababb";
+      constexpr std::array expected = {"a"sv, "aa"sv, ""sv, "b"sv};
+
+      assert(test(input, overlapping_sep, expected));
+      static_assert(test(input, overlapping_sep, expected));
+      assert(test_with_piping(input, overlapping_sep, expected));
+      static_assert(test_with_piping(input, overlapping_sep, expected));
+    }
+  }
+
+  // Non-character input.
+  {
+    {
+      constexpr int sep = 0;
+      constexpr int input[] = {1, 2, 3, 0, 4, 5, 6};
+      constexpr std::array expected = {std::array{1, 2, 3}, std::array{4, 5, 6}};
+
+      assert(test(input, sep, expected));
+      static_assert(test(input, sep, expected));
+      assert(test_with_piping(input, sep, expected));
+      static_assert(test_with_piping(input, sep, expected));
+    }
+
+    {
+      constexpr std::array sep = {0, 0, 0};
+      constexpr int input[] = {1, 2, 3, 0, 0, 0, 4, 5, 6};
+      constexpr std::array expected = {std::array{1, 2, 3}, std::array{4, 5, 6}};
+
+      assert(test(input, sep, expected));
+      static_assert(test(input, sep, expected));
+      assert(test_with_piping(input, sep, expected));
+      static_assert(test_with_piping(input, sep, expected));
+    }
+  }
+
+  assert(test_l_r_values());
+  static_assert(test_l_r_values());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.lazy.split/range.lazy.split.outer.value/begin.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
+
+// std::ranges::lazy_split_view::outer-iterator::value_type::begin()
+
+#include <ranges>
+
+#include <cassert>
+#include <string_view>
+#include <type_traits>
+#include <utility>
+
+constexpr bool test() {
+  using View = std::ranges::lazy_split_view<std::string_view, std::string_view>;
+  std::string_view input = "a";
+
+  // Non-const.
+  {
+    View v(input, "b");
+    auto val = *v.begin();
+    assert(val.begin().base() == input);
+  }
+
+  // Const.
+  {
+    View v(input, "b");
+    const auto val = *v.begin();
+    assert(val.begin().base() == input);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  assert(test());
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.lazy.split/range.lazy.split.outer.value/ctor.default.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
+
+// std::ranges::lazy_split_view::outer-iterator::value_type::value_type()
+
+#include <ranges>
+
+#include <cassert>
+#include <string_view>
+#include <type_traits>
+#include <utility>
+
+using View = std::ranges::lazy_split_view<std::string_view, std::string_view>;
+using ValueType = decltype(*std::declval<View>().begin());
+static_assert(std::is_default_constructible_v<ValueType>);
+
+int main(int, char**) {
+  ValueType val;
+  (void)val;
+
+  constexpr ValueType val2;
+  (void)val2;
+  // Note: attempting a check like `val.begin() == val.end()` leads to null pointer dereference.
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.lazy.split/range.lazy.split.outer.value/ctor.iter.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
+
+// std::ranges::lazy_split_view::outer-iterator::value_type::value_type(outer-iterator i)
+
+#include <ranges>
+
+#include <cassert>
+#include <string_view>
+#include <type_traits>
+#include <utility>
+
+using View = std::ranges::lazy_split_view<std::string_view, std::string_view>;
+using ValueType = decltype(*std::declval<View>().begin());
+static_assert(std::is_constructible_v<ValueType, std::ranges::iterator_t<View>>);
+
+constexpr bool test() {
+  std::string_view input = "a";
+  View v(input, "b");
+  ValueType val(v.begin());
+  return val.begin().base() == input;
+}
+
+int main(int, char**) {
+  assert(test());
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.lazy.split/range.lazy.split.outer.value/end.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
+
+// std::ranges::lazy_split_view::outer-iterator::value_type::end()
+
+#include <ranges>
+
+#include <cassert>
+#include <string_view>
+#include <utility>
+
+constexpr bool test() {
+  using View = std::ranges::lazy_split_view<std::string_view, std::string_view>;
+  std::string_view input = "a";
+
+  // Non-const.
+  {
+    View v(input, "b");
+    auto val = *v.begin();
+    static_assert(std::same_as<decltype(val.end()), std::default_sentinel_t>);
+  }
+
+  // Const.
+  {
+    View v(input, "b");
+    const auto val = *v.begin();
+    static_assert(std::same_as<decltype(val.end()), std::default_sentinel_t>);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  assert(test());
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.lazy.split/range.lazy.split.outer/ctor.copy.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
+
+#include <ranges>
+
+int main(int, char**) {
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.lazy.split/range.lazy.split.outer/ctor.current.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
+
+#include <ranges>
+
+int main(int, char**) {
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.lazy.split/range.lazy.split.outer/ctor.default.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
+
+// std::ranges::lazy_split_view::outer-iterator::outer-iterator()
+
+#include <ranges>
+
+#include <cassert>
+#include <string_view>
+#include <type_traits>
+#include <utility>
+
+using View = std::ranges::lazy_split_view<std::string_view, std::string_view>;
+using OuterIter = decltype(std::declval<View>().begin());
+static_assert(std::is_default_constructible_v<OuterIter>);
+
+int main(int, char**) {
+  OuterIter i;
+  (void)i;
+  constexpr OuterIter i2;
+  (void)i2;
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.lazy.split/range.lazy.split.outer/ctor.parent.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
+
+// std::ranges::lazy_split_view::outer-iterator::outer-iterator(Parent& parent)
+//   requires (!forward_range<Base>)
+
+#include <ranges>
+
+#include <cassert>
+#include <string_view>
+#include <type_traits>
+#include <utility>
+#include "../types.h"
+
+using SplitView = std::ranges::lazy_split_view<std::string_view, std::string_view>;
+using OuterIter = decltype(std::declval<SplitView>().begin());
+static_assert(std::ranges::forward_range<SplitView>);
+static_assert(!std::is_constructible_v<OuterIter, const SplitView&>);
+
+using SplitViewInput = std::ranges::lazy_split_view<InputView, ForwardTinyView>;
+using OuterIterInput = decltype(std::declval<SplitViewInput>().begin());
+// TODO(varconst): uncomment once `lazy_split_view` can use `ranges::find`.
+//static_assert(!std::ranges::forward_range<SplitViewInput>);
+//static_assert(std::is_constructible_v<OuterIterInput, SplitViewInput&>);
+
+constexpr bool test() {
+  InputView input;
+  SplitViewInput v(input, ForwardTinyView());
+
+  OuterIterInput i(v);
+  (void)v;
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.lazy.split/range.lazy.split.outer/equal.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
+
+#include <ranges>
+
+int main(int, char**) {
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.lazy.split/range.lazy.split.outer/increment.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
+
+#include <ranges>
+
+int main(int, char**) {
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.lazy.split/range.lazy.split.outer/star.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
+
+#include <ranges>
+
+int main(int, char**) {
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.lazy.split/range.lazy.split.outer/types.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::lazy_split_view::outer-iterator;
+
+#include <ranges>
+
+#include <concepts>
+#include <iterator>
+#include "../types.h"
+
+template <class Range, class Pattern>
+using OuterIter = decltype(std::declval<std::ranges::lazy_split_view<Range, Pattern>>().begin());
+
+// iterator_concept
+
+static_assert(std::same_as<typename OuterIter<ForwardView, ForwardView>::iterator_concept, std::forward_iterator_tag>);
+static_assert(std::same_as<typename OuterIter<InputView, ForwardTinyView>::iterator_concept, std::input_iterator_tag>);
+
+// iterator_category
+
+static_assert(std::same_as<typename OuterIter<ForwardView, ForwardView>::iterator_category, std::input_iterator_tag>);
+
+template <class Range, class Pattern>
+concept NoIteratorCategory = !requires { typename OuterIter<Range, Pattern>::iterator_category; };
+static_assert(NoIteratorCategory<InputView, ForwardTinyView>);
+
+// difference_type
+
+static_assert(std::same_as<typename OuterIter<ForwardView, ForwardView>::difference_type,
+    std::ranges::range_difference_t<ForwardView>>);

libcxx/test/std/ranges/range.adaptors/range.lazy.split/types.h

+//===----------------------------------------------------------------------===//
+//
+// 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 TEST_STD_RANGES_RANGE_ADAPTORS_RANGE_LAZY_SPLIT_TYPES_H
+#define TEST_STD_RANGES_RANGE_ADAPTORS_RANGE_LAZY_SPLIT_TYPES_H
+
+#include <ranges>
+#include <string_view>
+#include "test_iterators.h"
+
+int globalBuff[8];
+
+struct MoveOnlyView : std::ranges::view_base {
+  std::string_view view_;
+  constexpr MoveOnlyView() = default;
+  constexpr MoveOnlyView(const char* ptr) : view_(ptr) {}
+  constexpr MoveOnlyView(std::string_view v) : view_(v) {}
+  constexpr MoveOnlyView(MoveOnlyView&&) = default;
+  constexpr MoveOnlyView& operator=(MoveOnlyView&&) = default;
+  constexpr const char* begin() const { return view_.begin(); }
+  constexpr const char* end() const { return view_.end(); }
+  constexpr bool operator==(MoveOnlyView rhs) const { return view_ == rhs.view_; }
+};
+static_assert( std::ranges::view<MoveOnlyView>);
+static_assert( std::ranges::contiguous_range<MoveOnlyView>);
+static_assert(!std::copyable<MoveOnlyView>);
+
+struct CopyableView : std::ranges::view_base {
+  int start_;
+  constexpr explicit CopyableView(int start = 0) : start_(start) {}
+  constexpr CopyableView(CopyableView const&) = default;
+  constexpr CopyableView& operator=(CopyableView const&) = default;
+  constexpr int *begin() const { return globalBuff + start_; }
+  constexpr int *end() const { return globalBuff + 8; }
+  constexpr bool operator==(CopyableView rhs) const { return start_ == rhs.start_; }
+};
+
+using ForwardIter = forward_iterator<int*>;
+
+struct ForwardView : std::ranges::view_base {
+  std::string_view view_;
+  constexpr explicit ForwardView() = default;
+  constexpr ForwardView(const char* ptr) : view_(ptr) {}
+  constexpr ForwardView(std::string_view v) : view_(v) {}
+  constexpr ForwardView(ForwardView&&) = default;
+  constexpr ForwardView& operator=(ForwardView&&) = default;
+  constexpr forward_iterator<const char*> begin() const { return forward_iterator<const char*>(view_.begin()); }
+  constexpr forward_iterator<const char*> end() const { return forward_iterator<const char*>(view_.end()); }
+};
+
+// Iterator types differ based on constness of this class.
+struct ForwardDiffView : std::ranges::view_base {
+  std::string_view view_;
+  constexpr explicit ForwardDiffView() = default;
+  constexpr ForwardDiffView(const char* ptr) : view_(ptr) {}
+  constexpr ForwardDiffView(std::string_view v) : view_(v) {}
+  constexpr ForwardDiffView(ForwardDiffView&&) = default;
+  constexpr ForwardDiffView& operator=(ForwardDiffView&&) = default;
+  constexpr ForwardDiffView(const ForwardDiffView&) = default;
+  constexpr ForwardDiffView& operator=(const ForwardDiffView&) = default;
+  constexpr forward_iterator<char*> begin() { return forward_iterator<char*>(nullptr); }
+  constexpr forward_iterator<char*> end()  { return forward_iterator<char*>(nullptr); }
+  constexpr forward_iterator<const char*> begin() const { return forward_iterator<const char*>(view_.begin()); }
+  constexpr forward_iterator<const char*> end() const { return forward_iterator<const char*>(view_.end()); }
+};
+
+struct ForwardNonSimpleView : std::ranges::view_base {
+  std::string_view view_;
+  constexpr explicit ForwardNonSimpleView() = default;
+  constexpr ForwardNonSimpleView(const char* ptr) : view_(ptr) {}
+  constexpr ForwardNonSimpleView(std::string_view v) : view_(v) {}
+  constexpr ForwardNonSimpleView(ForwardNonSimpleView&&) = default;
+  constexpr ForwardNonSimpleView& operator=(ForwardNonSimpleView&&) = default;
+  constexpr forward_iterator<const char*> begin() { return forward_iterator<const char*>(view_.begin()); }
+  constexpr forward_iterator<const char*> end() { return forward_iterator<const char*>(view_.end()); }
+  constexpr cpp20_input_iterator<const char*> begin() const { return cpp20_input_iterator<const char*>(view_.begin()); }
+  constexpr cpp20_input_iterator<const char*> end() const { return cpp20_input_iterator<const char*>(view_.end()); }
+};
+
+struct ForwardTinyView : ForwardView {
+  ForwardTinyView() = default;
+  constexpr static size_t size() { return 1; }
+};
+
+template <class It>
+class almost_forward_iterator {
+    It it_;
+
+    template <class U> friend class almost_forward_iterator;
+
+public:
+    typedef          std::forward_iterator_tag                 iterator_category;
+    typedef typename std::iterator_traits<It>::value_type      value_type;
+    typedef typename std::iterator_traits<It>::difference_type difference_type;
+    typedef It                                                 pointer;
+    typedef typename std::iterator_traits<It>::reference       reference;
+
+    TEST_CONSTEXPR almost_forward_iterator() : it_() {}
+    TEST_CONSTEXPR explicit almost_forward_iterator(It it) : it_(it) {}
+    template <class U>
+        TEST_CONSTEXPR almost_forward_iterator(const almost_forward_iterator<U>& u) : it_(u.it_) {}
+
+    TEST_CONSTEXPR reference operator*() const {return *it_;}
+    TEST_CONSTEXPR pointer operator->() const {return it_;}
+
+    TEST_CONSTEXPR_CXX14 almost_forward_iterator& operator++() { ++it_; return *this; }
+    // Notice the slightly different return type.
+    TEST_CONSTEXPR_CXX14 const almost_forward_iterator operator++(int) {return almost_forward_iterator(it_);}
+
+    friend TEST_CONSTEXPR bool operator==(const almost_forward_iterator& x, const almost_forward_iterator& y) {return x.it_ == y.it_;}
+    friend TEST_CONSTEXPR bool operator!=(const almost_forward_iterator& x, const almost_forward_iterator& y) {return x.it_ != y.it_;}
+
+    template <class T>
+    void operator,(T const &) = delete;
+};
+
+struct ForwardOnlyIfNonConstView : std::ranges::view_base {
+  std::string_view view_;
+
+  constexpr explicit ForwardOnlyIfNonConstView() = default;
+  constexpr ForwardOnlyIfNonConstView(const char* ptr) : view_(ptr) {}
+  constexpr ForwardOnlyIfNonConstView(std::string_view v) : view_(v) {}
+  constexpr ForwardOnlyIfNonConstView(ForwardOnlyIfNonConstView&&) = default;
+  constexpr ForwardOnlyIfNonConstView& operator=(ForwardOnlyIfNonConstView&&) = default;
+
+  constexpr forward_iterator<const char*> begin() { return forward_iterator<const char*>(view_.begin()); }
+  constexpr forward_iterator<const char*> end() { return forward_iterator<const char*>(view_.end()); }
+  constexpr almost_forward_iterator<const char*> begin() const {
+    return almost_forward_iterator<const char*>(view_.begin());
+  }
+  constexpr almost_forward_iterator<const char*> end() const {
+    return almost_forward_iterator<const char*>(view_.end());
+  }
+};
+
+struct ThrowingDefaultCtorForwardView : std::ranges::view_base {
+  ThrowingDefaultCtorForwardView() noexcept(false);
+  ForwardIter begin() const;
+  ForwardIter end() const;
+};
+
+struct NoDefaultCtorForwardView : std::ranges::view_base {
+  NoDefaultCtorForwardView() = delete;
+  ForwardIter begin() const;
+  ForwardIter end() const;
+};
+
+struct InputView : std::ranges::view_base {
+  constexpr cpp20_input_iterator<int*> begin() { return cpp20_input_iterator<int*>(globalBuff); }
+  constexpr int* end() { return globalBuff + 8; }
+  constexpr cpp20_input_iterator<const int*> begin() const { return cpp20_input_iterator<const int*>(globalBuff); }
+  constexpr const int* end() const { return globalBuff + 8; }
+};
+constexpr bool operator==(const cpp20_input_iterator<int*> &lhs, int* rhs) { return lhs.base() == rhs; }
+constexpr bool operator==(int* lhs, const cpp20_input_iterator<int*> &rhs) { return rhs.base() == lhs; }
+
+struct ForwardRange {
+  ForwardIter begin() const;
+  ForwardIter end() const;
+};
+
+struct InputRange {
+  cpp20_input_iterator<const char*> begin() const;
+  std::default_sentinel_t end() const;
+};
+bool operator==(const cpp20_input_iterator<const char*>&, std::default_sentinel_t);
+static_assert(std::ranges::input_range<InputRange>);
+
+#endif // TEST_STD_RANGES_RANGE_ADAPTORS_RANGE_LAZY_SPLIT_TYPES_H

libcxx/test/std/ranges/range.adaptors/range.lazy.split/view_interface.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::lazy_split_view;
+
+#include <ranges>
+
+#include <cassert>
+#include <concepts>
+
+using V = decltype(std::ranges::lazy_split_view("abc", "d"));
+static_assert(std::ranges::forward_range<V>);
+
+// empty()
+template <class View>
+concept CanCallEmpty = requires (View& v) { v.empty(); };
+static_assert(CanCallEmpty<V>);
+
+// operator bool()
+template <class View>
+concept CanCallOperatorBool = requires (View& v) { static_cast<bool>(v); };
+static_assert(CanCallOperatorBool<V>);
+
+// front()
+template <class View>
+concept CanCallFront = requires (View& v) { v.front(); };
+static_assert(CanCallFront<V>);
+
+// size() is unavailable.
+static_assert(!std::sized_sentinel_for<std::ranges::sentinel_t<V>, std::ranges::iterator_t<V>>);
+template <class View>
+concept CanCallSize = requires (View& v) { v.size(); };
+static_assert(!CanCallSize<V>);
+
+// back() is unavailable.
+static_assert(!std::ranges::bidirectional_range<V>);
+template <class View>
+concept CanCallBack = requires (View& v) { v.back(); };
+static_assert(!CanCallBack<V>);
+
+// data() is unavailable.
+static_assert(!std::contiguous_iterator<std::ranges::iterator_t<V>>);
+template <class View>
+concept CanCallData = requires (View& v) { v.data(); };
+static_assert(!CanCallData<V>);
+
+// operator[] is unavailable.
+static_assert(!std::ranges::random_access_range<V>);
+template <class View>
+concept CanCallOperatorSubscript = requires (View& v) { v[0]; };
+static_assert(!CanCallOperatorSubscript<V>);
+
+int main(int, char**) {
+  // empty()
+  {
+    {
+      constexpr std::ranges::lazy_split_view v("abc", "");
+      assert(!v.empty());
+      static_assert(!v.empty());
+    }
+    // Note: a `lazy_split_view` is never empty.
+  }
+
+  // operator bool()
+  {
+    {
+      constexpr std::ranges::lazy_split_view v("abc", "");
+      assert(v);
+      static_assert(v);
+    }
+    // Note: a `lazy_split_view` is never empty.
+  }
+
+  // front()
+  {
+    constexpr std::ranges::lazy_split_view v("abc", "");
+    assert(*(v.front()).begin() == 'a');
+    static_assert(*(v.front()).begin() == 'a');
+  }
+
+  return 0;
+}

libcxx/test/support/test_iterators.h

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
public:
     constexpr void operator++(int) { ++it_; }
 
     constexpr const It& base() const& { return it_; } // TODO remove me
     friend constexpr It base(const cpp20_input_iterator& i) { return i.it_; }
 
     template <class T>
     void operator,(T const &) = delete;
 };
+#ifndef _LIBCPP_HAS_NO_CONCEPTS
+  static_assert(std::input_iterator<cpp20_input_iterator<int*>>);
+#endif
 
 template<std::input_or_output_iterator>
 struct iter_value_or_void { using type = void; };
 
 template<std::input_iterator I>
 struct iter_value_or_void<I> {
     using type = std::iter_value_t<I>;
 };