[libc++][ranges] Implement the changes to `basic_string` from P1206 (`ranges::to`):

[var-const]

Summary

• add the from_range_t constructors and the related deduction guides;
• add the insert_range/assign_range/etc. member functions.

(Note: this patch is split from https://reviews.llvm.org/D142335)

[var-const]

Address feedback

[var-const]

libcxx/include/string

1296

Original comment by @ldionne

This one can be more efficient. If we have an input range, then we do need to make a temporary string and append it. But if we have e.g. a forward_range or a sized_range, we don't need to make a copy of the input range, and I think we should really avoid doing it. I think simply using insert_range(end(), ...) here would solve that problem?

libcxx/test/std/strings/basic.string/string.modifiers/string_replace/replace_with_range.pass.cpp

27

Original comment by @ldionne

You are also missing a SFINAE test for the constraints of the method.

56

Original comment by @ldionne

// - input range: empty / one-element / middle-sized / longer than SSO / longer than current string capacity.

863

Original comment by @ldionne

We don't seem to be testing that the range is taken as Rng&&, are we?

[var-const]

libcxx/include/string

1296

Done (here and in assign_range).

libcxx/test/std/strings/basic.string/string.modifiers/string_replace/replace_with_range.pass.cpp

56

Added a few test cases suffixed with _LongerThanCapacityRange.

[var-const]

Fix the CI.

[var-const]

Fix CI

[ldionne]

libcxx/include/string

1369–1371

We should refactor this so that __assign_with_size actually assigns with size, so we don't have to compute __n = 0 when we don't actually need it anywhere. That's too confusing, it seems like we're assigning with size 0 when !__string_is_trivial_iterator but in reality __assign_with_size simply ignored the size we passed in.

1415

__string_is_trivial_iterator was introduced around D98573. Do we have the same issue in the insert_range you're adding? Why do we not need to check for __string_is_trivial_iterator here?

I suspect there is an exception-safety issue hidden in the current version of the code, in which case we should add a test case similar to what was added in D98573 but for the new methods in this patch.

libcxx/test/std/strings/basic.string/string.cons/from_range.pass.cpp

21–22

Above includes (here and elsewhere).

libcxx/test/std/strings/basic.string/string.modifiers/string_append/append_range.pass.cpp

20

Here and in other tests, I would inline those functions into main() and instead do:

// plain english comment explaining what you test
{
  // test content
}

This is what we try to do elsewhere and a plain text comment allows for a more precise description of what's going on than a function name -- I'm not 100% sure what's being tested by just reading test_string_append_range_return_value.

libcxx/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string_size_size.pass.cpp

2 ↗

(On Diff #523238)

I think this change is accidental.

[var-const]

Partially address feedback and rebase.

libcxx/include/string

1369–1371

I gave it a shot, but very open to suggestions.

Thinking more about it, it's not really "assign with size" since it only applies to a subset of cases where we know the size:

• first, the input iterators have to be "trivial";
• second, if the input range is a subset of the string itself, then we need to have enough capacity to avoid reallocating (or the input iterators will end up being invalidated).

These conditions are somewhat messy, so to avoid duplicating the check in two different places (assign and assign_range), I made it a try function that returns false if it fails to do the job (so that the caller can fall back to assign_with_sentinel). This also avoids the question of whether try_assign_trivial should assert that its preconditions are met or just trust the caller. Please let me know what you think!

[var-const]

libcxx/include/string

2545

I'm very open to reverting this, perhaps it's overkill. By the way, do we have any existing precedent for cases where we would want to use if constexpr but can't due to pre-C++17 language modes? I didn't find an obvious macro to use in __config, but perhaps I missed something.

2550–2551

Note: this is an inversion of the original "positive" condition ("if condition, proceed" now inverted to "if not condition, return early"):

if (__cap >= __n || !__addr_in_range(*__first)))

Unless I made a mistake and the rewrite is not equivalent, I don't really see how this case could happen. If __first is __addr_in_range, i.e., an iterator pointing at a character within the string itself, it seems that the input range cannot be longer than the size of the string, which cannot be less than the capacity. I don't think it's possible for the end iterator to point to some characters past the end of the string without UB. Perhaps I'm missing something? FWIW, no tests fail if I remove this early return.

(If we could remove this condition, it would simplify the function so that it no longer has to return a boolean)

[var-const]

libcxx/include/string

1415

insert_range delegates to __insert_with_size which falls back to constructing a temporary string if the iterator is not trivial. I don't think there should be an exception safety issue, but the code is not symmetrical with assign_range now. Should I introduce something like __insert_with_sentinel to mirror the other function?

[ldionne]

libcxx/include/string

1415

No, this makes sense to me now.

2545

Yeah, I think we should keep the previous code here. I don't think we have something to turn into a if constexpr in C++ >= 17 but if we did, then it would 100% make sense to use it here. I just don't think the #if is worth it.

2550–2551

I think I agree with this, @philnik does that make sense to you (you are pretty familiar with string).

[philnik]

libcxx/include/string

2545

I think we have quite a few places where if constexpr would be nice but not necessary, since the code will compile without the constexpr.

2550–2551

Users are allowed to inspect the object, so this will be the case if a user gives us a pointer to the value representation of this string. The question is just whether we want to bother supporting this, since about two people on this planet will actually do that.

2565–2569

Why do you have this condition here? We have static_asserts all the way back to C++03.

[var-const]

Address feedback and rebase.

libcxx/include/string

2550–2551

@philnik I don't fully understand the case you're describing, can you please give a code example?

2565–2569

I think if I'm not using if constexpr in the caller, this function will always end up being instantiated, whether it's called or not, so I can't use static_assert. I reverted the conditional if constexpr, so this is no longer applicable.

[var-const]

libcxx/include/string

2550–2551

Synced offline, it's basically:

std::string str("abc");
auto* ptr = reinterpret_cast<char*>(&str);
str.assign(ptr, ptr + sizeof(str));

IIUC, there's no undefined behavior here -- growing capacity will change the byte representation of the string but won't make it invalid. I think we don't need to look for that case (and we already don't in the overload of assign that takes a pointer and a size).

[var-const]

__try_assign_trivial -> __assign_trivial.

[var-const]

libcxx/include/string

2550–2551

Simplified __try_assign_trivial to just __assign_trivial (so that now it doesn't return anything).

If I had to guess, the patch that added the check added a similar check to append (where it makes sense) and perhaps just duplicated it in assign without realizing that this case doesn't apply.

[var-const]

Rebase

[ldionne]

libcxx/include/string

1514

I might have asked for that already, but do you have tests that these constraints are right, i.e. this overload doesn't match if you pass something that's not _ContainerCompatibleRange?

2558

You'll need to rebase on top of main and this should change to _LIBCPP_ASSERT_UNCATEGORIZED.

libcxx/test/std/strings/basic.string/string.cons/from_range.pass.cpp

13

This is marked as constexpr.

112

You don't seem to be testing this inside constexpr, but the constructor is definitely marked as constexpr. The same comment seems to apply to all tests.

libcxx/test/std/strings/basic.string/string.modifiers/string_append/append_range.pass.cpp

63–64

Can't we just inline this function here in a local scope? Applies to other tests as well.

[var-const]

Address feedback

libcxx/include/string

1514

Yes, see constexpr bool test_constraints_replace_with_range() in replace_with_range.pass.cpp.

libcxx/test/std/strings/basic.string/string.cons/from_range.pass.cpp

112

Thanks! Sorry, somehow I missed that.

libcxx/include/string

template <class T>
         explicit basic_string(const T& t, const Allocator& a = Allocator());                    // C++17, constexpr since C++20
     basic_string(const value_type* s, const allocator_type& a = allocator_type());              // constexpr since C++20
     basic_string(const value_type* s, size_type n, const allocator_type& a = allocator_type()); // constexpr since C++20
     basic_string(nullptr_t) = delete; // C++23
     basic_string(size_type n, value_type c, const allocator_type& a = allocator_type());        // constexpr since C++20
     template<class InputIterator>
         basic_string(InputIterator begin, InputIterator end,
                      const allocator_type& a = allocator_type());                               // constexpr since C++20
+    template<container-compatible-range<charT> R>
+      constexpr basic_string(from_range_t, R&& rg, const Allocator& a = Allocator());           // since C++23
     basic_string(initializer_list<value_type>, const Allocator& = Allocator());                 // constexpr since C++20
     basic_string(const basic_string&, const Allocator&);                                        // constexpr since C++20
     basic_string(basic_string&&, const Allocator&);                                             // constexpr since C++20
 
     ~basic_string();                                                                            // constexpr since C++20
 
     operator basic_string_view<charT, traits>() const noexcept;                                 // constexpr since C++20
 
// types:
     basic_string& append(const basic_string& str, size_type pos, size_type n=npos);             // C++14, constexpr since C++20
     template <class T>
         basic_string& append(const T& t, size_type pos, size_type n=npos);                      // C++17, constexpr since C++20
     basic_string& append(const value_type* s, size_type n);                                     // constexpr since C++20
     basic_string& append(const value_type* s);                                                  // constexpr since C++20
     basic_string& append(size_type n, value_type c);                                            // constexpr since C++20
     template<class InputIterator>
         basic_string& append(InputIterator first, InputIterator last);                          // constexpr since C++20
+    template<container-compatible-range<charT> R>
+      constexpr basic_string& append_range(R&& rg);                                             // C++23
     basic_string& append(initializer_list<value_type>);                                         // constexpr since C++20
 
     void push_back(value_type c);                                                               // constexpr since C++20
     void pop_back();                                                                            // constexpr since C++20
     reference       front();                                                                    // constexpr since C++20
     const_reference front() const;                                                              // constexpr since C++20
     reference       back();                                                                     // constexpr since C++20
     const_reference back() const;                                                               // constexpr since C++20
 
     basic_string& assign(const basic_string& str);                                              // constexpr since C++20
     template <class T>
         basic_string& assign(const T& t);                                                       // C++17, constexpr since C++20
     basic_string& assign(basic_string&& str);                                                   // constexpr since C++20
     basic_string& assign(const basic_string& str, size_type pos, size_type n=npos);             // C++14, constexpr since C++20
     template <class T>
         basic_string& assign(const T& t, size_type pos, size_type n=npos);                      // C++17, constexpr since C++20
     basic_string& assign(const value_type* s, size_type n);                                     // constexpr since C++20
     basic_string& assign(const value_type* s);                                                  // constexpr since C++20
     basic_string& assign(size_type n, value_type c);                                            // constexpr since C++20
     template<class InputIterator>
         basic_string& assign(InputIterator first, InputIterator last);                          // constexpr since C++20
+    template<container-compatible-range<charT> R>
+      constexpr basic_string& assign_range(R&& rg);                                             // C++23
     basic_string& assign(initializer_list<value_type>);                                         // constexpr since C++20
 
     basic_string& insert(size_type pos1, const basic_string& str);                              // constexpr since C++20
     template <class T>
         basic_string& insert(size_type pos1, const T& t);                                       // constexpr since C++20
     basic_string& insert(size_type pos1, const basic_string& str,
                          size_type pos2, size_type n);                                          // constexpr since C++20
     template <class T>
         basic_string& insert(size_type pos1, const T& t, size_type pos2, size_type n);          // C++17, constexpr since C++20
     basic_string& insert(size_type pos, const value_type* s, size_type n=npos);                 // C++14, constexpr since C++20
     basic_string& insert(size_type pos, const value_type* s);                                   // constexpr since C++20
     basic_string& insert(size_type pos, size_type n, value_type c);                             // constexpr since C++20
     iterator      insert(const_iterator p, value_type c);                                       // constexpr since C++20
     iterator      insert(const_iterator p, size_type n, value_type c);                          // constexpr since C++20
     template<class InputIterator>
         iterator insert(const_iterator p, InputIterator first, InputIterator last);             // constexpr since C++20
+    template<container-compatible-range<charT> R>
+      constexpr iterator insert_range(const_iterator p, R&& rg);                                // C++23
     iterator      insert(const_iterator p, initializer_list<value_type>);                       // constexpr since C++20
 
     basic_string& erase(size_type pos = 0, size_type n = npos);                                 // constexpr since C++20
     iterator      erase(const_iterator position);                                               // constexpr since C++20
     iterator      erase(const_iterator first, const_iterator last);                             // constexpr since C++20
 
     basic_string& replace(size_type pos1, size_type n1, const basic_string& str);               // constexpr since C++20
     template <class T>
// types:
     basic_string& replace(const_iterator i1, const_iterator i2, const basic_string& str);       // constexpr since C++20
     template <class T>
         basic_string& replace(const_iterator i1, const_iterator i2, const T& t);                // C++17, constexpr since C++20
     basic_string& replace(const_iterator i1, const_iterator i2, const value_type* s, size_type n); // constexpr since C++20
     basic_string& replace(const_iterator i1, const_iterator i2, const value_type* s);           // constexpr since C++20
     basic_string& replace(const_iterator i1, const_iterator i2, size_type n, value_type c);     // constexpr since C++20
     template<class InputIterator>
         basic_string& replace(const_iterator i1, const_iterator i2, InputIterator j1, InputIterator j2); // constexpr since C++20
+    template<container-compatible-range<charT> R>
+      constexpr basic_string& replace_with_range(const_iterator i1, const_iterator i2, R&& rg); // C++23
     basic_string& replace(const_iterator i1, const_iterator i2, initializer_list<value_type>);  // constexpr since C++20
 
     size_type copy(value_type* s, size_type n, size_type pos = 0) const;                        // constexpr since C++20
     basic_string substr(size_type pos = 0, size_type n = npos) const;                           // constexpr in C++20, removed in C++23
     basic_string substr(size_type pos = 0, size_type n = npos) const&;                          // since C++23
     constexpr basic_string substr(size_type pos = 0, size_type n = npos) &&;                    // since C++23
     void swap(basic_string& str)
         noexcept(allocator_traits<allocator_type>::propagate_on_container_swap::value ||

 
 template<class InputIterator,
          class Allocator = allocator<typename iterator_traits<InputIterator>::value_type>>
 basic_string(InputIterator, InputIterator, Allocator = Allocator())
    -> basic_string<typename iterator_traits<InputIterator>::value_type,
                   char_traits<typename iterator_traits<InputIterator>::value_type>,
                   Allocator>;   // C++17
 
+template<ranges::input_range R,
+         class Allocator = allocator<ranges::range_value_t<R>>>
+  basic_string(from_range_t, R&&, Allocator = Allocator())
+    -> basic_string<ranges::range_value_t<R>, char_traits<ranges::range_value_t<R>>,
+                    Allocator>; // C++23
+
+template<class charT,
+         class traits,
+         class Allocator = allocator<charT>>
+  explicit basic_string(basic_string_view<charT, traits>, const Allocator& = Allocator())
+    -> basic_string<charT, traits, Allocator>; // C++17
+
+template<class charT,
+         class traits,
+         class Allocator = allocator<charT>>
+  basic_string(basic_string_view<charT, traits>,
+                typename see below::size_type, typename see below::size_type,
+                const Allocator& = Allocator())
+    -> basic_string<charT, traits, Allocator>; // C++17
+
 template<class charT, class traits, class Allocator>
 basic_string<charT, traits, Allocator>
 operator+(const basic_string<charT, traits, Allocator>& lhs,
           const basic_string<charT, traits, Allocator>& rhs);                                   // constexpr since C++20
 
 template<class charT, class traits, class Allocator>
 basic_string<charT, traits, Allocator>
 operator+(const charT* lhs , const basic_string<charT,traits,Allocator>&rhs);                   // constexpr since C++20

 #include <__memory/allocate_at_least.h>
 #include <__memory/allocator.h>
 #include <__memory/allocator_traits.h>
 #include <__memory/compressed_pair.h>
 #include <__memory/construct_at.h>
 #include <__memory/pointer_traits.h>
 #include <__memory/swap_allocator.h>
 #include <__memory_resource/polymorphic_allocator.h>
+#include <__ranges/access.h>
+#include <__ranges/concepts.h>
+#include <__ranges/container_compatible_range.h>
+#include <__ranges/from_range.h>
+#include <__ranges/size.h>
 #include <__string/char_traits.h>
 #include <__string/extern_template_lists.h>
 #include <__type_traits/is_allocator.h>
 #include <__type_traits/is_array.h>
 #include <__type_traits/is_convertible.h>
 #include <__type_traits/is_nothrow_default_constructible.h>
 #include <__type_traits/is_nothrow_move_assignable.h>
 #include <__type_traits/is_same.h>
 #include <__type_traits/is_standard_layout.h>
 #include <__type_traits/is_trivial.h>
 #include <__type_traits/noexcept_move_assign_container.h>
 #include <__type_traits/remove_cvref.h>
 #include <__type_traits/void_t.h>
 #include <__utility/auto_cast.h>
 #include <__utility/declval.h>
+#include <__utility/forward.h>
 #include <__utility/is_pointer_in_range.h>
 #include <__utility/move.h>
 #include <__utility/swap.h>
 #include <__utility/unreachable.h>
 #include <climits>
 #include <cstdint>
 #include <cstdio>  // EOF
 #include <cstring>

 
 template <class _CharT, class _Traits, class _Tp>
 struct __can_be_converted_to_string_view : public _BoolConstant<
       is_convertible<const _Tp&, basic_string_view<_CharT, _Traits> >::value &&
      !is_convertible<const _Tp&, const _CharT*>::value
     > {};
 
 struct __uninitialized_size_tag {};
+struct __init_with_sentinel_tag {};
 
 template<class _CharT, class _Traits, class _Allocator>
 class basic_string
 {
 public:
     typedef basic_string                                 __self;
     typedef basic_string_view<_CharT, _Traits>           __self_view;
     typedef _Traits                                      traits_type;
explicit basic_string(__uninitialized_size_tag, size_type __size, const allocator_type& __a)
             auto __allocation = __alloc_traits::allocate(__alloc(), __capacity);
             __begin_lifetime(__allocation, __capacity);
             __set_long_cap(__capacity);
             __set_long_pointer(__allocation);
             __set_long_size(__size);
         }
     }
 
+    template <class _Iter, class _Sent>
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
+    basic_string(__init_with_sentinel_tag, _Iter __first, _Sent __last, const allocator_type& __a)
+        : __r_(__default_init_tag(), __a) {
+      __init_with_sentinel(std::move(__first), std::move(__last));
+    }
+
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 iterator __make_iterator(pointer __p) {
         return iterator(__p);
     }
 
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_iterator __make_const_iterator(const_pointer __p) const {
         return const_iterator(__p);
     }
 
#endif
 
   template <class _InputIterator, __enable_if_t<__has_input_iterator_category<_InputIterator>::value, int> = 0>
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
   basic_string(_InputIterator __first, _InputIterator __last, const allocator_type& __a)
       : __r_(__default_init_tag(), __a) {
     __init(__first, __last);
   }
 
+#if _LIBCPP_STD_VER >= 23
+  template <_ContainerCompatibleRange<_CharT> _Range>
+  _LIBCPP_HIDE_FROM_ABI constexpr
+  basic_string(from_range_t, _Range&& __range, const allocator_type& __a = allocator_type())
+      : __r_(__default_init_tag(), __a) {
+    if constexpr (ranges::forward_range<_Range> || ranges::sized_range<_Range>) {
+      __init_with_size(ranges::begin(__range), ranges::end(__range), ranges::distance(__range));
+    } else {
+      __init_with_sentinel(ranges::begin(__range), ranges::end(__range));
+    }
+  }
+#endif
+
 #ifndef _LIBCPP_CXX03_LANG
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string(initializer_list<_CharT> __il)
       : __r_(__default_init_tag(), __default_init_tag()) {
     __init(__il.begin(), __il.end());
   }
 
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string(initializer_list<_CharT> __il, const _Allocator& __a)
       : __r_(__default_init_tag(), __a) {
append(_InputIterator __first, _InputIterator __last) {
         append(__temp.data(), __temp.size());
         return *this;
     }
 
     template <class _ForwardIterator, __enable_if_t<__has_forward_iterator_category<_ForwardIterator>::value, int> = 0>
     _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string&
     append(_ForwardIterator __first, _ForwardIterator __last);
 
+#if _LIBCPP_STD_VER >= 23
+    template <_ContainerCompatibleRange<_CharT> _Range>
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr basic_string& append_range(_Range&& __range) {
+      insert_range(end(), std::forward<_Range>(__range));
+      return *this;
+    }
+#endif
+
 #ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
     basic_string& append(initializer_list<value_type> __il) {return append(__il.begin(), __il.size());}
 #endif // _LIBCPP_CXX03_LANG
 
     _LIBCPP_CONSTEXPR_SINCE_CXX20 void push_back(value_type __c);
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void pop_back();
 
#endif
     template <class _InputIterator, __enable_if_t<__has_exactly_input_iterator_category<_InputIterator>::value, int> = 0>
     _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string&
     assign(_InputIterator __first, _InputIterator __last);
 
     template <class _ForwardIterator, __enable_if_t<__has_forward_iterator_category<_ForwardIterator>::value, int> = 0>
     _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string&
     assign(_ForwardIterator __first, _ForwardIterator __last);
 
+#if _LIBCPP_STD_VER >= 23
+    template <_ContainerCompatibleRange<_CharT> _Range>
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr basic_string& assign_range(_Range&& __range) {
+      if constexpr (__string_is_trivial_iterator<ranges::iterator_t<_Range>>::value &&
+          (ranges::forward_range<_Range> || ranges::sized_range<_Range>)) {
+        size_type __n = static_cast<size_type>(ranges::distance(__range));
+        __assign_trivial(ranges::begin(__range), ranges::end(__range), __n);
+
+      } else {
+        __assign_with_sentinel(ranges::begin(__range), ranges::end(__range));
+      }
+
+      return *this;
+    }
+#endif
+
 #ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
     basic_string& assign(initializer_list<value_type> __il) {return assign(__il.begin(), __il.size());}
 #endif // _LIBCPP_CXX03_LANG
 
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string&
   insert(size_type __pos1, const basic_string& __str) {
     return insert(__pos1, __str.data(), __str.size());
#endif // _LIBCPP_CXX03_LANG
 
   _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string&
   insert(size_type __pos1, const basic_string& __str, size_type __pos2, size_type __n = npos);
   _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& insert(size_type __pos, const value_type* __s, size_type __n);
   _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& insert(size_type __pos, const value_type* __s);
   _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& insert(size_type __pos, size_type __n, value_type __c);
   _LIBCPP_CONSTEXPR_SINCE_CXX20 iterator insert(const_iterator __pos, value_type __c);
 
+#if _LIBCPP_STD_VER >= 23
+    template <_ContainerCompatibleRange<_CharT> _Range>
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr iterator insert_range(const_iterator __position, _Range&& __range) {
+      if constexpr (ranges::forward_range<_Range> || ranges::sized_range<_Range>) {
+        auto __n = static_cast<size_type>(ranges::distance(__range));
+        return __insert_with_size(__position, ranges::begin(__range), ranges::end(__range), __n);
+
+      } else {
+        basic_string __temp(from_range, std::forward<_Range>(__range), __alloc());
+        return insert(__position, __temp.data(), __temp.data() + __temp.size());
+      }
+    }
+#endif
+
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 iterator
   insert(const_iterator __pos, size_type __n, value_type __c) {
     difference_type __p = __pos - begin();
     insert(static_cast<size_type>(__p), __n, __c);
     return begin() + __p;
   }
 
   template <class _InputIterator, __enable_if_t<__has_exactly_input_iterator_category<_InputIterator>::value, int> = 0>
#endif // _LIBCPP_CXX03_LANG
   replace(const_iterator __i1, const_iterator __i2, size_type __n, value_type __c) {
     return replace(static_cast<size_type>(__i1 - begin()), static_cast<size_type>(__i2 - __i1), __n, __c);
   }
 
   template <class _InputIterator, __enable_if_t<__has_input_iterator_category<_InputIterator>::value, int> = 0>
   _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string&
   replace(const_iterator __i1, const_iterator __i2, _InputIterator __j1, _InputIterator __j2);
 
+#if _LIBCPP_STD_VER >= 23
+  template <_ContainerCompatibleRange<_CharT> _Range>
+  _LIBCPP_HIDE_FROM_ABI
+  constexpr basic_string& replace_with_range(const_iterator __i1, const_iterator __i2, _Range&& __range) {
+    basic_string __temp(from_range, std::forward<_Range>(__range), __alloc());
+    return replace(__i1, __i2, __temp);
+  }
+#endif
+
 #ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
     basic_string& replace(const_iterator __i1, const_iterator __i2, initializer_list<value_type> __il)
         {return replace(__i1, __i2, __il.begin(), __il.end());}
 #endif // _LIBCPP_CXX03_LANG
 
     _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type copy(value_type* __s, size_type __n, size_type __pos = 0) const;
 
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __deallocate_constexpr() {
             __alloc_traits::deallocate(__alloc(), __get_pointer(), __get_long_cap());
     }
 
     _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI static bool __fits_in_sso(size_type __sz) {
         // SSO is disabled during constant evaluation because `__is_long` isn't constexpr friendly
         return !__libcpp_is_constant_evaluated() && (__sz < __min_cap);
     }
 
-    template <class _ForwardIterator>
+    template <class _Iterator, class _Sentinel>
+    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
+    void __assign_trivial(_Iterator __first, _Sentinel __last, size_type __n);
+
+    template <class _Iterator, class _Sentinel>
+    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
+    void __assign_with_sentinel(_Iterator __first, _Sentinel __last);
+
+    template <class _ForwardIterator, class _Sentinel>
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-    iterator __insert_from_safe_copy(size_type __n, size_type __ip, _ForwardIterator __first, _ForwardIterator __last) {
+    iterator __insert_from_safe_copy(size_type __n, size_type __ip, _ForwardIterator __first, _Sentinel __last) {
         size_type __sz = size();
         size_type __cap = capacity();
         value_type* __p;
         if (__cap - __sz >= __n)
         {
             __p = std::__to_address(__get_pointer());
             size_type __n_move = __sz - __ip;
             if (__n_move != 0)
                 traits_type::move(__p + __ip + __n, __p + __ip, __n_move);
         }
         else
         {
             __grow_by(__cap, __sz + __n - __cap, __sz, __ip, 0, __n);
             __p = std::__to_address(__get_long_pointer());
         }
         __sz += __n;
         __set_size(__sz);
         traits_type::assign(__p[__sz], value_type());
         for (__p += __ip; __first != __last; ++__p, ++__first)
             traits_type::assign(*__p, *__first);
 
         return begin() + __ip;
     }
 
+    template<class _Iterator, class _Sentinel>
+    _LIBCPP_CONSTEXPR_SINCE_CXX20
+    iterator __insert_with_size(const_iterator __pos, _Iterator __first, _Sentinel __last, size_type __n);
+
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 allocator_type& __alloc() _NOEXCEPT { return __r_.second(); }
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR const allocator_type& __alloc() const _NOEXCEPT { return __r_.second(); }
 
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
     void __set_short_size(size_type __s) _NOEXCEPT {
         _LIBCPP_ASSERT_UNCATEGORIZED(__s < __min_cap,
                                      "__s should never be greater than or equal to the short string capacity");
         __r_.first().__s.__size_ = __s;
#endif // _LIBCPP_STD_VER >= 20
     _LIBCPP_CONSTEXPR_SINCE_CXX20 void __init_copy_ctor_external(const value_type* __s, size_type __sz);
 
     template <class _InputIterator, __enable_if_t<__has_exactly_input_iterator_category<_InputIterator>::value, int> = 0>
     inline _LIBCPP_CONSTEXPR_SINCE_CXX20 void __init(_InputIterator __first, _InputIterator __last);
 
     template <class _ForwardIterator, __enable_if_t<__has_forward_iterator_category<_ForwardIterator>::value, int> = 0>
     inline _LIBCPP_CONSTEXPR_SINCE_CXX20 void __init(_ForwardIterator __first, _ForwardIterator __last);
 
+    template <class _InputIterator, class _Sentinel>
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
+    void __init_with_sentinel(_InputIterator __first, _Sentinel __last);
+    template <class _InputIterator, class _Sentinel>
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
+    void __init_with_size(_InputIterator __first, _Sentinel __last, size_type __sz);
+
     _LIBCPP_CONSTEXPR_SINCE_CXX20
     void __grow_by(size_type __old_cap, size_type __delta_cap, size_type __old_sz,
                    size_type __n_copy,  size_type __n_del,     size_type __n_add = 0);
     _LIBCPP_CONSTEXPR_SINCE_CXX20
     void __grow_by_and_replace(size_type __old_cap, size_type __delta_cap, size_type __old_sz,
                                size_type __n_copy,  size_type __n_del,
                                size_type __n_add, const value_type* __p_new_stuff);
 
template<class _CharT,
          class _Allocator = allocator<_CharT>,
          class = enable_if_t<__is_allocator<_Allocator>::value>,
          class _Sz = typename allocator_traits<_Allocator>::size_type
          >
 basic_string(basic_string_view<_CharT, _Traits>, _Sz, _Sz, const _Allocator& = _Allocator())
   -> basic_string<_CharT, _Traits, _Allocator>;
 #endif
 
+#if _LIBCPP_STD_VER >= 23
+template <ranges::input_range _Range,
+          class _Allocator = allocator<ranges::range_value_t<_Range>>,
+          class = enable_if_t<__is_allocator<_Allocator>::value>
+          >
+basic_string(from_range_t, _Range&&, _Allocator = _Allocator())
+  -> basic_string<ranges::range_value_t<_Range>, char_traits<ranges::range_value_t<_Range>>, _Allocator>;
+#endif
+
 template <class _CharT, class _Traits, class _Allocator>
 _LIBCPP_CONSTEXPR_SINCE_CXX20
 void basic_string<_CharT, _Traits, _Allocator>::__init(const value_type* __s,
                                                        size_type __sz,
                                                        size_type __reserve)
 {
     if (__libcpp_is_constant_evaluated())
         __r_.first() = __rep();
basic_string<_CharT, _Traits, _Allocator>::__init(size_type __n, value_type __c)
     traits_type::assign(__p[__n], value_type());
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 template <class _InputIterator, __enable_if_t<__has_exactly_input_iterator_category<_InputIterator>::value, int> >
 _LIBCPP_CONSTEXPR_SINCE_CXX20
 void basic_string<_CharT, _Traits, _Allocator>::__init(_InputIterator __first, _InputIterator __last)
 {
+  __init_with_sentinel(std::move(__first), std::move(__last));
+}
+
+template <class _CharT, class _Traits, class _Allocator>
+template <class _InputIterator, class _Sentinel>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
+void basic_string<_CharT, _Traits, _Allocator>::__init_with_sentinel(_InputIterator __first, _Sentinel __last) {
     __default_init();
+
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
     try
     {
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
     for (; __first != __last; ++__first)
         push_back(*__first);
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
     }
     catch (...)
     {
         if (__is_long())
             __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap());
         throw;
     }
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 template <class _ForwardIterator, __enable_if_t<__has_forward_iterator_category<_ForwardIterator>::value, int> >
 _LIBCPP_CONSTEXPR_SINCE_CXX20 void
 basic_string<_CharT, _Traits, _Allocator>::__init(_ForwardIterator __first, _ForwardIterator __last)
 {
+  size_type __sz = static_cast<size_type>(std::distance(__first, __last));
+  __init_with_size(__first, __last, __sz);
+}
+
+template <class _CharT, class _Traits, class _Allocator>
+template <class _InputIterator, class _Sentinel>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
+void basic_string<_CharT, _Traits, _Allocator>::__init_with_size(
+    _InputIterator __first, _Sentinel __last, size_type __sz) {
     if (__libcpp_is_constant_evaluated())
         __r_.first() = __rep();
-    size_type __sz = static_cast<size_type>(std::distance(__first, __last));
+
     if (__sz > max_size())
         __throw_length_error();
+
     pointer __p;
     if (__fits_in_sso(__sz))
     {
         __set_short_size(__sz);
         __p = __get_short_pointer();
+
     }
     else
     {
         auto __allocation = std::__allocate_at_least(__alloc(), __recommend(__sz) + 1);
         __p = __allocation.ptr;
         __begin_lifetime(__p, __allocation.count);
         __set_long_pointer(__p);
         __set_long_cap(__allocation.count);

 
 #endif
 
 template <class _CharT, class _Traits, class _Allocator>
 template<class _InputIterator, __enable_if_t<__has_exactly_input_iterator_category<_InputIterator>::value, int> >
 _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::assign(_InputIterator __first, _InputIterator __last)
 {
-    const basic_string __temp(__first, __last, __alloc());
-    assign(__temp.data(), __temp.size());
-    return *this;
+  __assign_with_sentinel(__first, __last);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
+template <class _InputIterator, class _Sentinel>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
+void
+basic_string<_CharT, _Traits, _Allocator>::__assign_with_sentinel(_InputIterator __first, _Sentinel __last) {
+  const basic_string __temp(__init_with_sentinel_tag(), std::move(__first), std::move(__last), __alloc());
+  assign(__temp.data(), __temp.size());
+}
+
+template <class _CharT, class _Traits, class _Allocator>
 template<class _ForwardIterator, __enable_if_t<__has_forward_iterator_category<_ForwardIterator>::value, int> >
 _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::assign(_ForwardIterator __first, _ForwardIterator __last)
 {
-    size_type __cap = capacity();
-    size_type __n = __string_is_trivial_iterator<_ForwardIterator>::value ?
-        static_cast<size_type>(std::distance(__first, __last)) : 0;
+  if (__string_is_trivial_iterator<_ForwardIterator>::value) {
+    size_type __n = static_cast<size_type>(std::distance(__first, __last));
+    __assign_trivial(__first, __last, __n);
+  } else {
+    __assign_with_sentinel(__first, __last);
+  }
 
-    if (__string_is_trivial_iterator<_ForwardIterator>::value &&
-        (__cap >= __n || !__addr_in_range(*__first)))
-    {
-        if (__cap < __n)
-        {
-            size_type __sz = size();
-            __grow_by(__cap, __n - __cap, __sz, 0, __sz);
-        }
-        pointer __p = __get_pointer();
-        for (; __first != __last; ++__p, (void) ++__first)
-            traits_type::assign(*__p, *__first);
-        traits_type::assign(*__p, value_type());
-        __set_size(__n);
-    }
-    else
-    {
-        const basic_string __temp(__first, __last, __alloc());
-        assign(__temp.data(), __temp.size());
-    }
-    return *this;
-}
+  return *this;
+}
+
+template <class _CharT, class _Traits, class _Allocator>
+template <class _Iterator, class _Sentinel>
+_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
+void
+basic_string<_CharT, _Traits, _Allocator>::__assign_trivial(_Iterator __first, _Sentinel __last, size_type __n) {
+  _LIBCPP_ASSERT_UNCATEGORIZED(
+      __string_is_trivial_iterator<_Iterator>::value, "The iterator type given to `__assign_trivial` must be trivial");
+
+  size_type __cap = capacity();
+  if (__cap < __n) {
+    // Unlike `append` functions, if the input range points into the string itself, there is no case that the input
+    // range could get invalidated by reallocation:
+    // 1. If the input range is a subset of the string itself, its size cannot exceed the capacity of the string,
+    //    thus no reallocation would happen.
+    // 2. In the exotic case where the input range is the byte representation of the string itself, the string
+    //    object itself stays valid even if reallocation happens.
 
 template <class _CharT, class _Traits, class _Allocator>
 _LIBCPP_CONSTEXPR_SINCE_CXX20
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::assign(const basic_string& __str, size_type __pos, size_type __n)
 {
     size_type __sz = __str.size();
     if (__pos > __sz)
basic_string<_CharT, _Traits, _Allocator>::insert(const_iterator __pos, _InputIterator __first, _InputIterator __last)
   return insert(__pos, __temp.data(), __temp.data() + __temp.size());
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 template<class _ForwardIterator, __enable_if_t<__has_forward_iterator_category<_ForwardIterator>::value, int> >
 _LIBCPP_CONSTEXPR_SINCE_CXX20 typename basic_string<_CharT, _Traits, _Allocator>::iterator
 basic_string<_CharT, _Traits, _Allocator>::insert(const_iterator __pos, _ForwardIterator __first, _ForwardIterator __last)
 {
+    auto __n = static_cast<size_type>(std::distance(__first, __last));
+    return __insert_with_size(__pos, __first, __last, __n);
+}
+
+template <class _CharT, class _Traits, class _Allocator>
+template<class _Iterator, class _Sentinel>
+_LIBCPP_CONSTEXPR_SINCE_CXX20
+typename basic_string<_CharT, _Traits, _Allocator>::iterator
+basic_string<_CharT, _Traits, _Allocator>::__insert_with_size(
+    const_iterator __pos, _Iterator __first, _Sentinel __last, size_type __n) {
     size_type __ip = static_cast<size_type>(__pos - begin());
-    size_type __n = static_cast<size_type>(std::distance(__first, __last));
     if (__n == 0)
         return begin() + __ip;
 
-    if (__string_is_trivial_iterator<_ForwardIterator>::value && !__addr_in_range(*__first))
+    if (__string_is_trivial_iterator<_Iterator>::value && !__addr_in_range(*__first))
     {
         return __insert_from_safe_copy(__n, __ip, __first, __last);
     }
     else
     {
-        const basic_string __temp(__first, __last, __alloc());
+        const basic_string __temp(__init_with_sentinel_tag(), __first, __last, __alloc());
         return __insert_from_safe_copy(__n, __ip, __temp.begin(), __temp.end());
     }
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 _LIBCPP_CONSTEXPR_SINCE_CXX20
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos1, const basic_string& __str,

libcxx/test/std/strings/basic.string/string.cons/from_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, c++20
+
+// template<container-compatible-range<charT> R>
+//   constexpr basic_string(from_range_t, R&& rg, const Allocator& a = Allocator());           // since C++23
+
+#include <algorithm>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "../../../containers/from_range_helpers.h"
+#include "../../../containers/sequences/from_range_sequence_containers.h"
+#include "test_macros.h"
+
+template <class Container, class Range, class Alloc>
+concept StringHasFromRangeAllocCtr = requires (Range&& range, const Alloc& alloc) {
+  Container(std::from_range, std::forward<Range>(range), alloc);
+};
+
+constexpr bool test_constraints() {
+  // (from_range, range)
+  //
+  // Input range with the same value type.
+  static_assert(HasFromRangeCtr<std::string, InputRange<char>>);
+  // Input range with a convertible value type.
+  static_assert(HasFromRangeCtr<std::string, InputRange<int>>);
+  // Input range with a non-convertible value type.
+  static_assert(!HasFromRangeCtr<std::string, InputRange<Empty>>);
+  // Not an input range.
+  static_assert(!HasFromRangeCtr<std::string, InputRangeNotDerivedFrom>);
+  static_assert(!HasFromRangeCtr<std::string, InputRangeNotIndirectlyReadable>);
+  static_assert(!HasFromRangeCtr<std::string, InputRangeNotInputOrOutputIterator>);
+
+  // (from_range, range, alloc)
+  //
+  // Input range with the same value type.
+  using Alloc = test_allocator<char>;
+  using StringWithAlloc = std::basic_string<char, std::char_traits<char>, Alloc>;
+  static_assert(StringHasFromRangeAllocCtr<StringWithAlloc, InputRange<char>, Alloc>);
+  // Input range with a convertible value type.
+  static_assert(StringHasFromRangeAllocCtr<StringWithAlloc, InputRange<int>, Alloc>);
+  // Input range with a non-convertible value type.
+  static_assert(!StringHasFromRangeAllocCtr<StringWithAlloc, InputRange<Empty>, Alloc>);
+  // Not an input range.
+  static_assert(!StringHasFromRangeAllocCtr<StringWithAlloc, InputRangeNotDerivedFrom, Alloc>);
+  static_assert(!StringHasFromRangeAllocCtr<StringWithAlloc, InputRangeNotIndirectlyReadable, Alloc>);
+  static_assert(!StringHasFromRangeAllocCtr<StringWithAlloc, InputRangeNotInputOrOutputIterator, Alloc>);
+  // Not an allocator.
+  static_assert(!StringHasFromRangeAllocCtr<StringWithAlloc, InputRange<char>, Empty>);
+
+  return true;
+}
+
+template <class Iter,
+          class Sent,
+          class Alloc>
+constexpr void test_with_input(std::vector<char> input) {
+  auto b = Iter(input.data());
+  auto e = Iter(input.data() + input.size());
+  std::ranges::subrange in(std::move(b), Sent(std::move(e)));
+
+  { // (range)
+    std::string c(std::from_range, in);
+
+    LIBCPP_ASSERT(c.__invariants());
+    assert(c.size() == static_cast<std::size_t>(std::distance(c.begin(), c.end())));
+    assert(std::ranges::equal(in, c));
+  }
+
+  { // (range, allocator)
+    Alloc alloc;
+    std::basic_string<char, std::char_traits<char>, Alloc> c(std::from_range, in, alloc);
+
+    LIBCPP_ASSERT(c.__invariants());
+    assert(c.get_allocator() == alloc);
+    assert(c.size() == static_cast<std::size_t>(std::distance(c.begin(), c.end())));
+    assert(std::ranges::equal(in, c));
+  }
+}
+
+void test_string_exception_safety_throwing_allocator() {
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+  try {
+    ThrowingAllocator<char> alloc;
+
+    globalMemCounter.reset();
+    // Note: the input string must be long enough to prevent SSO, otherwise the allocator won't be used.
+    std::basic_string<char, std::char_traits<char>, ThrowingAllocator<char>> c(
+        std::from_range, std::vector<char>(64, 'A'), alloc);
+    assert(false); // The constructor call should throw.
+
+  } catch (int) {
+    assert(globalMemCounter.new_called == globalMemCounter.delete_called);
+  }
+#endif
+}
+
+constexpr bool test_inputs() {
+  for_all_iterators_and_allocators<char>([]<class Iter, class Sent, class Alloc>() {
+    // Shorter input -- SSO.
+    test_with_input<Iter, Sent, Alloc>({'a', 'b', 'c', 'd', 'e'});
+    // Longer input -- no SSO.
+    test_with_input<Iter, Sent, Alloc>(std::vector<char>(64, 'A'));
+    // Empty input.
+    test_with_input<Iter, Sent, Alloc>({});
+    // Single-element input.
+    test_with_input<Iter, Sent, Alloc>({'a'});
+  });
+
+  return true;
+}
+
+int main(int, char**) {
+  test_inputs();
+  static_assert(test_inputs());
+
+  static_assert(test_constraints());
+
+  // Note: `test_exception_safety_throwing_copy` doesn't apply because copying a `char` cannot throw.
+  test_string_exception_safety_throwing_allocator();
+
+  return 0;
+}

libcxx/test/std/strings/basic.string/string.cons/from_range_deduction.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
+//
+//===----------------------------------------------------------------------===//
+
+// <string>
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+// To silence a GCC warning-turned-error re. `BadAlloc::value_type`.
+// ADDITIONAL_COMPILE_FLAGS: -Wno-unused-local-typedefs
+
+// template<ranges::input_range R,
+//          class Allocator = allocator<ranges::range_value_t<R>>>
+//   basic_string(from_range_t, R&&, Allocator = Allocator())
+//     -> basic_string<ranges::range_value_t<R>, char_traits<ranges::range_value_t<R>>,
+//                     Allocator>; // C++23
+//
+// The deduction guide shall not participate in overload resolution if Allocator
+// is a type that does not qualify as an allocator (in addition to the `input_range` concept being satisfied by `R`).
+
+#include <array>
+#include <string>
+
+#include "deduction_guides_sfinae_checks.h"
+#include "test_allocator.h"
+
+int main(int, char**) {
+  using Char = char16_t;
+
+  {
+    std::basic_string c(std::from_range, std::array<Char, 0>());
+    static_assert(std::is_same_v<decltype(c), std::basic_string<Char>>);
+  }
+
+  {
+    using Alloc = test_allocator<Char>;
+    std::basic_string c(std::from_range, std::array<Char, 0>(), Alloc());
+    static_assert(std::is_same_v<decltype(c), std::basic_string<Char, std::char_traits<Char>, Alloc>>);
+  }
+
+  // Note: defining `value_type` is a workaround because one of the deduction guides will end up instantiating
+  // `basic_string`, and that would fail with a hard error if the given allocator doesn't define `value_type`.
+  struct BadAlloc { using value_type = char; };
+  SequenceContainerDeductionGuidesSfinaeAway<std::basic_string, std::basic_string<char>, BadAlloc>();
+
+  return 0;
+}

libcxx/test/std/strings/basic.string/string.cons/iter_alloc_deduction.pass.cpp

 template <class Iter, class Alloc>
 struct CanDeduce<Iter, Alloc, decltype((void)
   std::basic_string{std::declval<Iter>(), std::declval<Iter>(), std::declval<Alloc>()}
 )> : std::true_type { };
 
 static_assert( CanDeduce<char*, std::allocator<char>>::value);
 static_assert(!CanDeduce<NotAnIterator, std::allocator<char>>::value);
 static_assert(!CanDeduce<NotAnInputIterator, std::allocator<char16_t>>::value);
+static_assert(!CanDeduce<char*, NotAnAllocator<char>>::value);
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
 static_assert( CanDeduce<wchar_t*, std::allocator<wchar_t>>::value);
 static_assert(!CanDeduce<wchar_t const*, NotAnAllocator<wchar_t>>::value);
 #endif
 
 TEST_CONSTEXPR_CXX20 bool test() {
   {
     const char* s = "12345678901234";

libcxx/test/std/strings/basic.string/string.modifiers/string_append/append_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, c++20
+
+// template<container-compatible-range<charT> R>
+//   constexpr basic_string& append_range(R&& rg); // C++23
+
+#include <string>
+
+#include "../../../../containers/sequences/insert_range_sequence_containers.h"
+#include "test_macros.h"
+
+// Tested cases:
+// - different kinds of insertions (appending an {empty/one-element/mid-sized/long range} into an
+//   {empty/one-element/full} container);
+// - an exception is thrown when allocating new elements.
+
+constexpr bool test_constexpr() {
+  for_all_iterators_and_allocators_constexpr<char, const char*>([]<class Iter, class Sent, class Alloc>() {
+    test_sequence_append_range<std::basic_string<char, std::char_traits<char>, Alloc>, Iter, Sent>([](auto&& c) {
+      LIBCPP_ASSERT(c.__invariants());
+    });
+  });
+
+  return true;
+}
+
+int main(int, char**) {
+  static_assert(test_constraints_append_range<std::basic_string, char, int>());
+
+  for_all_iterators_and_allocators<char, const char*>([]<class Iter, class Sent, class Alloc>() {
+    test_sequence_append_range<std::basic_string<char, std::char_traits<char>, Alloc>, Iter, Sent>([](auto&& c) {
+      LIBCPP_ASSERT(c.__invariants());
+    });
+  });
+  static_assert(test_constexpr());
+
+  { // Check that `append_range` returns a reference to the string.
+    std::string c;
+    static_assert(std::is_lvalue_reference_v<decltype(
+        c.append_range(FullContainer_Begin_EmptyRange<char>.input)
+    )>);
+    assert(&c.append_range(FullContainer_Begin_EmptyRange<char>.input) == &c);
+    assert(&c.append_range(FullContainer_Begin_OneElementRange<char>.input) == &c);
+    assert(&c.append_range(FullContainer_Begin_MidRange<char>.input) == &c);
+    assert(&c.append_range(FullContainer_Begin_LongRange<char>.input) == &c);
+  }
+
+  // Note: `test_append_range_exception_safety_throwing_copy` doesn't apply because copying chars cannot throw.
+  {
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+    // Note: the input string must be long enough to prevent SSO, otherwise the allocator won't be used.
+    std::string in(64, 'a');
+
+    try {
+      ThrowingAllocator<char> alloc;
+
+      globalMemCounter.reset();
+      std::basic_string<char, std::char_traits<char>, ThrowingAllocator<char>> c(alloc);
+      c.append_range(in);
+      assert(false); // The function call above should throw.
+
+    } catch (int) {
+      assert(globalMemCounter.new_called == globalMemCounter.delete_called);
+    }
+#endif
+  }
+
+  return 0;
+}

libcxx/test/std/strings/basic.string/string.modifiers/string_assign/assign_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, c++20
+
+// template<container-compatible-range<charT> R>
+//   constexpr basic_string& assign_range(R&& rg); // C++23
+
+#include <string>
+
+#include "../../../../containers/sequences/insert_range_sequence_containers.h"
+#include "test_macros.h"
+
+// Tested cases:
+// - different kinds of assignments (assigning an {empty/one-element/mid-sized/long range} to an
+//   {empty/one-element/full} container);
+// - an exception is thrown when allocating new elements.
+
+constexpr bool test_constexpr() {
+  for_all_iterators_and_allocators_constexpr<char, const char*>([]<class Iter, class Sent, class Alloc>() {
+    test_sequence_assign_range<std::basic_string<char, std::char_traits<char>, Alloc>, Iter, Sent>([](auto&& c) {
+      LIBCPP_ASSERT(c.__invariants());
+    });
+  });
+
+  return true;
+}
+
+int main(int, char**) {
+  static_assert(test_constraints_assign_range<std::basic_string, char, int>());
+
+  for_all_iterators_and_allocators<char, const char*>([]<class Iter, class Sent, class Alloc>() {
+    test_sequence_assign_range<std::basic_string<char, std::char_traits<char>, Alloc>, Iter, Sent>([](auto&& c) {
+      LIBCPP_ASSERT(c.__invariants());
+    });
+  });
+  static_assert(test_constexpr());
+
+  { // Check that `assign_range` returns a reference to the string.
+    std::string c;
+    static_assert(std::is_lvalue_reference_v<decltype(
+        c.assign_range(FullContainer_Begin_EmptyRange<char>.input)
+    )>);
+    assert(&c.assign_range(FullContainer_Begin_EmptyRange<char>.input) == &c);
+    assert(&c.assign_range(FullContainer_Begin_OneElementRange<char>.input) == &c);
+    assert(&c.assign_range(FullContainer_Begin_MidRange<char>.input) == &c);
+    assert(&c.assign_range(FullContainer_Begin_LongRange<char>.input) == &c);
+  }
+
+  // Note: `test_assign_range_exception_safety_throwing_copy` doesn't apply because copying chars cannot throw.
+  {
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+    // Note: the input string must be long enough to prevent SSO, otherwise the allocator won't be used.
+    std::string in(64, 'a');
+
+    try {
+      ThrowingAllocator<char> alloc;
+
+      globalMemCounter.reset();
+      std::basic_string<char, std::char_traits<char>, ThrowingAllocator<char>> c(alloc);
+      c.assign_range(in);
+      assert(false); // The function call above should throw.
+
+    } catch (int) {
+      assert(globalMemCounter.new_called == globalMemCounter.delete_called);
+    }
+#endif
+  }
+
+  return 0;
+}

libcxx/test/std/strings/basic.string/string.modifiers/string_insert/insert_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, c++20
+
+// template<container-compatible-range<charT> R>
+//   constexpr iterator insert_range(const_iterator p, R&& rg);                                // C++23
+
+#include <string>
+
+#include "../../../../containers/sequences/insert_range_sequence_containers.h"
+#include "test_macros.h"
+
+// Tested cases:
+// - different kinds of insertions (inserting an {empty/one-element/mid-sized/long range} into an
+//   {empty/one-element/full} container at the {beginning/middle/end});
+// - an exception is thrown when allocating new elements.
+
+constexpr bool test_constexpr() {
+  for_all_iterators_and_allocators_constexpr<char, const char*>([]<class Iter, class Sent, class Alloc>() {
+    test_sequence_insert_range<std::basic_string<char, std::char_traits<char>, Alloc>, Iter, Sent>([](auto&& c) {
+      LIBCPP_ASSERT(c.__invariants());
+    });
+  });
+
+  return true;
+}
+
+int main(int, char**) {
+  static_assert(test_constraints_insert_range<std::basic_string, char, int>());
+
+  for_all_iterators_and_allocators<char, const char*>([]<class Iter, class Sent, class Alloc>() {
+    test_sequence_insert_range<std::basic_string<char, std::char_traits<char>, Alloc>, Iter, Sent>([](auto&& c) {
+      LIBCPP_ASSERT(c.__invariants());
+    });
+  });
+  static_assert(test_constexpr());
+
+  // Note: `test_insert_range_exception_safety_throwing_copy` doesn't apply because copying chars cannot throw.
+  {
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+    // Note: the input string must be long enough to prevent SSO, otherwise the allocator won't be used.
+    std::string in(64, 'a');
+
+    try {
+      ThrowingAllocator<char> alloc;
+
+      globalMemCounter.reset();
+      std::basic_string<char, std::char_traits<char>, ThrowingAllocator<char>> c(alloc);
+      c.insert_range(c.end(), in);
+      assert(false); // The function call above should throw.
+
+    } catch (int) {
+      assert(globalMemCounter.new_called == globalMemCounter.delete_called);
+    }
+#endif
+  }
+
+  return 0;
+}

libcxx/test/std/strings/basic.string/string.modifiers/string_replace/replace_with_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, c++20
+// ADDITIONAL_COMPILE_FLAGS(has-fconstexpr-steps): -fconstexpr-steps=10000000
+// ADDITIONAL_COMPILE_FLAGS(has-fconstexpr-ops-limit): -fconstexpr-ops-limit=70000000
+
+// template<container-compatible-range<charT> R>
+//   constexpr basic_string& replace_with_range(const_iterator i1, const_iterator i2, R&& rg); // C++23
+
+#include <string>
+#include <utility>
+
+#include "../../../../containers/sequences/insert_range_sequence_containers.h"
+#include "test_macros.h"
+
+template <class Range>
+concept HasReplaceWithRange = requires (std::string& c, Range&& range) {
+  c.replace_with_range(c.end(), c.end(), std::forward<Range>(range));
+};
+
+constexpr bool test_constraints_replace_with_range() {
+  // Input range with the same value type.
+  static_assert(HasReplaceWithRange<InputRange<char>>);
+  // Input range with a convertible value type.
+  static_assert(HasReplaceWithRange<InputRange<unsigned char>>);
+  // Input range with a non-convertible value type.
+  static_assert(!HasReplaceWithRange<InputRange<Empty>>);
+  // Not an input range.
+  static_assert(!HasReplaceWithRange<InputRangeNotDerivedFrom>);
+  static_assert(!HasReplaceWithRange<InputRangeNotIndirectlyReadable>);
+  static_assert(!HasReplaceWithRange<InputRangeNotInputOrOutputIterator>);
+
+  return true;
+}
+
+using StrBuffer = Buffer<char, 256>;
+
+struct TestCaseReplacement {
+  StrBuffer initial;
+  std::size_t from = 0;
+  std::size_t to = 0;
+  StrBuffer input;
+  StrBuffer expected;
+};
+
+// Permutation matrix:
+// - initial string: empty / one-element / n elements;
+// - cut starts from: beginning / middle / end;
+// - cut size: empty / one-element / several elements / until the end;
+// - input range: empty / one-element / middle-sized / longer than SSO / longer than the current string capacity.
+
+// Empty string.
+
+constexpr TestCaseReplacement EmptyString_End_EmptyCut_EmptyRange {
+  .initial = "", .from = 0, .to = 0, .input = "", .expected = ""
+};
+
+constexpr TestCaseReplacement EmptyString_End_EmptyCut_OneElementRange {
+  .initial = "", .from = 0, .to = 0, .input = "a", .expected = "a"
+};
+
+constexpr TestCaseReplacement EmptyString_End_EmptyCut_MidRange {
+  .initial = "", .from = 0, .to = 0, .input = "aeiou", .expected = "aeiou"
+};
+
+constexpr TestCaseReplacement EmptyString_End_EmptyCut_LongRange {
+  .initial = "", .from = 0, .to = 0,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "abcdefghijklmnopqrstuvwxyz0123456789"
+};
+
+// One-element string.
+
+constexpr TestCaseReplacement OneElementString_Begin_EmptyCut_EmptyRange {
+  .initial = "B", .from = 0, .to = 0, .input = "", .expected = "B"
+};
+
+constexpr TestCaseReplacement OneElementString_Begin_EmptyCut_OneElementRange {
+  .initial = "B", .from = 0, .to = 0, .input = "a", .expected = "aB"
+};
+
+constexpr TestCaseReplacement OneElementString_Begin_EmptyCut_MidRange {
+  .initial = "B", .from = 0, .to = 0, .input = "aeiou", .expected = "aeiouB"
+};
+
+constexpr TestCaseReplacement OneElementString_Begin_EmptyCut_LongRange {
+  .initial = "B", .from = 0, .to = 0,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "abcdefghijklmnopqrstuvwxyz0123456789B"
+};
+
+constexpr TestCaseReplacement OneElementString_Begin_OneElementCut_EmptyRange {
+  .initial = "B", .from = 0, .to = 1, .input = "", .expected = ""
+};
+
+constexpr TestCaseReplacement OneElementString_Begin_OneElementCut_OneElementRange {
+  .initial = "B", .from = 0, .to = 1, .input = "a", .expected = "a"
+};
+
+constexpr TestCaseReplacement OneElementString_Begin_OneElementCut_MidRange {
+  .initial = "B", .from = 0, .to = 1, .input = "aeiou", .expected = "aeiou"
+};
+
+constexpr TestCaseReplacement OneElementString_Begin_OneElementCut_LongRange {
+  .initial = "B", .from = 0, .to = 1,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "abcdefghijklmnopqrstuvwxyz0123456789"
+};
+
+constexpr TestCaseReplacement OneElementString_End_EmptyCut_EmptyRange {
+  .initial = "B", .from = 1, .to = 1, .input = "", .expected = "B"
+};
+
+constexpr TestCaseReplacement OneElementString_End_EmptyCut_OneElementRange {
+  .initial = "B", .from = 1, .to = 1, .input = "a", .expected = "Ba"
+};
+
+constexpr TestCaseReplacement OneElementString_End_EmptyCut_MidRange {
+  .initial = "B", .from = 1, .to = 1, .input = "aeiou", .expected = "Baeiou"
+};
+
+constexpr TestCaseReplacement OneElementString_End_EmptyCut_LongRange {
+  .initial = "B", .from = 1, .to = 1,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "Babcdefghijklmnopqrstuvwxyz0123456789"
+};
+
+// Short string (using SSO).
+
+// Replace at the beginning.
+
+constexpr TestCaseReplacement ShortString_Begin_EmptyCut_EmptyRange {
+  .initial = "_BCDFGHJ_", .from = 0, .to = 0, .input = "", .expected = "_BCDFGHJ_"
+};
+
+constexpr TestCaseReplacement ShortString_Begin_EmptyCut_OneElementRange {
+  .initial = "_BCDFGHJ_", .from = 0, .to = 0, .input = "a", .expected = "a_BCDFGHJ_"
+};
+
+constexpr TestCaseReplacement ShortString_Begin_EmptyCut_MidRange {
+  .initial = "_BCDFGHJ_", .from = 0, .to = 0, .input = "aeiou", .expected = "aeiou_BCDFGHJ_"
+};
+
+constexpr TestCaseReplacement ShortString_Begin_EmptyCut_LongRange {
+  .initial = "_BCDFGHJ_", .from = 0, .to = 0,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "abcdefghijklmnopqrstuvwxyz0123456789_BCDFGHJ_"
+};
+
+constexpr TestCaseReplacement ShortString_Begin_OneElementCut_EmptyRange {
+  .initial = "_BCDFGHJ_", .from = 0, .to = 1, .input = "", .expected = "BCDFGHJ_"
+};
+
+constexpr TestCaseReplacement ShortString_Begin_OneElementCut_OneElementRange {
+  .initial = "_BCDFGHJ_", .from = 0, .to = 1, .input = "a", .expected = "aBCDFGHJ_"
+};
+
+constexpr TestCaseReplacement ShortString_Begin_OneElementCut_MidRange {
+  .initial = "_BCDFGHJ_", .from = 0, .to = 1, .input = "aeiou", .expected = "aeiouBCDFGHJ_"
+};
+
+constexpr TestCaseReplacement ShortString_Begin_OneElementCut_LongRange {
+  .initial = "_BCDFGHJ_", .from = 0, .to = 1,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "abcdefghijklmnopqrstuvwxyz0123456789BCDFGHJ_"
+};
+
+constexpr TestCaseReplacement ShortString_Begin_MidSizedCut_EmptyRange {
+  .initial = "_BCDFGHJ_", .from = 0, .to = 3, .input = "", .expected = "DFGHJ_"
+};
+
+constexpr TestCaseReplacement ShortString_Begin_MidSizedCut_OneElementRange {
+  .initial = "_BCDFGHJ_", .from = 0, .to = 3, .input = "a", .expected = "aDFGHJ_"
+};
+
+constexpr TestCaseReplacement ShortString_Begin_MidSizedCut_MidRange {
+  .initial = "_BCDFGHJ_", .from = 0, .to = 3, .input = "aeiou", .expected = "aeiouDFGHJ_"
+};
+
+// Note: this test case switches from SSO to non-SSO.
+constexpr TestCaseReplacement ShortString_Begin_MidSizedCut_LongRange {
+  .initial = "_BCDFGHJ_", .from = 0, .to = 3,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "abcdefghijklmnopqrstuvwxyz0123456789DFGHJ_"
+};
+
+constexpr TestCaseReplacement ShortString_Begin_CutToEnd_EmptyRange {
+  .initial = "_BCDFGHJ_", .from = 0, .to = 9, .input = "", .expected = ""
+};
+
+constexpr TestCaseReplacement ShortString_Begin_CutToEnd_OneElementRange {
+  .initial = "_BCDFGHJ_", .from = 0, .to = 9, .input = "a", .expected = "a"
+};
+
+constexpr TestCaseReplacement ShortString_Begin_CutToEnd_MidRange {
+  .initial = "_BCDFGHJ_", .from = 0, .to = 9, .input = "aeiou", .expected = "aeiou"
+};
+
+// Note: this test case switches from SSO to non-SSO.
+constexpr TestCaseReplacement ShortString_Begin_CutToEnd_LongRange {
+  .initial = "_BCDFGHJ_", .from = 0, .to = 9,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "abcdefghijklmnopqrstuvwxyz0123456789"
+};
+
+// Replace in the middle.
+
+constexpr TestCaseReplacement ShortString_Mid_EmptyCut_EmptyRange {
+  .initial = "_BCDFGHJ_", .from = 4, .to = 4, .input = "", .expected = "_BCDFGHJ_"
+};
+
+constexpr TestCaseReplacement ShortString_Mid_EmptyCut_OneElementRange {
+  .initial = "_BCDFGHJ_", .from = 4, .to = 4, .input = "a", .expected = "_BCDaFGHJ_"
+};
+
+constexpr TestCaseReplacement ShortString_Mid_EmptyCut_MidRange {
+  .initial = "_BCDFGHJ_", .from = 4, .to = 4, .input = "aeiou", .expected = "_BCDaeiouFGHJ_"
+};
+
+constexpr TestCaseReplacement ShortString_Mid_EmptyCut_LongRange {
+  .initial = "_BCDFGHJ_", .from = 4, .to = 4,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "_BCDabcdefghijklmnopqrstuvwxyz0123456789FGHJ_"
+};
+
+constexpr TestCaseReplacement ShortString_Mid_OneElementCut_EmptyRange {
+  .initial = "_BCDFGHJ_", .from = 4, .to = 5, .input = "", .expected = "_BCDGHJ_"
+};
+
+constexpr TestCaseReplacement ShortString_Mid_OneElementCut_OneElementRange {
+  .initial = "_BCDFGHJ_", .from = 4, .to = 5, .input = "a", .expected = "_BCDaGHJ_"
+};
+
+constexpr TestCaseReplacement ShortString_Mid_OneElementCut_MidRange {
+  .initial = "_BCDFGHJ_", .from = 4, .to = 5, .input = "aeiou", .expected = "_BCDaeiouGHJ_"
+};
+
+constexpr TestCaseReplacement ShortString_Mid_OneElementCut_LongRange {
+  .initial = "_BCDFGHJ_", .from = 4, .to = 5,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "_BCDabcdefghijklmnopqrstuvwxyz0123456789GHJ_"
+};
+
+constexpr TestCaseReplacement ShortString_Mid_MidSizedCut_EmptyRange {
+  .initial = "_BCDFGHJ_", .from = 4, .to = 7, .input = "", .expected = "_BCDJ_"
+};
+
+constexpr TestCaseReplacement ShortString_Mid_MidSizedCut_OneElementRange {
+  .initial = "_BCDFGHJ_", .from = 4, .to = 7, .input = "a", .expected = "_BCDaJ_"
+};
+
+constexpr TestCaseReplacement ShortString_Mid_MidSizedCut_MidRange {
+  .initial = "_BCDFGHJ_", .from = 4, .to = 7, .input = "aeiou", .expected = "_BCDaeiouJ_"
+};
+
+constexpr TestCaseReplacement ShortString_Mid_MidSizedCut_LongRange {
+  .initial = "_BCDFGHJ_", .from = 4, .to = 7,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "_BCDabcdefghijklmnopqrstuvwxyz0123456789J_"
+};
+
+constexpr TestCaseReplacement ShortString_Mid_CutToEnd_EmptyRange {
+  .initial = "_BCDFGHJ_", .from = 4, .to = 9, .input = "", .expected = "_BCD"
+};
+
+constexpr TestCaseReplacement ShortString_Mid_CutToEnd_OneElementRange {
+  .initial = "_BCDFGHJ_", .from = 4, .to = 9, .input = "a", .expected = "_BCDa"
+};
+
+constexpr TestCaseReplacement ShortString_Mid_CutToEnd_MidRange {
+  .initial = "_BCDFGHJ_", .from = 4, .to = 9, .input = "aeiou", .expected = "_BCDaeiou"
+};
+
+constexpr TestCaseReplacement ShortString_Mid_CutToEnd_LongRange {
+  .initial = "_BCDFGHJ_", .from = 4, .to = 9,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "_BCDabcdefghijklmnopqrstuvwxyz0123456789"
+};
+
+// Replace at the end.
+
+constexpr TestCaseReplacement ShortString_End_EmptyCut_EmptyRange {
+  .initial = "_BCDFGHJ_", .from = 9, .to = 9, .input = "", .expected = "_BCDFGHJ_"
+};
+
+constexpr TestCaseReplacement ShortString_End_EmptyCut_OneElementRange {
+  .initial = "_BCDFGHJ_", .from = 9, .to = 9, .input = "a", .expected = "_BCDFGHJ_a"
+};
+
+constexpr TestCaseReplacement ShortString_End_EmptyCut_MidRange {
+  .initial = "_BCDFGHJ_", .from = 9, .to = 9, .input = "aeiou", .expected = "_BCDFGHJ_aeiou"
+};
+
+constexpr TestCaseReplacement ShortString_End_EmptyCut_LongRange {
+  .initial = "_BCDFGHJ_", .from = 9, .to = 9,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "_BCDFGHJ_abcdefghijklmnopqrstuvwxyz0123456789"
+};
+
+// Long string (no SSO).
+
+// Replace at the beginning.
+
+constexpr TestCaseReplacement LongString_Begin_EmptyCut_EmptyRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 0, .to = 0, .input = "",
+  .expected = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Begin_EmptyCut_OneElementRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 0, .to = 0, .input = "a",
+  .expected = "a_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Begin_EmptyCut_MidRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 0, .to = 0, .input = "aeiou",
+  .expected = "aeiou_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Begin_EmptyCut_LongRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 0, .to = 0,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "abcdefghijklmnopqrstuvwxyz0123456789_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Begin_EmptyCut_LongerThanCapacityRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 0, .to = 0,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789_"
+           "abcdefghijklmnopqrstuvwxyz0123456789_"
+           "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "abcdefghijklmnopqrstuvwxyz0123456789_"
+              "abcdefghijklmnopqrstuvwxyz0123456789_"
+              "abcdefghijklmnopqrstuvwxyz0123456789"
+              "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Begin_OneElementCut_EmptyRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 0, .to = 1, .input = "",
+  .expected = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Begin_OneElementCut_OneElementRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 0, .to = 1, .input = "a",
+  .expected = "aABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Begin_OneElementCut_MidRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 0, .to = 1, .input = "aeiou",
+  .expected = "aeiouABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Begin_OneElementCut_LongRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 0, .to = 1,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Begin_OneElementCut_LongerThanCapacityRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 0, .to = 1,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789_"
+           "abcdefghijklmnopqrstuvwxyz0123456789_"
+           "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "abcdefghijklmnopqrstuvwxyz0123456789_"
+              "abcdefghijklmnopqrstuvwxyz0123456789_"
+              "abcdefghijklmnopqrstuvwxyz0123456789"
+              "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Begin_MidSizedCut_EmptyRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 0, .to = 3, .input = "",
+  .expected = "CDEFGHIJKLMNOPQRSTUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Begin_MidSizedCut_OneElementRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 0, .to = 3, .input = "a",
+  .expected = "aCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Begin_MidSizedCut_MidRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 0, .to = 3, .input = "aeiou",
+  .expected = "aeiouCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Begin_MidSizedCut_LongRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 0, .to = 3,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "abcdefghijklmnopqrstuvwxyz0123456789CDEFGHIJKLMNOPQRSTUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Begin_MidSizedCut_LongerThanCapacityRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 0, .to = 3,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789_"
+           "abcdefghijklmnopqrstuvwxyz0123456789_"
+           "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "abcdefghijklmnopqrstuvwxyz0123456789_"
+              "abcdefghijklmnopqrstuvwxyz0123456789_"
+              "abcdefghijklmnopqrstuvwxyz0123456789"
+              "CDEFGHIJKLMNOPQRSTUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Begin_CutToEnd_EmptyRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 0, .to = 38, .input = "",
+  .expected = ""
+};
+
+constexpr TestCaseReplacement LongString_Begin_CutToEnd_OneElementRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 0, .to = 38, .input = "a",
+  .expected = "a"
+};
+
+constexpr TestCaseReplacement LongString_Begin_CutToEnd_MidRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 0, .to = 38, .input = "aeiou",
+  .expected = "aeiou"
+};
+
+constexpr TestCaseReplacement LongString_Begin_CutToEnd_LongRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 0, .to = 38,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "abcdefghijklmnopqrstuvwxyz0123456789"
+};
+
+constexpr TestCaseReplacement LongString_Begin_CutToEnd_LongerThanCapacityRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 0, .to = 38,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789_"
+           "abcdefghijklmnopqrstuvwxyz0123456789_"
+           "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "abcdefghijklmnopqrstuvwxyz0123456789_"
+              "abcdefghijklmnopqrstuvwxyz0123456789_"
+              "abcdefghijklmnopqrstuvwxyz0123456789"
+};
+
+// Replace in the middle.
+
+constexpr TestCaseReplacement LongString_Mid_EmptyCut_EmptyRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 18, .to = 18, .input = "",
+  .expected = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Mid_EmptyCut_OneElementRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 18, .to = 18, .input = "a",
+  .expected = "_ABCDEFGHIJKLMNOPQaRSTUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Mid_EmptyCut_MidRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 18, .to = 18, .input = "aeiou",
+  .expected = "_ABCDEFGHIJKLMNOPQaeiouRSTUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Mid_EmptyCut_LongRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 18, .to = 18,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "_ABCDEFGHIJKLMNOPQabcdefghijklmnopqrstuvwxyz0123456789RSTUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Mid_EmptyCut_LongerThanCapacityRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 18, .to = 18,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789_"
+           "abcdefghijklmnopqrstuvwxyz0123456789_"
+           "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "_ABCDEFGHIJKLMNOPQ"
+              "abcdefghijklmnopqrstuvwxyz0123456789_"
+              "abcdefghijklmnopqrstuvwxyz0123456789_"
+              "abcdefghijklmnopqrstuvwxyz0123456789"
+              "RSTUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Mid_OneElementCut_EmptyRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 18, .to = 19, .input = "",
+  .expected = "_ABCDEFGHIJKLMNOPQSTUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Mid_OneElementCut_OneElementRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 18, .to = 19, .input = "a",
+  .expected = "_ABCDEFGHIJKLMNOPQaSTUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Mid_OneElementCut_MidRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 18, .to = 19, .input = "aeiou",
+  .expected = "_ABCDEFGHIJKLMNOPQaeiouSTUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Mid_OneElementCut_LongRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 18, .to = 19,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "_ABCDEFGHIJKLMNOPQabcdefghijklmnopqrstuvwxyz0123456789STUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Mid_OneElementCut_LongerThanCapacityRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 18, .to = 19,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789_"
+           "abcdefghijklmnopqrstuvwxyz0123456789_"
+           "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "_ABCDEFGHIJKLMNOPQ"
+              "abcdefghijklmnopqrstuvwxyz0123456789_"
+              "abcdefghijklmnopqrstuvwxyz0123456789_"
+              "abcdefghijklmnopqrstuvwxyz0123456789"
+              "STUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Mid_MidSizedCut_EmptyRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 18, .to = 21, .input = "",
+  .expected = "_ABCDEFGHIJKLMNOPQUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Mid_MidSizedCut_OneElementRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 18, .to = 21, .input = "a",
+  .expected = "_ABCDEFGHIJKLMNOPQaUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Mid_MidSizedCut_MidRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 18, .to = 21, .input = "aeiou",
+  .expected = "_ABCDEFGHIJKLMNOPQaeiouUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Mid_MidSizedCut_LongRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 18, .to = 21,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "_ABCDEFGHIJKLMNOPQabcdefghijklmnopqrstuvwxyz0123456789UVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Mid_MidSizedCut_LongerThanCapacityRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 18, .to = 21,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789_"
+           "abcdefghijklmnopqrstuvwxyz0123456789_"
+           "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "_ABCDEFGHIJKLMNOPQ"
+              "abcdefghijklmnopqrstuvwxyz0123456789_"
+              "abcdefghijklmnopqrstuvwxyz0123456789_"
+              "abcdefghijklmnopqrstuvwxyz0123456789"
+              "UVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_Mid_CutToEnd_EmptyRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 18, .to = 38, .input = "",
+  .expected = "_ABCDEFGHIJKLMNOPQ"
+};
+
+constexpr TestCaseReplacement LongString_Mid_CutToEnd_OneElementRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 18, .to = 38, .input = "a",
+  .expected = "_ABCDEFGHIJKLMNOPQa"
+};
+
+constexpr TestCaseReplacement LongString_Mid_CutToEnd_MidRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 18, .to = 38, .input = "aeiou",
+  .expected = "_ABCDEFGHIJKLMNOPQaeiou"
+};
+
+constexpr TestCaseReplacement LongString_Mid_CutToEnd_LongRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 18, .to = 38,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "_ABCDEFGHIJKLMNOPQabcdefghijklmnopqrstuvwxyz0123456789"
+};
+
+constexpr TestCaseReplacement LongString_Mid_CutToEnd_LongerThanCapacityRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 18, .to = 38,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789_"
+           "abcdefghijklmnopqrstuvwxyz0123456789_"
+           "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "_ABCDEFGHIJKLMNOPQ"
+              "abcdefghijklmnopqrstuvwxyz0123456789_"
+              "abcdefghijklmnopqrstuvwxyz0123456789_"
+              "abcdefghijklmnopqrstuvwxyz0123456789"
+};
+
+// Replace at the end.
+
+constexpr TestCaseReplacement LongString_End_EmptyCut_EmptyRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 38, .to = 38, .input = "",
+  .expected = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_"
+};
+
+constexpr TestCaseReplacement LongString_End_EmptyCut_OneElementRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 38, .to = 38, .input = "a",
+  .expected = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_a"
+};
+
+constexpr TestCaseReplacement LongString_End_EmptyCut_MidRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 38, .to = 38, .input = "aeiou",
+  .expected = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_aeiou"
+};
+
+constexpr TestCaseReplacement LongString_End_EmptyCut_LongRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 38, .to = 38,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_abcdefghijklmnopqrstuvwxyz0123456789"
+};
+
+constexpr TestCaseReplacement LongString_End_EmptyCut_LongerThanCapacityRange {
+  .initial = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_", .from = 38, .to = 38,
+  .input = "abcdefghijklmnopqrstuvwxyz0123456789_"
+           "abcdefghijklmnopqrstuvwxyz0123456789_"
+           "abcdefghijklmnopqrstuvwxyz0123456789",
+  .expected = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_"
+              "abcdefghijklmnopqrstuvwxyz0123456789_"
+              "abcdefghijklmnopqrstuvwxyz0123456789_"
+              "abcdefghijklmnopqrstuvwxyz0123456789"
+};
+
+template <class Iter, class Sent, class Alloc>
+constexpr void test_string_replace_with_range() {
+  auto test = [&](const TestCaseReplacement& test_case) {
+    using Container = std::basic_string<char, std::char_traits<char>, Alloc>;
+
+    auto get_pos = [](auto& c, auto index) { return std::ranges::next(c.begin(), index); };
+    Container c(test_case.initial.begin(), test_case.initial.end());
+    auto in = wrap_input<Iter, Sent>(test_case.input);
+    auto from = get_pos(c, test_case.from);
+    auto to = get_pos(c, test_case.to);
+
+    Container& result = c.replace_with_range(from, to, in);
+    assert(&result == &c);
+    LIBCPP_ASSERT(c.__invariants());
+    return std::ranges::equal(c, test_case.expected);
+  };
+
+  { // Empty string.
+    // empty_str.replace_with_range(end, end, empty_range)
+    assert(test(EmptyString_End_EmptyCut_EmptyRange));
+    // empty_str.replace_with_range(end, end, one_element_range)
+    assert(test(EmptyString_End_EmptyCut_OneElementRange));
+    // empty_str.replace_with_range(end, end, mid_range)
+    assert(test(EmptyString_End_EmptyCut_MidRange));
+    // empty_str.replace_with_range(end, end, long_range)
+    assert(test(EmptyString_End_EmptyCut_LongRange));
+  }
+
+  { // One-element string.
+    // one_element_str.replace_with_range(begin, begin, empty_range)
+    assert(test(OneElementString_Begin_EmptyCut_EmptyRange));
+    // one_element_str.replace_with_range(begin, begin, one_element_range)
+    assert(test(OneElementString_Begin_EmptyCut_OneElementRange));
+    // one_element_str.replace_with_range(begin, begin, mid_range)
+    assert(test(OneElementString_Begin_EmptyCut_MidRange));
+    // one_element_str.replace_with_range(begin, begin, long_range)
+    assert(test(OneElementString_Begin_EmptyCut_LongRange));
+    // one_element_str.replace_with_range(begin, begin + 1, empty_range)
+    assert(test(OneElementString_Begin_OneElementCut_EmptyRange));
+    // one_element_str.replace_with_range(begin, begin + 1, one_element_range)
+    assert(test(OneElementString_Begin_OneElementCut_OneElementRange));
+    // one_element_str.replace_with_range(begin, begin + 1, mid_range)
+    assert(test(OneElementString_Begin_OneElementCut_MidRange));
+    // one_element_str.replace_with_range(begin, begin + 1, long_range)
+    assert(test(OneElementString_Begin_OneElementCut_LongRange));
+    // one_element_str.replace_with_range(end, end, empty_range)
+    assert(test(OneElementString_End_EmptyCut_EmptyRange));
+    // one_element_str.replace_with_range(end, end, one_element_range)
+    assert(test(OneElementString_End_EmptyCut_OneElementRange));
+    // one_element_str.replace_with_range(end, end, mid_range)
+    assert(test(OneElementString_End_EmptyCut_MidRange));
+    // one_element_str.replace_with_range(end, end, long_range)
+    assert(test(OneElementString_End_EmptyCut_LongRange));
+  }
+
+  { // Short string.
+    // Replace at the beginning.
+
+    // short_str.replace_with_range(begin, begin, empty_range)
+    assert(test(ShortString_Begin_EmptyCut_EmptyRange));
+    // short_str.replace_with_range(begin, begin, one_element_range)
+    assert(test(ShortString_Begin_EmptyCut_OneElementRange));
+    // short_str.replace_with_range(begin, begin, mid_range)
+    assert(test(ShortString_Begin_EmptyCut_MidRange));
+    // short_str.replace_with_range(begin, begin, long_range)
+    assert(test(ShortString_Begin_EmptyCut_LongRange));
+    // short_str.replace_with_range(begin, begin + 1, empty_range)
+    assert(test(ShortString_Begin_OneElementCut_EmptyRange));
+    // short_str.replace_with_range(begin, begin + 1, one_element_range)
+    assert(test(ShortString_Begin_OneElementCut_OneElementRange));
+    // short_str.replace_with_range(begin, begin + 1, mid_range)
+    assert(test(ShortString_Begin_OneElementCut_MidRange));
+    // short_str.replace_with_range(begin, begin + 1, long_range)
+    assert(test(ShortString_Begin_OneElementCut_LongRange));
+    // short_str.replace_with_range(begin, begin + 3, empty_range)
+    assert(test(ShortString_Begin_MidSizedCut_EmptyRange));
+    // short_str.replace_with_range(begin, begin + 3, one_element_range)
+    assert(test(ShortString_Begin_MidSizedCut_OneElementRange));
+    // short_str.replace_with_range(begin, begin + 3, mid_range)
+    assert(test(ShortString_Begin_MidSizedCut_MidRange));
+    // short_str.replace_with_range(begin, begin + 3, long_range)
+    assert(test(ShortString_Begin_MidSizedCut_LongRange));
+    // short_str.replace_with_range(begin, end, empty_range)
+    assert(test(ShortString_Begin_CutToEnd_EmptyRange));
+    // short_str.replace_with_range(begin, end, one_element_range)
+    assert(test(ShortString_Begin_CutToEnd_OneElementRange));
+    // short_str.replace_with_range(begin, end, mid_range)
+    assert(test(ShortString_Begin_CutToEnd_MidRange));
+    // short_str.replace_with_range(begin, end, long_range)
+    assert(test(ShortString_Begin_CutToEnd_LongRange));
+
+    // Replace in the middle.
+
+    // short_str.replace_with_range(mid, mid, empty_range)
+    assert(test(ShortString_Mid_EmptyCut_EmptyRange));
+    // short_str.replace_with_range(mid, mid, one_element_range)
+    assert(test(ShortString_Mid_EmptyCut_OneElementRange));
+    // short_str.replace_with_range(mid, mid, mid_range)
+    assert(test(ShortString_Mid_EmptyCut_MidRange));
+    // short_str.replace_with_range(mid, mid, long_range)
+    assert(test(ShortString_Mid_EmptyCut_LongRange));
+    // short_str.replace_with_range(mid, mid + 1, empty_range)
+    assert(test(ShortString_Mid_OneElementCut_EmptyRange));
+    // short_str.replace_with_range(mid, mid + 1, one_element_range)
+    assert(test(ShortString_Mid_OneElementCut_OneElementRange));
+    // short_str.replace_with_range(mid, mid + 1, mid_range)
+    assert(test(ShortString_Mid_OneElementCut_MidRange));
+    // short_str.replace_with_range(mid, mid + 1, long_range)
+    assert(test(ShortString_Mid_OneElementCut_LongRange));
+    // short_str.replace_with_range(mid, mid + 3, empty_range)
+    assert(test(ShortString_Mid_MidSizedCut_EmptyRange));
+    // short_str.replace_with_range(mid, mid + 3, one_element_range)
+    assert(test(ShortString_Mid_MidSizedCut_OneElementRange));
+    // short_str.replace_with_range(mid, mid + 3, mid_range)
+    assert(test(ShortString_Mid_MidSizedCut_MidRange));
+    // short_str.replace_with_range(mid, mid + 3, long_range)
+    assert(test(ShortString_Mid_MidSizedCut_LongRange));
+    // short_str.replace_with_range(mid, end, empty_range)
+    assert(test(ShortString_Mid_CutToEnd_EmptyRange));
+    // short_str.replace_with_range(mid, end, one_element_range)
+    assert(test(ShortString_Mid_CutToEnd_OneElementRange));
+    // short_str.replace_with_range(mid, end, mid_range)
+    assert(test(ShortString_Mid_CutToEnd_MidRange));
+    // short_str.replace_with_range(mid, end, long_range)
+    assert(test(ShortString_Mid_CutToEnd_LongRange));
+
+    // Replace at the end.
+
+    // short_str.replace_with_range(end, end, empty_range)
+    assert(test(ShortString_End_EmptyCut_EmptyRange));
+    // short_str.replace_with_range(end, end, one_element_range)
+    assert(test(ShortString_End_EmptyCut_OneElementRange));
+    // short_str.replace_with_range(end, end, mid_range)
+    assert(test(ShortString_End_EmptyCut_MidRange));
+    // short_str.replace_with_range(end, end, long_range)
+    assert(test(ShortString_End_EmptyCut_LongRange));
+  }
+
+  { // Long string.
+    // Replace at the beginning.
+
+    // long_str.replace_with_range(begin, begin, empty_range)
+    assert(test(LongString_Begin_EmptyCut_EmptyRange));
+    // long_str.replace_with_range(begin, begin, one_element_range)
+    assert(test(LongString_Begin_EmptyCut_OneElementRange));
+    // long_str.replace_with_range(begin, begin, mid_range)
+    assert(test(LongString_Begin_EmptyCut_MidRange));
+    // long_str.replace_with_range(begin, begin, long_range)
+    assert(test(LongString_Begin_EmptyCut_LongRange));
+    // long_str.replace_with_range(begin, begin, longer_than_capacity_range)
+    assert(test(LongString_Begin_EmptyCut_LongerThanCapacityRange));
+    // long_str.replace_with_range(begin, begin + 1, empty_range)
+    assert(test(LongString_Begin_OneElementCut_EmptyRange));
+    // long_str.replace_with_range(begin, begin + 1, one_element_range)
+    assert(test(LongString_Begin_OneElementCut_OneElementRange));
+    // long_str.replace_with_range(begin, begin + 1, mid_range)
+    assert(test(LongString_Begin_OneElementCut_MidRange));
+    // long_str.replace_with_range(begin, begin + 1, long_range)
+    assert(test(LongString_Begin_OneElementCut_LongRange));
+    // long_str.replace_with_range(begin, begin + 1, longer_than_capacity_range)
+    assert(test(LongString_Begin_OneElementCut_LongerThanCapacityRange));
+    // long_str.replace_with_range(begin, begin + 3, empty_range)
+    assert(test(LongString_Begin_MidSizedCut_EmptyRange));
+    // long_str.replace_with_range(begin, begin + 3, one_element_range)
+    assert(test(LongString_Begin_MidSizedCut_OneElementRange));
+    // long_str.replace_with_range(begin, begin + 3, mid_range)
+    assert(test(LongString_Begin_MidSizedCut_MidRange));
+    // long_str.replace_with_range(begin, begin + 3, long_range)
+    assert(test(LongString_Begin_MidSizedCut_LongRange));
+    // long_str.replace_with_range(begin, begin + 3, longer_than_capacity_range)
+    assert(test(LongString_Begin_MidSizedCut_LongerThanCapacityRange));
+    // long_str.replace_with_range(begin, end, empty_range)
+    assert(test(LongString_Begin_CutToEnd_EmptyRange));
+    // long_str.replace_with_range(begin, end, one_element_range)
+    assert(test(LongString_Begin_CutToEnd_OneElementRange));
+    // long_str.replace_with_range(begin, end, mid_range)
+    assert(test(LongString_Begin_CutToEnd_MidRange));
+    // long_str.replace_with_range(begin, end, long_range)
+    assert(test(LongString_Begin_CutToEnd_LongRange));
+    // long_str.replace_with_range(begin, end, longer_than_capacity_range)
+    assert(test(LongString_Begin_CutToEnd_LongerThanCapacityRange));
+
+    // Replace in the middle.
+
+    // long_str.replace_with_range(mid, mid, empty_range)
+    assert(test(LongString_Mid_EmptyCut_EmptyRange));
+    // long_str.replace_with_range(mid, mid, one_element_range)
+    assert(test(LongString_Mid_EmptyCut_OneElementRange));
+    // long_str.replace_with_range(mid, mid, mid_range)
+    assert(test(LongString_Mid_EmptyCut_MidRange));
+    // long_str.replace_with_range(mid, mid, long_range)
+    assert(test(LongString_Mid_EmptyCut_LongRange));
+    // long_str.replace_with_range(mid, mid, longer_than_capacity_range)
+    assert(test(LongString_Mid_EmptyCut_LongerThanCapacityRange));
+    // long_str.replace_with_range(mid, mid + 1, empty_range)
+    assert(test(LongString_Mid_OneElementCut_EmptyRange));
+    // long_str.replace_with_range(mid, mid + 1, one_element_range)
+    assert(test(LongString_Mid_OneElementCut_OneElementRange));
+    // long_str.replace_with_range(mid, mid + 1, mid_range)
+    assert(test(LongString_Mid_OneElementCut_MidRange));
+    // long_str.replace_with_range(mid, mid + 1, long_range)
+    assert(test(LongString_Mid_OneElementCut_LongRange));
+    // long_str.replace_with_range(mid, mid + 1, longer_than_capacity_range)
+    assert(test(LongString_Mid_OneElementCut_LongerThanCapacityRange));
+    // long_str.replace_with_range(mid, mid + 3, empty_range)
+    assert(test(LongString_Mid_MidSizedCut_EmptyRange));
+    // long_str.replace_with_range(mid, mid + 3, one_element_range)
+    assert(test(LongString_Mid_MidSizedCut_OneElementRange));
+    // long_str.replace_with_range(mid, mid + 3, mid_range)
+    assert(test(LongString_Mid_MidSizedCut_MidRange));
+    // long_str.replace_with_range(mid, mid + 3, long_range)
+    assert(test(LongString_Mid_MidSizedCut_LongRange));
+    // long_str.replace_with_range(mid, mid + 3, longer_than_capacity_range)
+    assert(test(LongString_Mid_MidSizedCut_LongerThanCapacityRange));
+    // long_str.replace_with_range(mid, end, empty_range)
+    assert(test(LongString_Mid_CutToEnd_EmptyRange));
+    // long_str.replace_with_range(mid, end, one_element_range)
+    assert(test(LongString_Mid_CutToEnd_OneElementRange));
+    // long_str.replace_with_range(mid, end, mid_range)
+    assert(test(LongString_Mid_CutToEnd_MidRange));
+    // long_str.replace_with_range(mid, end, long_range)
+    assert(test(LongString_Mid_CutToEnd_LongRange));
+    // long_str.replace_with_range(mid, end, longer_than_capacity_range)
+    assert(test(LongString_Mid_CutToEnd_LongerThanCapacityRange));
+
+    // Replace at the end.
+
+    // long_str.replace_with_range(end, end, empty_range)
+    assert(test(LongString_End_EmptyCut_EmptyRange));
+    // long_str.replace_with_range(end, end, one_element_range)
+    assert(test(LongString_End_EmptyCut_OneElementRange));
+    // long_str.replace_with_range(end, end, mid_range)
+    assert(test(LongString_End_EmptyCut_MidRange));
+    // long_str.replace_with_range(end, end, long_range)
+    assert(test(LongString_End_EmptyCut_LongRange));
+    // long_str.replace_with_range(end, end, longer_than_capacity_range)
+    assert(test(LongString_End_EmptyCut_LongerThanCapacityRange));
+  }
+}
+
+constexpr void test_string_replace_with_range_rvalue_range() {
+  // Make sure that the input range can be passed by both an lvalue and an rvalue reference and regardless of constness.
+
+  { // Lvalue.
+    std::string in = "abc";
+    std::string c = "123";
+    c.replace_with_range(c.begin(), c.end(), in);
+  }
+
+  { // Const lvalue.
+    const std::string in = "abc";
+    std::string c = "123";
+    c.replace_with_range(c.begin(), c.end(), in);
+  }
+
+  { // Rvalue.
+    std::string in = "abc";
+    std::string c = "123";
+    c.replace_with_range(c.begin(), c.end(), std::move(in));
+  }
+
+  { // Const rvalue.
+    const std::string in = "abc";
+    std::string c = "123";
+    c.replace_with_range(c.begin(), c.end(), std::move(in));
+  }
+}
+
+constexpr bool test_constexpr() {
+  for_all_iterators_and_allocators_constexpr<char, const char*>([]<class Iter, class Sent, class Alloc>() {
+    test_string_replace_with_range<Iter, Sent, Alloc>();
+  });
+  test_string_replace_with_range_rvalue_range();
+
+  return true;
+}
+
+// Tested cases:
+// - different kinds of replacements (varying the size of the initial string, the cut point and the cut size, and the
+//   size of the input range);
+// - an exception is thrown when allocating new elements.
+int main(int, char**) {
+  static_assert(test_constraints_replace_with_range());
+
+  for_all_iterators_and_allocators<char, const char*>([]<class Iter, class Sent, class Alloc>() {
+    test_string_replace_with_range<Iter, Sent, Alloc>();
+  });
+  test_string_replace_with_range_rvalue_range();
+  static_assert(test_constexpr());
+
+  // Note: `test_string_replace_with_range_exception_safety_throwing_copy` doesn't apply because copying chars cannot
+  // throw.
+  {
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+    // Note: the input string must be long enough to prevent SSO, otherwise the allocator won't be used.
+    std::string in(64, 'a');
+
+    try {
+      ThrowingAllocator<char> alloc;
+
+      globalMemCounter.reset();
+      std::basic_string<char, std::char_traits<char>, ThrowingAllocator<char>> c(alloc);
+      c.replace_with_range(c.end(), c.end(), in);
+      assert(false); // The function call above should throw.
+
+    } catch (int) {
+      assert(globalMemCounter.new_called == globalMemCounter.delete_called);
+    }
+#endif
+  }
+
+  return 0;
+}