Also, check for uses of StringMemory for example:

The name makes me think that take_string!(iobuffer) should be a replacement/synonym for String(take!(iobuffer))?

I would be in favor of that. Every time I have used an IOBuffer I have had to go to the docs to figure out how to get the data out of it correctly.

So what's the specification of String(_): does it truncate or not? Or does it depend on the specific argument type? An "it depends" is not a very nice property for generic programming.

It does not truncate - except when the argument is a Vector{UInt8}. Yes, that's bad and in my opinion it shouldn't have been like that. But it's documented, and therefore can't change. I made this PR to make sure more exceptions aren't added.

Do we need an underscore here? takestring! is pretty readable

Triage had a long talk about this, #54369, #54156 and #54273. The conclusions we came to are

1. String(Memory) should copy
2. String(Array) should truncate the array but not the Memory
3. triage was right last time wrt view and reshape of Memory
4. using the an Array aliased with another Array that is turned into a String is UB.
5. take_string! is a much better API for IOBuffer et al.

The style guide says not to use underscores "when readable" without, which I think applies here.

4. using the an Array aliased with another Array that is turned into a String is UB.

Can this be refined to "mutating an Array after its alias has been turned into a String is UB"?

edit: For the record , I don't think it's right for us to put this contract on an API that's not marked unsafe. I expect that this 'contract' is broken much more often than the UB is actually triggered though, which is probably what's saving us in practice.

Yes. observing it is not great but not UB. the only UB is if you mutate it.

takestring! can mutate the bytes in the underlying memory of a Vector input, it is not just making a String view.

After triage, this PR now contains the following changes:

• Add takestring!. This function can be used with IOBuffer and Vector{UInt8}, returning a String. It resets the input to its initial state. This means it empties vectors, and empties IOBuffer if and only if the buffer is writable. This behaviour of not empying the input if the input is not writable is slightly weird, but matches take!
• Add the internal methods Base.unsafe_takestring! and Base.unsafe_takestring, which are similar to takestring!, except they leave the argument (IOBuffer or Memory) in an unusable corrupt state. They are useful for the common pattern when code creates a buffer, takes a string from the buffer and then returns the string without touching the buffer again.
• String(::Memory) now no longer truncates the memory
• String(::Vector{UInt8}) now no longer truncates the underlying memory of the string. It still empties the vector, and assigns a new (empty) memory to the vector just like before.
• The many different calls to String(take!(::IOBuffer)) and String(_unsafe_take!(::IOBuffer)) has been replaced with takestring! and the two internal methods Base.unsafe_takestring! and Base.unsafe_takestring). Not all calls to String(take!(...)) has been replaced, as there are many, many of such calls in the test suite and no need to change them.
• Replace most uses of String(take!(::IOBuffer)) in Base and the stdlibs
• Add tests

Rebased. Test failures look unrelated, but it's suspicious that they now failed twice on Windows.