Remove unique temporary adoption optimizations

PyUnstable_Object_IsUniqueReferencedTemporary() can't tell when a C
caller still holds a borrowed reference to the argument (for example
bisect.insort(lst, bytearray(b'abc')[1:], key=bytes)), so adopting the
buffer empties an object still in use. Leave the optimization for a
follow-up and keep this PR to the vectorcall change.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: cmaloney

Lib/test/test_bytes.py

@@ -16,7 +16,6 @@
 import sys
 import tempfile
 import textwrap
-lazy import tracemalloc
 import threading
 import unittest
 from _codecs import _unregister_error as _codecs_unregister_error
@@ -1810,23 +1809,6 @@ def hashing_codec(name):
         self.assertEqual(taken, b'Hello')
         self.assertEqual(hash(taken), hash(b'Hello'))
 
-    @support.cpython_only
-    @support.bigmemtest(size=support._1G, memuse=1)
-    def test_unique_temporary_take_memory(self, size):
-        # Optimization: When passed a unique temporary adopt it rather than
-        # allocate + copy + deallocate.
-        def peak(func):
-            tracemalloc.start()
-            try:
-                func()
-                return tracemalloc.get_traced_memory()[1]
-            finally:
-                tracemalloc.stop()
-        # Copy would be 2.0, 1.5 gives space for other allocations.
-        self.assertLess(peak(lambda: bytearray(bytes(size))), size * 1.5)
-        self.assertLess(peak(lambda: bytearray(bytearray(size))), size * 1.5)
-        self.assertLess(peak(lambda: bytes(bytearray(size))), size * 1.5)
-
     def test_take_bytes_reentrant_resize(self):
         # gh-153570: n.__index__() can resize the bytearray, so take_bytes()
         # must re-read the size afterwards.  It cached the size before the

Objects/bytearrayobject.c

@@ -1083,33 +1083,6 @@ bytearray___init___impl(PyByteArrayObject *self, PyObject *arg,
         }
     }
 
-    /* optimization: Adopt bytes rather than copying. */
-    if (PyBytes_CheckExact(arg)
-        && PyUnstable_Object_IsUniqueReferencedTemporary(arg)
-        && _PyBytes_GET_CACHED_HASH((PyBytesObject *)arg) == -1)
-    {
-        /* Reinit before taking a reference: it asserts the bytes is
-           uniquely referenced. */
-        self->ob_bytes_object = arg;
-        bytearray_reinit_from_bytes(self, PyBytes_GET_SIZE(arg));
-        Py_INCREF(arg);
-        return 0;
-    }
-
-    /* optimization: Adopt bytearray rather than copying. */
-    if (PyByteArray_CheckExact(arg)
-        && PyUnstable_Object_IsUniqueReferencedTemporary(arg))
-    {
-        PyObject *bytes = bytearray_take_bytes_impl((PyByteArrayObject *)arg,
-                                                    Py_None);
-        if (bytes == NULL) {
-            return -1;
-        }
-        self->ob_bytes_object = bytes;
-        bytearray_reinit_from_bytes(self, PyBytes_GET_SIZE(bytes));
-        return 0;
-    }
-
     /* Use the buffer API */
     if (PyObject_CheckBuffer(arg)) {
         Py_ssize_t size;

Objects/bytesobject.c

@@ -3003,11 +3003,6 @@ bytes_new_impl(PyTypeObject *type, PyObject *x, const char *encoding,
             bytes = _PyBytes_FromSizeZero(size);
         }
     }
-    /* Adopt unique temporary bytearray rather than copying. */
-    else if (PyByteArray_CheckExact(x)
-             && PyUnstable_Object_IsUniqueReferencedTemporary(x)) {
-        bytes = PyObject_CallMethodNoArgs(x, &_Py_ID(take_bytes));
-    }
     else {
         bytes = PyBytes_FromObject(x);
     }