[libc++] Use bounded iterators in std::string_view when the debug mode is enabled

[ldionne]

Note that I thought I had fixed all of std::format's reliance on char*, but I have not so this will still fail for now.

[ldionne]

Fix assumptions of std::string_view::iterator being char*

[ldionne]

I think this looks good from the CI side. @Mordante I'll ship this if you are happy with the std::format changes.

[Mordante]

Thanks a lot for working on this and fixing the format header.
LGTM modulo some nits.

libcxx/test/std/strings/string.view/string.view.iterators/debug.iterator-indexing.pass.cpp

7 ↗

(On Diff #493372)

Why is this not a libc++ specific test?

18–20 ↗

(On Diff #493372)

Unused.

27 ↗

(On Diff #493372)

Should we also test with cfoo and crfoo?

[ldionne]

Address comments -- thanks!

libcxx/docs/ReleaseNotes.rst

 ============================
 
 Implemented Papers
 ------------------
 
 Improvements and New Features
 -----------------------------
 
+- ``std::string_view`` now provides iterators that check for out-of-bounds accesses when the safe
+  libc++ mode is enabled.
+
 Deprecations and Removals
 -------------------------
 
 - The ``<experimental/coroutine>`` header has been removed in this release. The ``<coroutine>`` header
   has been shipping since LLVM 14, so the Coroutines TS implementation is being removed per our policy
   for removing TSes.
 
 Upcoming Deprecations and Removals

libcxx/include/__chrono/formatter.h

if (*__it == _CharT('%')) {
         break;
 
       case _CharT('C'): {
         // strftime's output is only defined in the range [00, 99].
         int __year = __t.tm_year + 1900;
         if (__year < 1000 || __year > 9999)
           __formatter::__format_century(__year, __sstr);
         else
-          __facet.put({__sstr}, __sstr, _CharT(' '), std::addressof(__t), __s, __it + 1);
+          __facet.put({__sstr}, __sstr, _CharT(' '), std::addressof(__t), std::to_address(__s), std::to_address(__it + 1));
       } break;
 
       case _CharT('j'):
         if constexpr (chrono::__is_duration<_Tp>::value)
           // Converting a duration where the period has a small ratio to days
           // may fail to compile. This due to loss of precision in the
           // conversion. In order to avoid that issue convert to seconds as
           // an intemediate step.
           __sstr << chrono::duration_cast<chrono::days>(chrono::duration_cast<chrono::seconds>(__value)).count();
         else
-          __facet.put({__sstr}, __sstr, _CharT(' '), std::addressof(__t), __s, __it + 1);
+          __facet.put({__sstr}, __sstr, _CharT(' '), std::addressof(__t), std::to_address(__s), std::to_address(__it + 1));
         break;
 
       case _CharT('q'):
         if constexpr (chrono::__is_duration<_Tp>::value) {
           __sstr << chrono::__units_suffix<_CharT, typename _Tp::period>();
           break;
         }
         __builtin_unreachable();
if (*__it == _CharT('%')) {
         if constexpr (chrono::__is_duration<_Tp>::value) {
           __sstr << std::format(_LIBCPP_STATICALLY_WIDEN(_CharT, "{}"), __value.count());
           break;
         }
         __builtin_unreachable();
 
       case _CharT('S'):
       case _CharT('T'):
-        __facet.put({__sstr}, __sstr, _CharT(' '), std::addressof(__t), __s, __it + 1);
+        __facet.put({__sstr}, __sstr, _CharT(' '), std::addressof(__t), std::to_address(__s), std::to_address(__it + 1));
         if constexpr (__use_fraction<_Tp>())
           __formatter::__format_sub_seconds(__value, __sstr);
         break;
 
         // Unlike time_put and strftime the formatting library requires %Y
         //
         // [tab:time.format.spec]
         //   The year as a decimal number. If the result is less than four digits
#  if defined(__GLIBC__) || defined(_AIX)
         break;
 #  endif // defined(__GLIBC__) || defined(_AIX)
 
       case _CharT('Y'): {
         int __year = __t.tm_year + 1900;
         if (__year < 1000)
           __formatter::__format_year(__year, __sstr);
         else
-          __facet.put({__sstr}, __sstr, _CharT(' '), std::addressof(__t), __s, __it + 1);
+          __facet.put({__sstr}, __sstr, _CharT(' '), std::addressof(__t), std::to_address(__s), std::to_address(__it + 1));
       } break;
 
       case _CharT('F'): {
         int __year = __t.tm_year + 1900;
         if (__year < 1000) {
           __formatter::__format_year(__year, __sstr);
           __sstr << std::format(_LIBCPP_STATICALLY_WIDEN(_CharT, "-{:02}-{:02}"), __t.tm_mon + 1, __t.tm_mday);
         } else
-          __facet.put({__sstr}, __sstr, _CharT(' '), std::addressof(__t), __s, __it + 1);
+          __facet.put({__sstr}, __sstr, _CharT(' '), std::addressof(__t), std::to_address(__s), std::to_address(__it + 1));
       } break;
 
       case _CharT('O'):
         if constexpr (__use_fraction<_Tp>()) {
           // Handle OS using the normal representation for the non-fractional
           // part. There seems to be no locale information regarding how the
           // fractional part should be formatted.
           if (*(__it + 1) == 'S') {
             ++__it;
-            __facet.put({__sstr}, __sstr, _CharT(' '), std::addressof(__t), __s, __it + 1);
+            __facet.put({__sstr}, __sstr, _CharT(' '), std::addressof(__t), std::to_address(__s), std::to_address(__it + 1));
             __formatter::__format_sub_seconds(__value, __sstr);
             break;
           }
         }
         [[fallthrough]];
       case _CharT('E'):
         ++__it;
         [[fallthrough]];
       default:
-        __facet.put({__sstr}, __sstr, _CharT(' '), std::addressof(__t), __s, __it + 1);
+        __facet.put({__sstr}, __sstr, _CharT(' '), std::addressof(__t), std::to_address(__s), std::to_address(__it + 1));
         break;
       }
     } else {
       __sstr << *__it;
     }
   }
 }
 

libcxx/include/__chrono/parser_std_format_spec.h

 
 _LIBCPP_HIDE_FROM_ABI constexpr void __validate_time_zone(__flags __flags) {
   if ((__flags & __flags::__time_zone) != __flags::__time_zone)
     std::__throw_format_error("The supplied date time doesn't contain a time zone");
 }
 
 template <class _CharT>
 class _LIBCPP_TEMPLATE_VIS __parser_chrono {
+  using _ConstIterator = typename basic_format_parse_context<_CharT>::const_iterator;
+
 public:
   _LIBCPP_HIDE_FROM_ABI constexpr auto
   __parse(basic_format_parse_context<_CharT>& __parse_ctx, __fields __fields, __flags __flags)
       -> decltype(__parse_ctx.begin()) {
-    const _CharT* __begin = __parser_.__parse(__parse_ctx, __fields);
-    const _CharT* __end   = __parse_ctx.end();
+    _ConstIterator __begin = __parser_.__parse(__parse_ctx, __fields);
+    _ConstIterator __end   = __parse_ctx.end();
     if (__begin == __end)
       return __begin;
 
-    const _CharT* __last = __parse_chrono_specs(__begin, __end, __flags);
-    __chrono_specs_      = basic_string_view<_CharT>{__begin, __last};
+    _ConstIterator __last = __parse_chrono_specs(__begin, __end, __flags);
+    __chrono_specs_       = basic_string_view<_CharT>{__begin, __last};
 
     return __last;
   }
 
   __parser<_CharT> __parser_;
   basic_string_view<_CharT> __chrono_specs_;
 
 private:
-  _LIBCPP_HIDE_FROM_ABI constexpr const _CharT*
-  __parse_chrono_specs(const _CharT* __begin, const _CharT* __end, __flags __flags) {
+  _LIBCPP_HIDE_FROM_ABI constexpr _ConstIterator
+  __parse_chrono_specs(_ConstIterator __begin, _ConstIterator __end, __flags __flags) {
     _LIBCPP_ASSERT(__begin != __end,
                    "When called with an empty input the function will cause "
                    "undefined behavior by evaluating data not in the input");
 
     if (*__begin != _CharT('%') && *__begin != _CharT('}'))
       std::__throw_format_error("Expected '%' or '}' in the chrono format-string");
 
     do {
__parse_chrono_specs(_ConstIterator __begin, _ConstIterator __end, __flags __flags) {
     } while (__begin != __end && *__begin != _CharT('}'));
 
     return __begin;
   }
 
   /// \pre *__begin == '%'
   /// \post __begin points at the end parsed conversion-spec
   _LIBCPP_HIDE_FROM_ABI constexpr void
-  __parse_conversion_spec(const _CharT*& __begin, const _CharT* __end, __flags __flags) {
+  __parse_conversion_spec(_ConstIterator& __begin, _ConstIterator __end, __flags __flags) {
     ++__begin;
     if (__begin == __end)
       std::__throw_format_error("End of input while parsing the modifier chrono conversion-spec");
 
     switch (*__begin) {
     case _CharT('n'):
     case _CharT('t'):
     case _CharT('%'):
__parse_conversion_spec(_ConstIterator& __begin, _ConstIterator __end, __flags __flags) {
     default: // unknown type;
       std::__throw_format_error("The date time type specifier is invalid");
     }
   }
 
   /// \pre *__begin == 'E'
   /// \post __begin is incremented by one.
   _LIBCPP_HIDE_FROM_ABI constexpr void
-  __parse_modifier_E(const _CharT*& __begin, const _CharT* __end, __flags __flags) {
+  __parse_modifier_E(_ConstIterator& __begin, _ConstIterator __end, __flags __flags) {
     ++__begin;
     if (__begin == __end)
       std::__throw_format_error("End of input while parsing the modifier E");
 
     switch (*__begin) {
     case _CharT('X'):
       __format_spec::__validate_time(__flags);
       break;
__parse_modifier_E(_ConstIterator& __begin, _ConstIterator __end, __flags __flags) {
     default:
       std::__throw_format_error("The date time type specifier for modifier E is invalid");
     }
   }
 
   /// \pre *__begin == 'O'
   /// \post __begin is incremented by one.
   _LIBCPP_HIDE_FROM_ABI constexpr void
-  __parse_modifier_O(const _CharT*& __begin, const _CharT* __end, __flags __flags) {
+  __parse_modifier_O(_ConstIterator& __begin, _ConstIterator __end, __flags __flags) {
     ++__begin;
     if (__begin == __end)
       std::__throw_format_error("End of input while parsing the modifier O");
 
     switch (*__begin) {
     case _CharT('S'):
       __format_spec::__validate_second(__flags);
       break;

libcxx/include/__format/formatter_output.h

 }
 
 template <class _CharT>
 _LIBCPP_HIDE_FROM_ABI void
 __escape(basic_string<_CharT>& __str, basic_string_view<_CharT> __values, __escape_quotation_mark __mark) {
   __unicode::__code_point_view<_CharT> __view{__values.begin(), __values.end()};
 
   while (!__view.__at_end()) {
-    const _CharT* __first                               = __view.__position();
+    auto __first                                        = __view.__position();
     typename __unicode::__consume_p2286_result __result = __view.__consume_p2286();
     if (__result.__ill_formed_size == 0) {
       if (!__formatter::__is_escaped_sequence_written(__str, __result.__value, __mark))
         // 2.2.1.3 - Add the character
         ranges::copy(__first, __view.__position(), std::back_insert_iterator(__str));
 
     } else {
       // 2.2.3 sequence of ill-formed code units

libcxx/include/__format/formatter_tuple.h

struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT __formatter_tuple {
   _LIBCPP_HIDE_FROM_ABI constexpr void
   set_brackets(basic_string_view<_CharT> __opening_bracket, basic_string_view<_CharT> __closing_bracket) {
     __opening_bracket_ = __opening_bracket;
     __closing_bracket_ = __closing_bracket;
   }
 
   template <class _ParseContext>
   _LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __parse_ctx) {
-    const _CharT* __begin = __parser_.__parse(__parse_ctx, __format_spec::__fields_tuple);
+    auto __begin = __parser_.__parse(__parse_ctx, __format_spec::__fields_tuple);
 
     // [format.tuple]/7
     //   ... For each element e in underlying_, if e.set_debug_format()
     //   is a valid expression, calls e.set_debug_format().
     // TODO FMT this can be removed when P2733 is accepted.
     std::__for_each_index_sequence(make_index_sequence<sizeof...(_Args)>(), [&]<size_t _Index> {
       std::__set_debug_format(std::get<_Index>(__underlying_));
     });
 
-    const _CharT* __end = __parse_ctx.end();
+    auto __end = __parse_ctx.end();
     if (__begin == __end)
       return __begin;
 
     if (*__begin == _CharT('m')) {
       if constexpr (sizeof...(_Args) == 2) {
         set_separator(_LIBCPP_STATICALLY_WIDEN(_CharT, ": "));
         set_brackets({}, {});
         ++__begin;

libcxx/include/__format/range_formatter.h

set_brackets(basic_string_view<_CharT> __opening_bracket, basic_string_view<_CharT> __closing_bracket) {
     __closing_bracket_ = __closing_bracket;
   }
 
   _LIBCPP_HIDE_FROM_ABI constexpr formatter<_Tp, _CharT>& underlying() { return __underlying_; }
   _LIBCPP_HIDE_FROM_ABI constexpr const formatter<_Tp, _CharT>& underlying() const { return __underlying_; }
 
   template <class _ParseContext>
   _LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __parse_ctx) {
-    const _CharT* __begin = __parser_.__parse(__parse_ctx, __format_spec::__fields_range);
-    const _CharT* __end   = __parse_ctx.end();
+    auto __begin = __parser_.__parse(__parse_ctx, __format_spec::__fields_range);
+    auto __end   = __parse_ctx.end();
     if (__begin == __end)
       return __begin;
 
     // The n field overrides a possible m type, therefore delay applying the
     // effect of n until the type has been procesed.
     bool __clear_brackets = (*__begin == _CharT('n'));
     if (__clear_brackets) {
       ++__begin;
__format_as_sequence(_Rp&& __range, _FormatContext& __ctx) const {
     }
 
     return ranges::copy(__closing_bracket_, __ctx.out()).out;
   }
 
   __format_spec::__parser<_CharT> __parser_{.__alignment_ = __format_spec::__alignment::__left};
 
 private:
-  _LIBCPP_HIDE_FROM_ABI constexpr void __parse_type(const _CharT*& __begin, const _CharT* __end) {
+  template <contiguous_iterator _Iterator>
+  _LIBCPP_HIDE_FROM_ABI constexpr void __parse_type(_Iterator& __begin, _Iterator __end) {
     switch (*__begin) {
     case _CharT('m'):
       if constexpr (__fmt_pair_like<_Tp>) {
         set_brackets(_LIBCPP_STATICALLY_WIDEN(_CharT, "{"), _LIBCPP_STATICALLY_WIDEN(_CharT, "}"));
         set_separator(_LIBCPP_STATICALLY_WIDEN(_CharT, ", "));
         ++__begin;
       } else
         std::__throw_format_error("The range-format-spec type m requires two elements for a pair or tuple");

libcxx/include/string_view

 */
 
 #include <__algorithm/min.h>
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__functional/hash.h>
 #include <__functional/unary_function.h>
 #include <__fwd/string_view.h>
+#include <__iterator/bounded_iter.h>
 #include <__iterator/concepts.h>
 #include <__iterator/readable_traits.h>
 #include <__iterator/reverse_iterator.h>
 #include <__memory/pointer_traits.h>
 #include <__ranges/concepts.h>
 #include <__ranges/data.h>
 #include <__ranges/enable_borrowed_range.h>
 #include <__ranges/enable_view.h>

 public:
     // types
     using traits_type            = _Traits;
     using value_type             = _CharT;
     using pointer                = _CharT*;
     using const_pointer          = const _CharT*;
     using reference              = _CharT&;
     using const_reference        = const _CharT&;
+#ifdef _LIBCPP_DEBUG_ITERATOR_BOUNDS_CHECKING
+    using const_iterator         = __bounded_iter<const_pointer>;
+#else
     using const_iterator         = const_pointer; // See [string.view.iterators]
+#endif
     using iterator               = const_iterator;
     using const_reverse_iterator = _VSTD::reverse_iterator<const_iterator>;
     using reverse_iterator       = const_reverse_iterator;
     using size_type              = size_t;
     using difference_type        = ptrdiff_t;
     static _LIBCPP_CONSTEXPR const size_type npos = -1; // size_type(-1);
 
     static_assert((!is_array<value_type>::value), "Character type of basic_string_view must not be an array");
#endif
     // [string.view.iterators], iterators
     _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
     const_iterator begin()  const _NOEXCEPT { return cbegin(); }
 
     _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
     const_iterator end()    const _NOEXCEPT { return cend(); }
 
     _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
-    const_iterator cbegin() const _NOEXCEPT { return __data_; }
+    const_iterator cbegin() const _NOEXCEPT {
+#ifdef _LIBCPP_DEBUG_ITERATOR_BOUNDS_CHECKING
+        return std::__make_bounded_iter(data(), data(), data() + size());
+#else
+        return __data_;
+#endif
+    }
 
     _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
-    const_iterator cend()   const _NOEXCEPT { return __data_ + __size_; }
+    const_iterator cend()   const _NOEXCEPT {
+#ifdef _LIBCPP_DEBUG_ITERATOR_BOUNDS_CHECKING
+        return std::__make_bounded_iter(data() + size(), data(), data() + size());
+#else
+        return __data_ + __size_;
+#endif
+    }
 
     _LIBCPP_CONSTEXPR_SINCE_CXX17 _LIBCPP_INLINE_VISIBILITY
     const_reverse_iterator rbegin()   const _NOEXCEPT { return const_reverse_iterator(cend()); }
 
     _LIBCPP_CONSTEXPR_SINCE_CXX17 _LIBCPP_INLINE_VISIBILITY
     const_reverse_iterator rend()     const _NOEXCEPT { return const_reverse_iterator(cbegin()); }
 
     _LIBCPP_CONSTEXPR_SINCE_CXX17 _LIBCPP_INLINE_VISIBILITY

libcxx/test/libcxx/strings/string.view/string.view.iterators/debug.iterator-indexing.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
+//
+//===----------------------------------------------------------------------===//
+
+// Make sure that std::string_view's iterators check for OOB accesses when the debug mode is enabled.
+
+// REQUIRES: has-unix-headers
+// UNSUPPORTED: !libcpp-has-debug-mode
+
+#include <string_view>
+
+#include "check_assertion.h"
+
+int main(int, char**) {
+    // string_view::iterator
+    {
+        std::string_view const str("hello world");
+        {
+            auto it = str.end();
+            TEST_LIBCPP_ASSERT_FAILURE(*it, "__bounded_iter::operator*: Attempt to dereference an out-of-range iterator");
+        }
+        {
+            auto it = str.end();
+            TEST_LIBCPP_ASSERT_FAILURE(it.operator->(), "__bounded_iter::operator->: Attempt to dereference an out-of-range iterator");
+        }
+        {
+            auto it = str.begin();
+            TEST_LIBCPP_ASSERT_FAILURE(it[99], "__bounded_iter::operator[]: Attempt to index an iterator out-of-range");
+        }
+    }
+
+    // string_view::const_iterator
+    {
+        std::string_view const str("hello world");
+        {
+            auto it = str.cend();
+            TEST_LIBCPP_ASSERT_FAILURE(*it, "__bounded_iter::operator*: Attempt to dereference an out-of-range iterator");
+        }
+        {
+            auto it = str.cend();
+            TEST_LIBCPP_ASSERT_FAILURE(it.operator->(), "__bounded_iter::operator->: Attempt to dereference an out-of-range iterator");
+        }
+        {
+            auto it = str.cbegin();
+            TEST_LIBCPP_ASSERT_FAILURE(it[99], "__bounded_iter::operator[]: Attempt to index an iterator out-of-range");
+        }
+    }
+
+    // string_view::reverse_iterator
+    {
+        std::string_view const str("hello world");
+        {
+            auto it = str.rend();
+            TEST_LIBCPP_ASSERT_FAILURE(*it, "__bounded_iter::operator*: Attempt to dereference an out-of-range iterator");
+        }
+        {
+            auto it = str.rend();
+            TEST_LIBCPP_ASSERT_FAILURE(it.operator->(), "__bounded_iter::operator->: Attempt to dereference an out-of-range iterator");
+        }
+        {
+            auto it = str.rbegin();
+            TEST_LIBCPP_ASSERT_FAILURE(it[99], "__bounded_iter::operator*: Attempt to dereference an out-of-range iterator");
+        }
+    }
+
+    // string_view::const_reverse_iterator
+    {
+        std::string_view const str("hello world");
+        {
+            auto it = str.crend();
+            TEST_LIBCPP_ASSERT_FAILURE(*it, "__bounded_iter::operator*: Attempt to dereference an out-of-range iterator");
+        }
+        {
+            auto it = str.crend();
+            TEST_LIBCPP_ASSERT_FAILURE(it.operator->(), "__bounded_iter::operator->: Attempt to dereference an out-of-range iterator");
+        }
+        {
+            auto it = str.crbegin();
+            TEST_LIBCPP_ASSERT_FAILURE(it[99], "__bounded_iter::operator*: Attempt to dereference an out-of-range iterator");
+        }
+    }
+
+    return 0;
+}

libcxx/test/libcxx/utilities/format/format.string/format.string.std/extended_grapheme_cluster.pass.cpp

 
 } // namespace
 
 template <class Data>
 constexpr void test(const Data& data) {
   for (const auto& d : data) {
     assert(d.code_points.size() == d.breaks.size());
 
-    std::__unicode::__extended_grapheme_cluster_view view{d.input.data(), d.input.data() + d.input.size()};
+    std::__unicode::__extended_grapheme_cluster_view view{d.input.begin(), d.input.end()};
     for (size_t i = 0; i < d.breaks.size(); ++i) {
       auto r = view.__consume();
       assert(r.__code_point_ == d.code_points[i]);
-      assert(r.__last_ == d.input.data() + d.breaks[i]);
+      assert(r.__last_ == d.input.begin() + d.breaks[i]);
     }
   }
 }
 
 constexpr bool test() {
   test(data_utf8);
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS

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

 
 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 std::string_view::const_iterator begin() const { return view_.begin(); }
+  constexpr std::string_view::const_iterator 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 ViewWithInitTracking : std::ranges::view_base {
   enum class InitializedBy {

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

struct StrView : std::ranges::view_base {
   std::string_view buffer_;
   constexpr explicit StrView() = default;
   constexpr StrView(const char* ptr) : buffer_(ptr) {}
   // Intentionally don't forward to range constructor for std::string_view since
   // this test needs to work on C++20 as well and the range constructor is only for
   // C++23 and later.
   template <std::ranges::range R>
   constexpr StrView(R&& r) : buffer_(r.begin(), r.end()) {}
-  constexpr const char* begin() const { return buffer_.begin(); }
-  constexpr const char* end() const { return buffer_.end(); }
+  constexpr std::string_view::const_iterator begin() const { return buffer_.begin(); }
+  constexpr std::string_view::const_iterator end() const { return buffer_.end(); }
   constexpr bool operator==(const StrView& rhs) const { return buffer_ == rhs.buffer_; }
 };
 static_assert( std::ranges::random_access_range<StrView>);
 static_assert( std::ranges::view<StrView>);
 static_assert( std::is_copy_constructible_v<StrView>);
 
 constexpr bool test() {
   {

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

struct ForwardViewCommonIfConst : std::ranges::view_base {
   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()); }
+  constexpr forward_iterator<std::string_view::const_iterator> begin() const { return forward_iterator<std::string_view::const_iterator>(view_.begin()); }
+  constexpr forward_iterator<std::string_view::const_iterator> end() const { return forward_iterator<std::string_view::const_iterator>(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 forward_iterator<std::string_view::const_iterator> begin() const { return forward_iterator<std::string_view::const_iterator>(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; }
+bool operator==(forward_iterator<std::string_view::const_iterator>, 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;
 

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

 
 // CopyableView
 
 struct CopyableView : std::ranges::view_base {
   std::string_view view_;
   constexpr explicit CopyableView() = default;
   constexpr CopyableView(const char* ptr) : view_(ptr) {}
   constexpr CopyableView(std::string_view v) : view_(v) {}
-  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()); }
+  constexpr forward_iterator<std::string_view::const_iterator> begin() const { return forward_iterator<std::string_view::const_iterator>(view_.begin()); }
+  constexpr forward_iterator<std::string_view::const_iterator> end() const { return forward_iterator<std::string_view::const_iterator>(view_.end()); }
   constexpr bool operator==(const CopyableView& rhs) const { return view_ == rhs.view_; }
 };
 static_assert( std::ranges::forward_range<CopyableView>);
 static_assert( std::ranges::forward_range<const CopyableView>);
 static_assert( std::ranges::view<CopyableView>);
 static_assert( std::is_copy_constructible_v<CopyableView>);
 
 // ForwardView
 
 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()); }
+  constexpr forward_iterator<std::string_view::const_iterator> begin() const { return forward_iterator<std::string_view::const_iterator>(view_.begin()); }
+  constexpr forward_iterator<std::string_view::const_iterator> end() const { return forward_iterator<std::string_view::const_iterator>(view_.end()); }
 };
 static_assert( std::ranges::forward_range<ForwardView>);
 static_assert( std::ranges::forward_range<const ForwardView>);
 static_assert( std::ranges::view<ForwardView>);
 static_assert(!std::is_copy_constructible_v<ForwardView>);
 static_assert( std::is_move_constructible_v<ForwardView>);
 
 // ForwardDiffView
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 forward_iterator<std::string_view::const_iterator> begin() { return forward_iterator<std::string_view::const_iterator>(view_.begin()); }
+  constexpr forward_iterator<std::string_view::const_iterator> end() { return forward_iterator<std::string_view::const_iterator>(view_.end()); }
+  constexpr almost_forward_iterator<std::string_view::const_iterator> begin() const {
+    return almost_forward_iterator<std::string_view::const_iterator>(view_.begin());
   }
-  constexpr almost_forward_iterator<const char*> end() const {
-    return almost_forward_iterator<const char*>(view_.end());
+  constexpr almost_forward_iterator<std::string_view::const_iterator> end() const {
+    return almost_forward_iterator<std::string_view::const_iterator>(view_.end());
   }
 };
 static_assert( std::ranges::forward_range<ForwardOnlyIfNonConstView>);
 static_assert(!std::ranges::forward_range<const ForwardOnlyIfNonConstView>);
 static_assert( std::ranges::view<ForwardOnlyIfNonConstView>);
 
 // InputView