[libc++] Implement P1072R10 (std::basic_string::resize_and_overwrite)

[philnik]

• Remove unused includes

[Mordante]

Thanks for working on this!
Please mark the feature complete in libcxx/docs/Status/Cxx2bPapers.csv.

Please update libcxx/utils/generate_feature_test_macro_components.py with the new feature-test macro __cpp_lib_string_resize_and_overwrite; its values should be 202110L and run this script to update the appropriate tests.

I didn't have enough time to do a thorough review; I'll have a closer look after all issues have been addressed.

libcxx/include/string

160–163

Please update the synopsis.

template<class Operation>
constexpr void resize_and_overwrite(size_type n, Operation op); // since C++23

985

This looks wrong. "Implementations should avoid unnecessary copies and allocations" This may allocate more than required. The paper 3. Implementation refers to __resize_default_init as example.

libcxx/test/std/strings/basic.string/string.capacity/resize_and_overwrite.pass.cpp

14

Please use the entire signature of the function.

21

All tests are now done on an empty string. Please also test with non-empty strings.

65

It would be good to test with all string types. libcxx/test/support/make_string.h has a helper to create the same string for all supported string types. Then the test function can be templated on the string type.

77

Please use int main(int, char**).

80

Please return 0; Some of our supported platforms require this even for main.

[philnik]

• Using __resize_default_init now and extended tests

[• Quuxplusone]

libcxx/include/string

993

Line-break after constexpr, please.
Also, I certainly wouldn't complain if s/_Operation/_Op/.

994

http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2021/p1072r10.html doesn't mention any Constraints, only a Mandates that std::move(__o)(declval<_CharT*&>(), __n) should have an integer-like type. I don't think "integer-like-ness" is expressible in C++, but prove me wrong. :)
Anyway, this function definitely should not be constrained, because (1) the standard says it shouldn't be, and (2) if we get our constraint wrong then we're needlessly preventing valid use-cases.

...Hm, I guess [p1072r10] has a minor wording bug, because obviously they intended to mandate the type of std::move(op)(std::move(p), std::move(n)), not std::move(op)(p, n). I think we should "do what they mean, not what they say."

998

Forgot the std::move here. Please add a test case that catches this (e.g. use an _Op with a &&-ref-qualified operator(), and/or one where operator()() && and operator()() & do different things).

libcxx/test/std/strings/basic.string/string.capacity/resize_and_overwrite.pass.cpp

77

I question the usefulness of all of the "nonsense" strings. I understand "" and "Banane" (i.e. "short") and "long long string so no SSO", but the other five seem calculated only to make the z/OS folks unhappy. ;) If they're redundant, please eliminate them.

[philnik]

• Added move only tests

libcxx/include/string

993

What do you mean by

Also, I certainly wouldn't complain if s/_Operation/_Op/.

?

994

I think the paper is right. What would be the point of moving a raw pointer or a size_type?

[• Quuxplusone]

libcxx/include/string

993

"I wouldn't complain if X" means "I'm not asking for X, but I'd be pleased if X were to happen anyway." Okay, usually it means I'm asking for X. ;)
s/foo/bar/ is awk/sed-speak for "replace foo with bar."
As usual, the further down in the review I got, the more strongly I liked _Op over _Operation.

994

The question is whether it is permissible for libc++ to reject

std::string s;
s.resize_and_overwrite(100, [](char *p, int& n) {
    return 0;
});

or, vice versa, whether it is permissible for us to accept

std::string s;
s.resize_and_overwrite(100, [](char *p, int&& n) {
    return 0;
});

That is, it's not so much about the machine code generated as it is about the value-categories of things.

libcxx/test/std/strings/basic.string/string.capacity/resize_and_overwrite.pass.cpp

23–39

For the ref-qualification/value-category issue, this simple non-template test will suffice; you can get rid of move_only_functor.

void test_value_categories() {
    std::string s;
    s.resize_and_overwrite(10, [](char*&, size_t&) { return 0; });
    struct RefQual {
        int operator()(char *, size_t) && { return 0; }
    };
    s.resize_and_overwrite(10, RefQual());
}

(Here I'm following libstdc++ in assuming that p, n are passed as lvalues, even though I said above that they really ought to be passed as rvalues. If we hear that rvalues were intended, then just change & to && above.)

90–95

Throughout: I see your reason for using the names begin, size for Op's parameters, but I think it will be clearer to use p, n the same way the standard does. Also, speaking of s.begin() and s.size(), it looks like you're assuming things about their values without asserting those things. Could we assert them instead?

constexpr void test_undersized(S src, S orig)
{
  S dst = orig;
  size_t new_size = 1.5 * src.size();
  auto func = [&](auto *p, size_t n) {
    assert(n == new_size);
    assert(dst.size() == new_size);
    p = std::copy_n(src.begin(), src.size(), p);
    std::copy_n(src.begin(), src.size() / 2, p);
    return n;
  };
  dst.resize_and_overwrite(new_size, func);
  assert(dst == src + src.substr(0, src.size() / 2);
}

But, writing it out this way, I just don't see the point of this test. What is orig doing there (your former s3)? Why does your func overwrite not just the new space but the original contents of the string too? What is the significance of the division in size() / 2 as opposed to using a constant like 42?
Could test_undersized and test_oversized both be replaced with something like...?

template<class S>
constexpr void test_appending(int k, int N) {
    assert(N > k);
    auto s = S(k, 'a');
    s.resize_and_overwrite(N, [&](char *p, int n) {
        assert(n == N);
        LIBCPP_ASSERT(s.size() == n);
        LIBCPP_ASSERT(s.begin() == p);
        assert(std::all_of(p, p+k, [](auto ch) { return ch == 'a'; }));
        LIBCPP_ASSERT(p[k] == '\0');
        std::fill(p+k, p+n, 'b');
        p[n] = 'c';  // will be overwritten
        return n;
    });
    auto expected = S(k, 'a') + S(N-k, 'b');
    assert(s == expected);
}

template<class S>
constexpr void test_truncating(int o, int N) {
    assert(N < o);
    auto s = S(o, 'a');
    s.resize_and_overwrite(N, [&](char *p, int n) {
        assert(n == N);
        LIBCPP_ASSERT(s.size() == n);
        LIBCPP_ASSERT(s.begin() == p);
        assert(std::all_of(p, p+n, [](auto ch) { return ch == 'a'; }));
        LIBCPP_ASSERT(p[n] == 'a');
        p[n-1] = 'b';
        p[n] = 'c';  // will be overwritten
        return n;
    });
    auto expected = S(N-1, 'a') + 'b';
    assert(s == expected);
}

However, this is still missing any coverage for what happens when op(p, n) < n. We should have coverage for that.

108–113

Throughout: IIUC, s1 means dest and s2 means src. (On line 87, s means dest and s3 means src. And so on.) Please consistent-ize the parameter names.

124

template<class CharT> — it's not a String.
Likewise on line 114 — class CharT, class S — although in that case, S is invariably basic_string<CharT>, so I don't see why it needs to be a parameter at all. Just using S = basic_string<CharT> in the body of the function is good enough.

133–135

(Moot) These lines are too long.
(1) Unless @ldionne asked for this (in which case his preference can overrule mine), I'd much much prefer to see the usual libc++ style of test_x(); static_assert(test_x()); written out longhand. It's only 10 lines of tests (as opposed to what you have here: 5 lines of tests plus 3 lines of macros).
(2) I don't understand why test_overwrite_str calls test_copy_strings calls test_all calls test_{exact_size, oversized, undersized}. These names don't seem to reflect any sort of hierarchy. I think it should just be that test<CharT> calls all the different tests, period.
(3) Only the one function that you're static_assert'ing on needs to return true; the rest should have return type void. (I suggest that that one bool-returning function should be named test<CharT>().)

[philnik]

Rebased and updated test

[• Quuxplusone]

LGTM at this point, mod minor comments.

libcxx/include/string

339–340

Please move this up to between resize and capacity, to match https://eel.is/c++draft/basic.string
...er, I guess we have some pre-existing issues in that ordering. Either just move this up to between resize and reserve, or else redistribute our synopses of reserve-thru-empty to match the Standard's synopsis ordering. (But I wouldn't recommend anything more drastic than that.)

2668

Here and line 3495, since we're changing it anyway, I'd prefer to see

_LIBCPP_CONSTEXPR_AFTER_CXX17 void

We shouldn't need the inline keyword at all, because this is a template; and constexpr void reads better than void constexpr.
https://quuxplusone.github.io/blog/2021/04/03/static-constexpr-whittling-knife/

libcxx/test/std/strings/basic.string/string.capacity/resize_and_overwrite.pass.cpp

24

Neat. Perhaps resizeSize should be named newCapacity? (The ultimate size of the final string will be N.)

62

I think you're missing an interesting case: something like test_appending<S>(10, 30, 15), where the original string fits in SSO, then we need to allocate for the lambda call, and then the final string would again fit in SSO (but IIUC we do not actually put it back into SSO — we just leave it with the extra allocated capacity, right? This is fine).

[Mordante]

In general this looks good! I've some minor nit. It also seems you missed some of my "bookkeeping" remarks. I added these as comments.

libcxx/include/string

339–340

Basically where my original request for updating the synopsis is ;-)

340

In my original reply I mentioned some not yet done things. For clarity I add them here to it's easier to tick the box once done.

Please mark the feature complete in libcxx/docs/Status/Cxx2bPapers.csv.

Please update libcxx/utils/generate_feature_test_macro_components.py with the new feature-test macro __cpp_lib_string_resize_and_overwrite; its values should be 202110L and run this script to update the appropriate tests.

996

Is there a reason to use variable instead of calling data() in __erase_to_end.
The LLVM coding convention doesn't like auto when the type isn't clear.

libcxx/test/std/strings/basic.string/string.capacity/resize_and_overwrite.pass.cpp

24

Also please use snake_case.

37

Please don't use auto.

38

Can you test whether s.c_str() contains a proper NUL-terminated string. The same for the truncating test.

87

Next time it would be better to make a helper function that calls all 5 variants, just to keep main simpler.

[• Quuxplusone]

libcxx/include/string

996

Sadly yes, OP's parameters are overspecified as lvalues, not prvalues. I've just requested an LWG issue number for this.
https://eel.is/c++draft/basic.string#string.capacity-7

libcxx/test/std/strings/basic.string/string.capacity/resize_and_overwrite.pass.cpp

38

Ah, +1; I'd been implicitly assuming that s == expected would also check the null byte, but I guess it doesn't necessarily have to.

const S expected = S(k, 'a') + S(N - k, 'b');
assert(s == expected);
assert(s.c_str()[N] == '\0');

87

I forget if I specifically requested the current status quo, but I very well might have — personally I like <10 LOC of code repetition in main better than a second layer of test functions. :)

[Mordante]

libcxx/include/string

996

In that case once you have a number, can you provide it here. Then we can add a comment why this is required. (And clean it up once the issue is resolved.)

libcxx/test/std/strings/basic.string/string.capacity/resize_and_overwrite.pass.cpp

87

I prefer the extra layer, especially due to the duplication for static_assert.
However I don't object against this version.

[philnik]

Added feature-test macro and some minor changes

[Mordante]

LGTM, assuming the CI passes.

[• Quuxplusone]

libcxx/include/string

996

@mzeren-vmw @ckennelly (paper authors), thoughts? Shall we even just go ahead and do the sane thing here, on the assumption that LWG will catch up to us? :)

[philnik]

• Remove _LIBCPP_CONSTEXPR_AFTER_CXX17
• Disable constexpr test

@Quuxplusone, @Mordante do you want to take another look before I land it?

[• Quuxplusone]

libcxx/include/string

996

The LWG issue for this is https://timsong-cpp.github.io/lwg-issues/3645
@philnik, I suggest that you land D113013 as-is (with the lvalue __data); but then (if you don't mind the extra work) I think you should immediately submit another PR that changes the offending line to __erase_to_end(_VSTD::move(__op)(data(), +__n)); with a message something like "[libc++] resize_and_overwrite: Adopt the P/R for LWG3645." I can't vouch for @ldionne, but personally I'd accept such a PR right away. :)

libcxx/test/std/strings/basic.string/string.capacity/resize_and_overwrite.pass.cpp

32

Nit: remove const, or add &, depending on your intent

[Mordante]

I don't mind landing it now, but let's make sure we show the correct state. In the followup patch you can then update the state to fully implemented.

libcxx/docs/Status/Cxx2bPapers.csv

29

Please add a note the constexpr part isn't done yet.
The LLVM 14 branching will happen later this month, so it's not certain the complete version will be in LLVM 14. So let's make the state correct.

libcxx/utils/generate_feature_test_macro_components.py

630

Likewise show the correct state.

[philnik]

@Mordante I'd argue that it is fully implemented. The function signature is complete. It only doesn't work, because the rest of string isn't constexpr yet. And P1679R3 is also marked complete, including feature test macro.

[Mordante]

Good point, then lets keep it as is.

[philnik]

• Address Arthur's nit

libcxx/docs/FeatureTestMacroTable.rst

.. table:: Current Status
     ``__cpp_lib_spanstream``                          *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_stacktrace``                          *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_stdatomic_h``                         *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_string_contains``                     ``202011L``
     ------------------------------------------------- -----------------
+    ``__cpp_lib_string_resize_and_overwrite``         ``202110L``
+    ------------------------------------------------- -----------------
     ``__cpp_lib_to_underlying``                       ``202102L``
     ================================================= =================
 

libcxx/docs/Status/Cxx2bPapers.csv

 "`P1951R1 <https://wg21.link/P1951R1>`__","LWG","Default Arguments for pair Forwarding Constructor","June 2021","|Complete|","14.0"
 "`P1989R2 <https://wg21.link/P1989R2>`__","LWG","Range constructor for std::string_view","June 2021","|Complete|","14.0"
 "`P2136R3 <https://wg21.link/P2136R3>`__","LWG","invoke_r","June 2021","",""
 "`P2166R1 <https://wg21.link/P2166R1>`__","LWG","A Proposal to Prohibit std::basic_string and std::basic_string_view construction from nullptr","June 2021","|Complete|","13.0"
 "","","","","",""
 "`P0288R9 <https://wg21.link/P0288R9>`__","LWG","``any_invocable``","October 2021","",""
 "`P0798R8 <https://wg21.link/P0798R8>`__","LWG","Monadic operations for ``std::optional``","October 2021","|Complete|","14.0"
 "`P0849R8 <https://wg21.link/P0849R8>`__","LWG","``auto(x)``: ``DECAY_COPY`` in the language","October 2021","|Complete|","14.0"
-"`P1072R10 <https://wg21.link/P1072R10>`__","LWG","``basic_string::resize_and_overwrite``","October 2021","",""
+"`P1072R10 <https://wg21.link/P1072R10>`__","LWG","``basic_string::resize_and_overwrite``","October 2021","|Complete|","14.0"
 "`P1147R1 <https://wg21.link/P1147R1>`__","LWG","Printing ``volatile`` Pointers","October 2021","|Complete|","14.0"
 "`P1272R4 <https://wg21.link/P1272R4>`__","LWG","Byteswapping for fun&&nuf","October 2021","|Complete|","14.0"
 "`P1675R2 <https://wg21.link/P1675R2>`__","LWG","``rethrow_exception`` must be allowed to copy","October 2021","",""
 "`P2077R3 <https://wg21.link/P2077R3>`__","LWG","Heterogeneous erasure overloads for associative containers","October 2021","",""
 "`P2251R1 <https://wg21.link/P2251R1>`__","LWG","Require ``span`` & ``basic_string_view`` to be Trivially Copyable","October 2021","|Complete|","14.0"
 "`P2301R1 <https://wg21.link/P2301R1>`__","LWG","Add a ``pmr`` alias for ``std::stacktrace``","October 2021","",""
 "`P2321R2 <https://wg21.link/P2321R2>`__","LWG","``zip``","October 2021","",""
 "`P2340R1 <https://wg21.link/P2340R1>`__","LWG","Clarifying the status of the 'C headers'","October 2021","",""
 "`P2393R1 <https://wg21.link/P2393R1>`__","LWG","Cleaning up ``integer``-class types","October 2021","",""
 "`P2401R0 <https://wg21.link/P2401R0>`__","LWG","Add a conditional ``noexcept`` specification to ``std::exchange``","October 2021","|Complete|","14.0"
 "","","","","",""

libcxx/include/string

// types:
 
     size_type size() const noexcept;
     size_type length() const noexcept;
     size_type max_size() const noexcept;
     size_type capacity() const noexcept;
 
     void resize(size_type n, value_type c);
     void resize(size_type n);
 
+    template<class Operation>
+    constexpr void resize_and_overwrite(size_type n, Operation op); // since C++23
+
     void reserve(size_type res_arg);
     void reserve(); // deprecated in C++20
     void shrink_to_fit();
     void clear() noexcept;
     bool empty() const noexcept;
 
     const_reference operator[](size_type pos) const;
     reference       operator[](size_type pos);
// types:
     bool ends_with(basic_string_view<charT, traits> sv) const noexcept;   // C++20
     bool ends_with(charT c) const noexcept;                               // C++20
     bool ends_with(const charT* s) const;                                 // C++20
 
     constexpr bool contains(basic_string_view<charT, traits> sv) const noexcept; // C++2b
     constexpr bool contains(charT c) const noexcept;                             // C++2b
     constexpr bool contains(const charT* s) const;                               // C++2b
 
     bool __invariants() const;
 };
 
 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
 
#endif // _LIBCPP_DEBUG_LEVEL == 2
     _LIBCPP_INLINE_VISIBILITY size_type capacity() const _NOEXCEPT
         {return (__is_long() ? __get_long_cap()
                              : static_cast<size_type>(__min_cap)) - 1;}
 
     void resize(size_type __n, value_type __c);
     _LIBCPP_INLINE_VISIBILITY void resize(size_type __n) {resize(__n, value_type());}
 
     void reserve(size_type __requested_capacity);
+
+#if _LIBCPP_STD_VER > 20
+    template <class _Op>
+    _LIBCPP_HIDE_FROM_ABI constexpr
+    void resize_and_overwrite(size_type __n, _Op __op) {
+      __resize_default_init(__n);
+      pointer __data = data();
+      __erase_to_end(_VSTD::move(__op)(__data, __n));
+    }
+#endif
+
     _LIBCPP_INLINE_VISIBILITY void __resize_default_init(size_type __n);
 
     _LIBCPP_DEPRECATED_IN_CXX20 _LIBCPP_INLINE_VISIBILITY
     void reserve() _NOEXCEPT {shrink_to_fit();}
     _LIBCPP_INLINE_VISIBILITY
     void shrink_to_fit() _NOEXCEPT;
     _LIBCPP_INLINE_VISIBILITY
     void clear() _NOEXCEPT;
     _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     bool empty() const _NOEXCEPT {return size() == 0;}
 
     _LIBCPP_INLINE_VISIBILITY const_reference operator[](size_type __pos) const _NOEXCEPT;
     _LIBCPP_INLINE_VISIBILITY reference       operator[](size_type __pos)       _NOEXCEPT;
 
     const_reference at(size_type __n) const;
     reference       at(size_type __n);
 
if (__n)
         __sz += __n;
         __set_size(__sz);
         traits_type::assign(__p[__sz], value_type());
     }
     return *this;
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 inline void
 basic_string<_CharT, _Traits, _Allocator>::__append_default_init(size_type __n)
 {
     if (__n)
     {
         size_type __cap = capacity();
         size_type __sz = size();
         if (__cap - __sz < __n)
             __grow_by(__cap, __sz + __n - __cap, __sz, __sz, 0);

libcxx/include/version

 __cpp_lib_source_location                               201907L <source_location>
 __cpp_lib_span                                          202002L <span>
 __cpp_lib_spanstream                                    202106L <spanstream>
 __cpp_lib_ssize                                         201902L <iterator>
 __cpp_lib_stacktrace                                    202011L <stacktrace>
 __cpp_lib_starts_ends_with                              201711L <string> <string_view>
 __cpp_lib_stdatomic_h                                   202011L <stdatomic.h>
 __cpp_lib_string_contains                               202011L <string> <string_view>
+__cpp_lib_string_resize_and_overwrite                   202110L <string>
 __cpp_lib_string_udls                                   201304L <string>
 __cpp_lib_string_view                                   201803L <string> <string_view>
                                                         201606L // C++17
 __cpp_lib_syncbuf                                       201803L <syncstream>
 __cpp_lib_three_way_comparison                          201907L <compare>
 __cpp_lib_to_address                                    201711L <memory>
 __cpp_lib_to_array                                      201907L <array>
 __cpp_lib_to_chars                                      201611L <charconv>

 // # define __cpp_lib_move_only_function                   202110L
 // # define __cpp_lib_out_ptr                              202106L
 // # define __cpp_lib_ranges_starts_ends_with              202106L
 // # define __cpp_lib_ranges_zip                           202110L
 // # define __cpp_lib_spanstream                           202106L
 // # define __cpp_lib_stacktrace                           202011L
 // # define __cpp_lib_stdatomic_h                          202011L
 # define __cpp_lib_string_contains                      202011L
+# define __cpp_lib_string_resize_and_overwrite          202110L
 # define __cpp_lib_to_underlying                        202102L
 #endif
 
 // clang-format on
 
 #endif // _LIBCPP_VERSIONH

libcxx/test/std/language.support/support.limits/support.limits.general/string.version.pass.cpp

 /*  Constant                                      Value
     __cpp_lib_allocator_traits_is_always_equal    201411L [C++17]
     __cpp_lib_char8_t                             201811L [C++20]
     __cpp_lib_constexpr_string                    201811L [C++20]
     __cpp_lib_erase_if                            202002L [C++20]
     __cpp_lib_nonmember_container_access          201411L [C++17]
     __cpp_lib_starts_ends_with                    201711L [C++20]
     __cpp_lib_string_contains                     202011L [C++2b]
+    __cpp_lib_string_resize_and_overwrite         202110L [C++2b]
     __cpp_lib_string_udls                         201304L [C++14]
     __cpp_lib_string_view                         201606L [C++17]
                                                   201803L [C++20]
 */
 
 #include <string>
 #include "test_macros.h"
 

 # ifdef __cpp_lib_starts_ends_with
 #   error "__cpp_lib_starts_ends_with should not be defined before c++20"
 # endif
 
 # ifdef __cpp_lib_string_contains
 #   error "__cpp_lib_string_contains should not be defined before c++2b"
 # endif
 
+# ifdef __cpp_lib_string_resize_and_overwrite
+#   error "__cpp_lib_string_resize_and_overwrite should not be defined before c++2b"
+# endif
+
 # ifdef __cpp_lib_string_udls
 #   error "__cpp_lib_string_udls should not be defined before c++14"
 # endif
 
 # ifdef __cpp_lib_string_view
 #   error "__cpp_lib_string_view should not be defined before c++17"
 # endif
 

 # ifdef __cpp_lib_starts_ends_with
 #   error "__cpp_lib_starts_ends_with should not be defined before c++20"
 # endif
 
 # ifdef __cpp_lib_string_contains
 #   error "__cpp_lib_string_contains should not be defined before c++2b"
 # endif
 
+# ifdef __cpp_lib_string_resize_and_overwrite
+#   error "__cpp_lib_string_resize_and_overwrite should not be defined before c++2b"
+# endif
+
 # ifndef __cpp_lib_string_udls
 #   error "__cpp_lib_string_udls should be defined in c++14"
 # endif
 # if __cpp_lib_string_udls != 201304L
 #   error "__cpp_lib_string_udls should have the value 201304L in c++14"
 # endif
 
 # ifdef __cpp_lib_string_view

 # ifdef __cpp_lib_starts_ends_with
 #   error "__cpp_lib_starts_ends_with should not be defined before c++20"
 # endif
 
 # ifdef __cpp_lib_string_contains
 #   error "__cpp_lib_string_contains should not be defined before c++2b"
 # endif
 
+# ifdef __cpp_lib_string_resize_and_overwrite
+#   error "__cpp_lib_string_resize_and_overwrite should not be defined before c++2b"
+# endif
+
 # ifndef __cpp_lib_string_udls
 #   error "__cpp_lib_string_udls should be defined in c++17"
 # endif
 # if __cpp_lib_string_udls != 201304L
 #   error "__cpp_lib_string_udls should have the value 201304L in c++17"
 # endif
 
 # ifndef __cpp_lib_string_view

 # if __cpp_lib_starts_ends_with != 201711L
 #   error "__cpp_lib_starts_ends_with should have the value 201711L in c++20"
 # endif
 
 # ifdef __cpp_lib_string_contains
 #   error "__cpp_lib_string_contains should not be defined before c++2b"
 # endif
 
+# ifdef __cpp_lib_string_resize_and_overwrite
+#   error "__cpp_lib_string_resize_and_overwrite should not be defined before c++2b"
+# endif
+
 # ifndef __cpp_lib_string_udls
 #   error "__cpp_lib_string_udls should be defined in c++20"
 # endif
 # if __cpp_lib_string_udls != 201304L
 #   error "__cpp_lib_string_udls should have the value 201304L in c++20"
 # endif
 
 # ifndef __cpp_lib_string_view

 
 # ifndef __cpp_lib_string_contains
 #   error "__cpp_lib_string_contains should be defined in c++2b"
 # endif
 # if __cpp_lib_string_contains != 202011L
 #   error "__cpp_lib_string_contains should have the value 202011L in c++2b"
 # endif
 
+# ifndef __cpp_lib_string_resize_and_overwrite
+#   error "__cpp_lib_string_resize_and_overwrite should be defined in c++2b"
+# endif
+# if __cpp_lib_string_resize_and_overwrite != 202110L
+#   error "__cpp_lib_string_resize_and_overwrite should have the value 202110L in c++2b"
+# endif
+
 # ifndef __cpp_lib_string_udls
 #   error "__cpp_lib_string_udls should be defined in c++2b"
 # endif
 # if __cpp_lib_string_udls != 201304L
 #   error "__cpp_lib_string_udls should have the value 201304L in c++2b"
 # endif
 
 # ifndef __cpp_lib_string_view

libcxx/test/std/language.support/support.limits/support.limits.general/version.version.pass.cpp

/*  Constant                                       Value
     __cpp_lib_source_location                      201907L [C++20]
     __cpp_lib_span                                 202002L [C++20]
     __cpp_lib_spanstream                           202106L [C++2b]
     __cpp_lib_ssize                                201902L [C++20]
     __cpp_lib_stacktrace                           202011L [C++2b]
     __cpp_lib_starts_ends_with                     201711L [C++20]
     __cpp_lib_stdatomic_h                          202011L [C++2b]
     __cpp_lib_string_contains                      202011L [C++2b]
+    __cpp_lib_string_resize_and_overwrite          202110L [C++2b]
     __cpp_lib_string_udls                          201304L [C++14]
     __cpp_lib_string_view                          201606L [C++17]
                                                    201803L [C++20]
     __cpp_lib_syncbuf                              201803L [C++20]
     __cpp_lib_three_way_comparison                 201907L [C++20]
     __cpp_lib_to_address                           201711L [C++20]
     __cpp_lib_to_array                             201907L [C++20]
     __cpp_lib_to_chars                             201611L [C++17]

 # ifdef __cpp_lib_stdatomic_h
 #   error "__cpp_lib_stdatomic_h should not be defined before c++2b"
 # endif
 
 # ifdef __cpp_lib_string_contains
 #   error "__cpp_lib_string_contains should not be defined before c++2b"
 # endif
 
+# ifdef __cpp_lib_string_resize_and_overwrite
+#   error "__cpp_lib_string_resize_and_overwrite should not be defined before c++2b"
+# endif
+
 # ifdef __cpp_lib_string_udls
 #   error "__cpp_lib_string_udls should not be defined before c++14"
 # endif
 
 # ifdef __cpp_lib_string_view
 #   error "__cpp_lib_string_view should not be defined before c++17"
 # endif
 

 # ifdef __cpp_lib_stdatomic_h
 #   error "__cpp_lib_stdatomic_h should not be defined before c++2b"
 # endif
 
 # ifdef __cpp_lib_string_contains
 #   error "__cpp_lib_string_contains should not be defined before c++2b"
 # endif
 
+# ifdef __cpp_lib_string_resize_and_overwrite
+#   error "__cpp_lib_string_resize_and_overwrite should not be defined before c++2b"
+# endif
+
 # ifndef __cpp_lib_string_udls
 #   error "__cpp_lib_string_udls should be defined in c++14"
 # endif
 # if __cpp_lib_string_udls != 201304L
 #   error "__cpp_lib_string_udls should have the value 201304L in c++14"
 # endif
 
 # ifdef __cpp_lib_string_view

 # ifdef __cpp_lib_stdatomic_h
 #   error "__cpp_lib_stdatomic_h should not be defined before c++2b"
 # endif
 
 # ifdef __cpp_lib_string_contains
 #   error "__cpp_lib_string_contains should not be defined before c++2b"
 # endif
 
+# ifdef __cpp_lib_string_resize_and_overwrite
+#   error "__cpp_lib_string_resize_and_overwrite should not be defined before c++2b"
+# endif
+
 # ifndef __cpp_lib_string_udls
 #   error "__cpp_lib_string_udls should be defined in c++17"
 # endif
 # if __cpp_lib_string_udls != 201304L
 #   error "__cpp_lib_string_udls should have the value 201304L in c++17"
 # endif
 
 # ifndef __cpp_lib_string_view

 # ifdef __cpp_lib_stdatomic_h
 #   error "__cpp_lib_stdatomic_h should not be defined before c++2b"
 # endif
 
 # ifdef __cpp_lib_string_contains
 #   error "__cpp_lib_string_contains should not be defined before c++2b"
 # endif
 
+# ifdef __cpp_lib_string_resize_and_overwrite
+#   error "__cpp_lib_string_resize_and_overwrite should not be defined before c++2b"
+# endif
+
 # ifndef __cpp_lib_string_udls
 #   error "__cpp_lib_string_udls should be defined in c++20"
 # endif
 # if __cpp_lib_string_udls != 201304L
 #   error "__cpp_lib_string_udls should have the value 201304L in c++20"
 # endif
 
 # ifndef __cpp_lib_string_view

 
 # ifndef __cpp_lib_string_contains
 #   error "__cpp_lib_string_contains should be defined in c++2b"
 # endif
 # if __cpp_lib_string_contains != 202011L
 #   error "__cpp_lib_string_contains should have the value 202011L in c++2b"
 # endif
 
+# ifndef __cpp_lib_string_resize_and_overwrite
+#   error "__cpp_lib_string_resize_and_overwrite should be defined in c++2b"
+# endif
+# if __cpp_lib_string_resize_and_overwrite != 202110L
+#   error "__cpp_lib_string_resize_and_overwrite should have the value 202110L in c++2b"
+# endif
+
 # ifndef __cpp_lib_string_udls
 #   error "__cpp_lib_string_udls should be defined in c++2b"
 # endif
 # if __cpp_lib_string_udls != 201304L
 #   error "__cpp_lib_string_udls should have the value 201304L in c++2b"
 # endif
 
 # ifndef __cpp_lib_string_view

libcxx/test/std/strings/basic.string/string.capacity/resize_and_overwrite.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
+
+// <string>
+
+// template<class Operation>
+// void resize_and_overwrite(size_type n, Operation op)
+
+#include <cassert>
+#include <string>
+
+#include "make_string.h"
+#include "test_macros.h"
+
+template <class S>
+constexpr void test_appending(size_t k, size_t N, size_t new_capacity) {
+  assert(N > k);
+  assert(new_capacity >= N);
+  auto s = S(k, 'a');
+  s.resize_and_overwrite(new_capacity, [&](auto* p, auto n) {
+    assert(n == new_capacity);
+    LIBCPP_ASSERT(s.size() == new_capacity);
+    LIBCPP_ASSERT(s.begin().base() == p);
+    assert(std::all_of(p, p + k, [](const auto ch) { return ch == 'a'; }));
+    std::fill(p + k, p + n, 'b');
+    p[n] = 'c'; // will be overwritten
+    return N;
+  });
+  const S expected = S(k, 'a') + S(N - k, 'b');
+  assert(s == expected);
+  assert(s.c_str()[N] == '\0');
+}
+
+template <class S>
+constexpr void test_truncating(size_t o, size_t N) {
+  assert(N < o);
+  auto s = S(o, 'a');
+  s.resize_and_overwrite(N, [&](auto* p, auto n) {
+    assert(n == N);
+    LIBCPP_ASSERT(s.size() == n);
+    LIBCPP_ASSERT(s.begin().base() == p);
+    assert(std::all_of(p, p + n, [](auto ch) { return ch == 'a'; }));
+    p[n - 1] = 'b';
+    p[n] = 'c'; // will be overwritten
+    return n;
+  });
+  const S expected = S(N - 1, 'a') + S(1, 'b');
+  assert(s == expected);
+  assert(s.c_str()[N] == '\0');
+}
+
+template <class CharT>
+constexpr bool test() {
+  using S = std::basic_string<CharT>;
+  test_appending<S>(10, 15, 15);
+  test_appending<S>(10, 15, 20);
+  test_appending<S>(10, 40, 40);
+  test_appending<S>(10, 40, 50);
+  test_appending<S>(30, 35, 35);
+  test_appending<S>(30, 35, 45);
+  test_appending<S>(10, 15, 30);
+  test_truncating<S>(15, 10);
+  test_truncating<S>(40, 35);
+  test_truncating<S>(40, 10);
+
+  return true;
+}
+
+void test_value_categories() {
+  std::string s;
+  s.resize_and_overwrite(10, [](char*&, size_t&) { return 0; });
+  struct RefQualified {
+    int operator()(char*, size_t) && { return 0; }
+  };
+  s.resize_and_overwrite(10, RefQualified{});
+}
+
+int main(int, char**) {
+  test<char>();
+  test<char8_t>();
+  test<char16_t>();
+  test<char32_t>();
+
+#if defined(__cpp_lib_constexpr_string) && __cpp_lib_constexpr_string >= 201907L
+  static_assert(test<char>());
+  static_assert(test<char8_t>());
+  static_assert(test<char16_t>());
+  static_assert(test<char32_t>());
+#endif
+
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  test<wchar_t>();
+#if defined(__cpp_lib_constexpr_string) && __cpp_lib_constexpr_string >= 201907L
+  static_assert(test<wchar_t>());
+#endif
+#endif
+  return 0;
+}

libcxx/utils/generate_feature_test_macro_components.py

feature_test_macros = [ add_version_header(x) for x in [
     "values": { "c++2b": 202011 },
     "headers": ["stdatomic.h"],
     "unimplemented": True,
   }, {
     "name": "__cpp_lib_string_contains",
     "values": { "c++2b": 202011 },
     "headers": ["string", "string_view"],
   }, {
+    "name": "__cpp_lib_string_resize_and_overwrite",
+    "values": { "c++2b": 202110 },
+    "headers": ["string"],
+  }, {
     "name": "__cpp_lib_string_udls",
     "values": { "c++14": 201304 },
     "headers": ["string"],
   }, {
     "name": "__cpp_lib_string_view",
     "values": { "c++17": 201606, "c++20": 201803 },
     "headers": ["string", "string_view"],
   }, {