gh-99300: Use Py_NewRef() in Objects/ directory (#99332)

vstinner · web-flow · commit c0feb99187f4 · 2022-11-10T16:27:32.000+01:00
Replace Py_INCREF() and Py_XINCREF() with Py_NewRef() and
Py_XNewRef() in C files of the Objects/ directory.
diff --git a/Objects/abstract.c b/Objects/abstract.c
@@ -45,8 +45,7 @@ PyObject_Type(PyObject *o)
     }
 
     v = (PyObject *)Py_TYPE(o);
-    Py_INCREF(v);
-    return v;
+    return Py_NewRef(v);
 }
 
 Py_ssize_t
@@ -722,9 +721,7 @@ PyBuffer_FillInfo(Py_buffer *view, PyObject *obj, void *buf, Py_ssize_t len,
         return -1;
     }
 
-    view->obj = obj;
-    if (obj)
-        Py_INCREF(obj);
+    view->obj = Py_XNewRef(obj);
     view->buf = buf;
     view->len = len;
     view->readonly = readonly;
@@ -776,8 +773,7 @@ PyObject_Format(PyObject *obj, PyObject *format_spec)
     /* Fast path for common types. */
     if (format_spec == NULL || PyUnicode_GET_LENGTH(format_spec) == 0) {
         if (PyUnicode_CheckExact(obj)) {
-            Py_INCREF(obj);
-            return obj;
+            return Py_NewRef(obj);
         }
         if (PyLong_CheckExact(obj)) {
             return PyObject_Str(obj);
@@ -1405,8 +1401,7 @@ _PyNumber_Index(PyObject *item)
     }
 
     if (PyLong_Check(item)) {
-        Py_INCREF(item);
-        return item;
+        return Py_NewRef(item);
     }
     if (!_PyIndex_Check(item)) {
         PyErr_Format(PyExc_TypeError,
@@ -1520,8 +1515,7 @@ PyNumber_Long(PyObject *o)
     }
 
     if (PyLong_CheckExact(o)) {
-        Py_INCREF(o);
-        return o;
+        return Py_NewRef(o);
     }
     m = Py_TYPE(o)->tp_as_number;
     if (m && m->nb_int) { /* This should include subclasses of int */
@@ -2045,8 +2039,7 @@ PySequence_Tuple(PyObject *v)
            a tuple *subclass* instance as-is, hence the restriction
            to exact tuples here.  In contrast, lists always make
            a copy, so there's no need for exactness below. */
-        Py_INCREF(v);
-        return v;
+        return Py_NewRef(v);
     }
     if (PyList_CheckExact(v))
         return PyList_AsTuple(v);
@@ -2144,8 +2137,7 @@ PySequence_Fast(PyObject *v, const char *m)
     }
 
     if (PyList_CheckExact(v) || PyTuple_CheckExact(v)) {
-        Py_INCREF(v);
-        return v;
+        return Py_NewRef(v);
     }
 
     it = PyObject_GetIter(v);
diff --git a/Objects/boolobject.c b/Objects/boolobject.c
@@ -23,8 +23,7 @@ PyObject *PyBool_FromLong(long ok)
         result = Py_True;
     else
         result = Py_False;
-    Py_INCREF(result);
-    return result;
+    return Py_NewRef(result);
 }
 
 /* We define bool_new to always return either Py_True or Py_False */
diff --git a/Objects/bytesobject.c b/Objects/bytesobject.c
@@ -53,8 +53,7 @@ static inline PyObject* bytes_get_empty(void)
 // Return a strong reference to the empty bytes string singleton.
 static inline PyObject* bytes_new_empty(void)
 {
-    Py_INCREF(EMPTY);
-    return (PyObject *)EMPTY;
+    return Py_NewRef(EMPTY);
 }
 
 
@@ -126,8 +125,7 @@ PyBytes_FromStringAndSize(const char *str, Py_ssize_t size)
     }
     if (size == 1 && str != NULL) {
         op = CHARACTER(*str & 255);
-        Py_INCREF(op);
-        return (PyObject *)op;
+        return Py_NewRef(op);
     }
     if (size == 0) {
         return bytes_new_empty();
@@ -162,8 +160,7 @@ PyBytes_FromString(const char *str)
     }
     else if (size == 1) {
         op = CHARACTER(*str & 255);
-        Py_INCREF(op);
-        return (PyObject *)op;
+        return Py_NewRef(op);
     }
 
     /* Inline PyObject_NewVar */
@@ -527,14 +524,12 @@ format_obj(PyObject *v, const char **pbuf, Py_ssize_t *plen)
     if (PyBytes_Check(v)) {
         *pbuf = PyBytes_AS_STRING(v);
         *plen = PyBytes_GET_SIZE(v);
-        Py_INCREF(v);
-        return v;
+        return Py_NewRef(v);
     }
     if (PyByteArray_Check(v)) {
         *pbuf = PyByteArray_AS_STRING(v);
         *plen = PyByteArray_GET_SIZE(v);
-        Py_INCREF(v);
-        return v;
+        return Py_NewRef(v);
     }
     /* does it support __bytes__? */
     func = _PyObject_LookupSpecial(v, &_Py_ID(__bytes__));
@@ -1411,13 +1406,11 @@ bytes_concat(PyObject *a, PyObject *b)
 
     /* Optimize end cases */
     if (va.len == 0 && PyBytes_CheckExact(b)) {
-        result = b;
-        Py_INCREF(result);
+        result = Py_NewRef(b);
         goto done;
     }
     if (vb.len == 0 && PyBytes_CheckExact(a)) {
-        result = a;
-        Py_INCREF(result);
+        result = Py_NewRef(a);
         goto done;
     }
 
@@ -1458,8 +1451,7 @@ bytes_repeat(PyBytesObject *a, Py_ssize_t n)
     }
     size = Py_SIZE(a) * n;
     if (size == Py_SIZE(a) && PyBytes_CheckExact(a)) {
-        Py_INCREF(a);
-        return (PyObject *)a;
+        return Py_NewRef(a);
     }
     nbytes = (size_t)size;
     if (nbytes + PyBytesObject_SIZE <= nbytes) {
@@ -1625,8 +1617,7 @@ bytes_subscript(PyBytesObject* self, PyObject* item)
         else if (start == 0 && step == 1 &&
                  slicelength == PyBytes_GET_SIZE(self) &&
                  PyBytes_CheckExact(self)) {
-            Py_INCREF(self);
-            return (PyObject *)self;
+            return Py_NewRef(self);
         }
         else if (step == 1) {
             return PyBytes_FromStringAndSize(
@@ -1696,8 +1687,7 @@ bytes___bytes___impl(PyBytesObject *self)
 /*[clinic end generated code: output=63a306a9bc0caac5 input=34ec5ddba98bd6bb]*/
 {
     if (PyBytes_CheckExact(self)) {
-        Py_INCREF(self);
-        return (PyObject *)self;
+        return Py_NewRef(self);
     }
     else {
         return PyBytes_FromStringAndSize(self->ob_sval, Py_SIZE(self));
@@ -1922,8 +1912,7 @@ do_xstrip(PyBytesObject *self, int striptype, PyObject *sepobj)
     PyBuffer_Release(&vsep);
 
     if (i == 0 && j == len && PyBytes_CheckExact(self)) {
-        Py_INCREF(self);
-        return (PyObject*)self;
+        return Py_NewRef(self);
     }
     else
         return PyBytes_FromStringAndSize(s+i, j-i);
@@ -1952,8 +1941,7 @@ do_strip(PyBytesObject *self, int striptype)
     }
 
     if (i == 0 && j == len && PyBytes_CheckExact(self)) {
-        Py_INCREF(self);
-        return (PyObject*)self;
+        return Py_NewRef(self);
     }
     else
         return PyBytes_FromStringAndSize(s+i, j-i);
@@ -2152,8 +2140,7 @@ bytes_translate_impl(PyBytesObject *self, PyObject *table,
     }
     if (!changed && PyBytes_CheckExact(input_obj)) {
         Py_DECREF(result);
-        Py_INCREF(input_obj);
-        return input_obj;
+        return Py_NewRef(input_obj);
     }
     /* Fix the size of the resulting byte string */
     if (inlen > 0)
@@ -2245,8 +2232,7 @@ bytes_removeprefix_impl(PyBytesObject *self, Py_buffer *prefix)
     }
 
     if (PyBytes_CheckExact(self)) {
-        Py_INCREF(self);
-        return (PyObject *)self;
+        return Py_NewRef(self);
     }
 
     return PyBytes_FromStringAndSize(self_start, self_len);
@@ -2284,8 +2270,7 @@ bytes_removesuffix_impl(PyBytesObject *self, Py_buffer *suffix)
     }
 
     if (PyBytes_CheckExact(self)) {
-        Py_INCREF(self);
-        return (PyObject *)self;
+        return Py_NewRef(self);
     }
 
     return PyBytes_FromStringAndSize(self_start, self_len);
@@ -2844,8 +2829,7 @@ PyBytes_FromObject(PyObject *x)
     }
 
     if (PyBytes_CheckExact(x)) {
-        Py_INCREF(x);
-        return x;
+        return Py_NewRef(x);
     }
 
     /* Use the modern buffer interface */
@@ -3269,8 +3253,7 @@ bytes_iter(PyObject *seq)
     if (it == NULL)
         return NULL;
     it->it_index = 0;
-    Py_INCREF(seq);
-    it->it_seq = (PyBytesObject *)seq;
+    it->it_seq = (PyBytesObject *)Py_NewRef(seq);
     _PyObject_GC_TRACK(it);
     return (PyObject *)it;
 }
diff --git a/Objects/call.c b/Objects/call.c
@@ -1000,8 +1000,7 @@ _PyStack_UnpackDict(PyThreadState *tstate,
 
     /* Copy positional arguments */
     for (Py_ssize_t i = 0; i < nargs; i++) {
-        Py_INCREF(args[i]);
-        stack[i] = args[i];
+        stack[i] = Py_NewRef(args[i]);
     }
 
     PyObject **kwstack = stack + nargs;
@@ -1013,10 +1012,8 @@ _PyStack_UnpackDict(PyThreadState *tstate,
     unsigned long keys_are_strings = Py_TPFLAGS_UNICODE_SUBCLASS;
     while (PyDict_Next(kwargs, &pos, &key, &value)) {
         keys_are_strings &= Py_TYPE(key)->tp_flags;
-        Py_INCREF(key);
-        Py_INCREF(value);
-        PyTuple_SET_ITEM(kwnames, i, key);
-        kwstack[i] = value;
+        PyTuple_SET_ITEM(kwnames, i, Py_NewRef(key));
+        kwstack[i] = Py_NewRef(value);
         i++;
     }
 
diff --git a/Objects/cellobject.c b/Objects/cellobject.c
@@ -11,8 +11,7 @@ PyCell_New(PyObject *obj)
     op = (PyCellObject *)PyObject_GC_New(PyCellObject, &PyCell_Type);
     if (op == NULL)
         return NULL;
-    op->ob_ref = obj;
-    Py_XINCREF(obj);
+    op->ob_ref = Py_XNewRef(obj);
 
     _PyObject_GC_TRACK(op);
     return (PyObject *)op;
@@ -68,8 +67,7 @@ PyCell_Set(PyObject *op, PyObject *value)
         return -1;
     }
     PyObject *old_value = PyCell_GET(op);
-    Py_XINCREF(value);
-    PyCell_SET(op, value);
+    PyCell_SET(op, Py_XNewRef(value));
     Py_XDECREF(old_value);
     return 0;
 }
@@ -135,15 +133,13 @@ cell_get_contents(PyCellObject *op, void *closure)
         PyErr_SetString(PyExc_ValueError, "Cell is empty");
         return NULL;
     }
-    Py_INCREF(op->ob_ref);
-    return op->ob_ref;
+    return Py_NewRef(op->ob_ref);
 }
 
 static int
 cell_set_contents(PyCellObject *op, PyObject *obj, void *Py_UNUSED(ignored))
 {
-    Py_XINCREF(obj);
-    Py_XSETREF(op->ob_ref, obj);
+    Py_XSETREF(op->ob_ref, Py_XNewRef(obj));
     return 0;
 }
 
diff --git a/Objects/classobject.c b/Objects/classobject.c
@@ -113,10 +113,8 @@ PyMethod_New(PyObject *func, PyObject *self)
         return NULL;
     }
     im->im_weakreflist = NULL;
-    Py_INCREF(func);
-    im->im_func = func;
-    Py_INCREF(self);
-    im->im_self = self;
+    im->im_func = Py_NewRef(func);
+    im->im_self = Py_NewRef(self);
     im->vectorcall = method_vectorcall;
     _PyObject_GC_TRACK(im);
     return (PyObject *)im;
@@ -195,8 +193,7 @@ method_getattro(PyObject *obj, PyObject *name)
         if (f != NULL)
             return f(descr, obj, (PyObject *)Py_TYPE(obj));
         else {
-            Py_INCREF(descr);
-            return descr;
+            return Py_NewRef(descr);
         }
     }
 
@@ -267,8 +264,7 @@ method_richcompare(PyObject *self, PyObject *other, int op)
         res = eq ? Py_True : Py_False;
     else
         res = eq ? Py_False : Py_True;
-    Py_INCREF(res);
-    return res;
+    return Py_NewRef(res);
 }
 
 static PyObject *
@@ -359,8 +355,7 @@ PyInstanceMethod_New(PyObject *func) {
     method = PyObject_GC_New(PyInstanceMethodObject,
                              &PyInstanceMethod_Type);
     if (method == NULL) return NULL;
-    Py_INCREF(func);
-    method->func = func;
+    method->func = Py_NewRef(func);
     _PyObject_GC_TRACK(method);
     return (PyObject *)method;
 }
@@ -412,8 +407,7 @@ instancemethod_getattro(PyObject *self, PyObject *name)
         if (f != NULL)
             return f(descr, self, (PyObject *)Py_TYPE(self));
         else {
-            Py_INCREF(descr);
-            return descr;
+            return Py_NewRef(descr);
         }
     }
 
@@ -443,8 +437,7 @@ static PyObject *
 instancemethod_descr_get(PyObject *descr, PyObject *obj, PyObject *type) {
     PyObject *func = PyInstanceMethod_GET_FUNCTION(descr);
     if (obj == NULL) {
-        Py_INCREF(func);
-        return func;
+        return Py_NewRef(func);
     }
     else
         return PyMethod_New(func, obj);
@@ -472,8 +465,7 @@ instancemethod_richcompare(PyObject *self, PyObject *other, int op)
         res = eq ? Py_True : Py_False;
     else
         res = eq ? Py_False : Py_True;
-    Py_INCREF(res);
-    return res;
+    return Py_NewRef(res);
 }
 
 static PyObject *
diff --git a/Objects/codeobject.c b/Objects/codeobject.c
diff --git a/Objects/complexobject.c b/Objects/complexobject.c
diff --git a/Objects/descrobject.c b/Objects/descrobject.c

Original file line number	Diff line number	Diff line change
`@@ -45,8 +45,7 @@ PyObject_Type(PyObject *o)`
`45`	`45`	`}`
`46`	`46`
`47`	`47`	`v = (PyObject *)Py_TYPE(o);`
`48`		`- Py_INCREF(v);`
`49`		`- return v;`
	`48`	`+ return Py_NewRef(v);`
`50`	`49`	`}`
`51`	`50`
`52`	`51`	`Py_ssize_t`
`@@ -722,9 +721,7 @@ PyBuffer_FillInfo(Py_buffer view, PyObject obj, void *buf, Py_ssize_t len,`
`722`	`721`	`return -1;`
`723`	`722`	`}`
`724`	`723`
`725`		`- view->obj = obj;`
`726`		`- if (obj)`
`727`		`- Py_INCREF(obj);`
	`724`	`+ view->obj = Py_XNewRef(obj);`
`728`	`725`	`view->buf = buf;`
`729`	`726`	`view->len = len;`
`730`	`727`	`view->readonly = readonly;`
`@@ -776,8 +773,7 @@ PyObject_Format(PyObject obj, PyObject format_spec)`
`776`	`773`	`/* Fast path for common types. */`
`777`	`774`	`if (format_spec == NULL \|\| PyUnicode_GET_LENGTH(format_spec) == 0) {`
`778`	`775`	`if (PyUnicode_CheckExact(obj)) {`
`779`		`- Py_INCREF(obj);`
`780`		`- return obj;`
	`776`	`+ return Py_NewRef(obj);`
`781`	`777`	`}`
`782`	`778`	`if (PyLong_CheckExact(obj)) {`
`783`	`779`	`return PyObject_Str(obj);`
`@@ -1405,8 +1401,7 @@ _PyNumber_Index(PyObject *item)`
`1405`	`1401`	`}`
`1406`	`1402`
`1407`	`1403`	`if (PyLong_Check(item)) {`
`1408`		`- Py_INCREF(item);`
`1409`		`- return item;`
	`1404`	`+ return Py_NewRef(item);`
`1410`	`1405`	`}`
`1411`	`1406`	`if (!_PyIndex_Check(item)) {`
`1412`	`1407`	`PyErr_Format(PyExc_TypeError,`
`@@ -1520,8 +1515,7 @@ PyNumber_Long(PyObject *o)`
`1520`	`1515`	`}`
`1521`	`1516`
`1522`	`1517`	`if (PyLong_CheckExact(o)) {`
`1523`		`- Py_INCREF(o);`
`1524`		`- return o;`
	`1518`	`+ return Py_NewRef(o);`
`1525`	`1519`	`}`
`1526`	`1520`	`m = Py_TYPE(o)->tp_as_number;`
`1527`	`1521`	`if (m && m->nb_int) { /* This should include subclasses of int */`
`@@ -2045,8 +2039,7 @@ PySequence_Tuple(PyObject *v)`
`2045`	`2039`	`a tuple subclass instance as-is, hence the restriction`
`2046`	`2040`	`to exact tuples here. In contrast, lists always make`
`2047`	`2041`	`a copy, so there's no need for exactness below. */`
`2048`		`- Py_INCREF(v);`
`2049`		`- return v;`
	`2042`	`+ return Py_NewRef(v);`
`2050`	`2043`	`}`
`2051`	`2044`	`if (PyList_CheckExact(v))`
`2052`	`2045`	`return PyList_AsTuple(v);`
`@@ -2144,8 +2137,7 @@ PySequence_Fast(PyObject v, const char m)`
`2144`	`2137`	`}`
`2145`	`2138`
`2146`	`2139`	`if (PyList_CheckExact(v) \|\| PyTuple_CheckExact(v)) {`
`2147`		`- Py_INCREF(v);`
`2148`		`- return v;`
	`2140`	`+ return Py_NewRef(v);`
`2149`	`2141`	`}`
`2150`	`2142`
`2151`	`2143`	`it = PyObject_GetIter(v);`
Original file line number	Diff line number	Diff line change
`@@ -23,8 +23,7 @@ PyObject *PyBool_FromLong(long ok)`
`23`	`23`	`result = Py_True;`
`24`	`24`	`else`
`25`	`25`	`result = Py_False;`
`26`		`- Py_INCREF(result);`
`27`		`- return result;`
	`26`	`+ return Py_NewRef(result);`
`28`	`27`	`}`
`29`	`28`
`30`	`29`	`/* We define bool_new to always return either Py_True or Py_False */`
Original file line number	Diff line number	Diff line change
`@@ -53,8 +53,7 @@ static inline PyObject* bytes_get_empty(void)`
`53`	`53`	`// Return a strong reference to the empty bytes string singleton.`
`54`	`54`	`static inline PyObject* bytes_new_empty(void)`
`55`	`55`	`{`
`56`		`- Py_INCREF(EMPTY);`
`57`		`- return (PyObject *)EMPTY;`
	`56`	`+ return Py_NewRef(EMPTY);`
`58`	`57`	`}`
`59`	`58`
`60`	`59`
`@@ -126,8 +125,7 @@ PyBytes_FromStringAndSize(const char *str, Py_ssize_t size)`
`126`	`125`	`}`
`127`	`126`	`if (size == 1 && str != NULL) {`
`128`	`127`	`op = CHARACTER(*str & 255);`
`129`		`- Py_INCREF(op);`
`130`		`- return (PyObject *)op;`
	`128`	`+ return Py_NewRef(op);`
`131`	`129`	`}`
`132`	`130`	`if (size == 0) {`
`133`	`131`	`return bytes_new_empty();`
`@@ -162,8 +160,7 @@ PyBytes_FromString(const char *str)`
`162`	`160`	`}`
`163`	`161`	`else if (size == 1) {`
`164`	`162`	`op = CHARACTER(*str & 255);`
`165`		`- Py_INCREF(op);`
`166`		`- return (PyObject *)op;`
	`163`	`+ return Py_NewRef(op);`
`167`	`164`	`}`
`168`	`165`
`169`	`166`	`/* Inline PyObject_NewVar */`
`@@ -527,14 +524,12 @@ format_obj(PyObject v, const char pbuf, Py_ssize_t plen)`
`527`	`524`	`if (PyBytes_Check(v)) {`
`528`	`525`	`*pbuf = PyBytes_AS_STRING(v);`
`529`	`526`	`*plen = PyBytes_GET_SIZE(v);`
`530`		`- Py_INCREF(v);`
`531`		`- return v;`
	`527`	`+ return Py_NewRef(v);`
`532`	`528`	`}`
`533`	`529`	`if (PyByteArray_Check(v)) {`
`534`	`530`	`*pbuf = PyByteArray_AS_STRING(v);`
`535`	`531`	`*plen = PyByteArray_GET_SIZE(v);`
`536`		`- Py_INCREF(v);`
`537`		`- return v;`
	`532`	`+ return Py_NewRef(v);`
`538`	`533`	`}`
`539`	`534`	`/* does it support __bytes__? */`
`540`	`535`	`func = _PyObject_LookupSpecial(v, &_Py_ID(__bytes__));`
`@@ -1411,13 +1406,11 @@ bytes_concat(PyObject a, PyObject b)`
`1411`	`1406`
`1412`	`1407`	`/* Optimize end cases */`
`1413`	`1408`	`if (va.len == 0 && PyBytes_CheckExact(b)) {`
`1414`		`- result = b;`
`1415`		`- Py_INCREF(result);`
	`1409`	`+ result = Py_NewRef(b);`
`1416`	`1410`	`goto done;`
`1417`	`1411`	`}`
`1418`	`1412`	`if (vb.len == 0 && PyBytes_CheckExact(a)) {`
`1419`		`- result = a;`
`1420`		`- Py_INCREF(result);`
	`1413`	`+ result = Py_NewRef(a);`
`1421`	`1414`	`goto done;`
`1422`	`1415`	`}`
`1423`	`1416`
`@@ -1458,8 +1451,7 @@ bytes_repeat(PyBytesObject *a, Py_ssize_t n)`
`1458`	`1451`	`}`
`1459`	`1452`	`size = Py_SIZE(a) * n;`
`1460`	`1453`	`if (size == Py_SIZE(a) && PyBytes_CheckExact(a)) {`
`1461`		`- Py_INCREF(a);`
`1462`		`- return (PyObject *)a;`
	`1454`	`+ return Py_NewRef(a);`
`1463`	`1455`	`}`
`1464`	`1456`	`nbytes = (size_t)size;`
`1465`	`1457`	`if (nbytes + PyBytesObject_SIZE <= nbytes) {`
`@@ -1625,8 +1617,7 @@ bytes_subscript(PyBytesObject* self, PyObject* item)`
`1625`	`1617`	`else if (start == 0 && step == 1 &&`
`1626`	`1618`	`slicelength == PyBytes_GET_SIZE(self) &&`
`1627`	`1619`	`PyBytes_CheckExact(self)) {`
`1628`		`- Py_INCREF(self);`
`1629`		`- return (PyObject *)self;`
	`1620`	`+ return Py_NewRef(self);`
`1630`	`1621`	`}`
`1631`	`1622`	`else if (step == 1) {`
`1632`	`1623`	`return PyBytes_FromStringAndSize(`
`@@ -1696,8 +1687,7 @@ bytes___bytes___impl(PyBytesObject *self)`
`1696`	`1687`	`/[clinic end generated code: output=63a306a9bc0caac5 input=34ec5ddba98bd6bb]/`
`1697`	`1688`	`{`
`1698`	`1689`	`if (PyBytes_CheckExact(self)) {`
`1699`		`- Py_INCREF(self);`
`1700`		`- return (PyObject *)self;`
	`1690`	`+ return Py_NewRef(self);`
`1701`	`1691`	`}`
`1702`	`1692`	`else {`
`1703`	`1693`	`return PyBytes_FromStringAndSize(self->ob_sval, Py_SIZE(self));`
`@@ -1922,8 +1912,7 @@ do_xstrip(PyBytesObject self, int striptype, PyObject sepobj)`
`1922`	`1912`	`PyBuffer_Release(&vsep);`
`1923`	`1913`
`1924`	`1914`	`if (i == 0 && j == len && PyBytes_CheckExact(self)) {`
`1925`		`- Py_INCREF(self);`
`1926`		`- return (PyObject*)self;`
	`1915`	`+ return Py_NewRef(self);`
`1927`	`1916`	`}`
`1928`	`1917`	`else`
`1929`	`1918`	`return PyBytes_FromStringAndSize(s+i, j-i);`
`@@ -1952,8 +1941,7 @@ do_strip(PyBytesObject *self, int striptype)`
`1952`	`1941`	`}`
`1953`	`1942`
`1954`	`1943`	`if (i == 0 && j == len && PyBytes_CheckExact(self)) {`
`1955`		`- Py_INCREF(self);`
`1956`		`- return (PyObject*)self;`
	`1944`	`+ return Py_NewRef(self);`
`1957`	`1945`	`}`
`1958`	`1946`	`else`
`1959`	`1947`	`return PyBytes_FromStringAndSize(s+i, j-i);`
`@@ -2152,8 +2140,7 @@ bytes_translate_impl(PyBytesObject self, PyObject table,`
`2152`	`2140`	`}`
`2153`	`2141`	`if (!changed && PyBytes_CheckExact(input_obj)) {`
`2154`	`2142`	`Py_DECREF(result);`
`2155`		`- Py_INCREF(input_obj);`
`2156`		`- return input_obj;`
	`2143`	`+ return Py_NewRef(input_obj);`
`2157`	`2144`	`}`
`2158`	`2145`	`/* Fix the size of the resulting byte string */`
`2159`	`2146`	`if (inlen > 0)`
`@@ -2245,8 +2232,7 @@ bytes_removeprefix_impl(PyBytesObject self, Py_buffer prefix)`
`2245`	`2232`	`}`
`2246`	`2233`
`2247`	`2234`	`if (PyBytes_CheckExact(self)) {`
`2248`		`- Py_INCREF(self);`
`2249`		`- return (PyObject *)self;`
	`2235`	`+ return Py_NewRef(self);`
`2250`	`2236`	`}`
`2251`	`2237`
`2252`	`2238`	`return PyBytes_FromStringAndSize(self_start, self_len);`
`@@ -2284,8 +2270,7 @@ bytes_removesuffix_impl(PyBytesObject self, Py_buffer suffix)`
`2284`	`2270`	`}`
`2285`	`2271`
`2286`	`2272`	`if (PyBytes_CheckExact(self)) {`
`2287`		`- Py_INCREF(self);`
`2288`		`- return (PyObject *)self;`
	`2273`	`+ return Py_NewRef(self);`
`2289`	`2274`	`}`
`2290`	`2275`
`2291`	`2276`	`return PyBytes_FromStringAndSize(self_start, self_len);`
`@@ -2844,8 +2829,7 @@ PyBytes_FromObject(PyObject *x)`
`2844`	`2829`	`}`
`2845`	`2830`
`2846`	`2831`	`if (PyBytes_CheckExact(x)) {`
`2847`		`- Py_INCREF(x);`
`2848`		`- return x;`
	`2832`	`+ return Py_NewRef(x);`
`2849`	`2833`	`}`
`2850`	`2834`
`2851`	`2835`	`/* Use the modern buffer interface */`
`@@ -3269,8 +3253,7 @@ bytes_iter(PyObject *seq)`
`3269`	`3253`	`if (it == NULL)`
`3270`	`3254`	`return NULL;`
`3271`	`3255`	`it->it_index = 0;`
`3272`		`- Py_INCREF(seq);`
`3273`		`- it->it_seq = (PyBytesObject *)seq;`
	`3256`	`+ it->it_seq = (PyBytesObject *)Py_NewRef(seq);`
`3274`	`3257`	`_PyObject_GC_TRACK(it);`
`3275`	`3258`	`return (PyObject *)it;`
`3276`	`3259`	`}`
Original file line number	Diff line number	Diff line change
`@@ -11,8 +11,7 @@ PyCell_New(PyObject *obj)`
`11`	`11`	`op = (PyCellObject *)PyObject_GC_New(PyCellObject, &PyCell_Type);`
`12`	`12`	`if (op == NULL)`
`13`	`13`	`return NULL;`
`14`		`- op->ob_ref = obj;`
`15`		`- Py_XINCREF(obj);`
	`14`	`+ op->ob_ref = Py_XNewRef(obj);`
`16`	`15`
`17`	`16`	`_PyObject_GC_TRACK(op);`
`18`	`17`	`return (PyObject *)op;`
`@@ -68,8 +67,7 @@ PyCell_Set(PyObject op, PyObject value)`
`68`	`67`	`return -1;`
`69`	`68`	`}`
`70`	`69`	`PyObject *old_value = PyCell_GET(op);`
`71`		`- Py_XINCREF(value);`
`72`		`- PyCell_SET(op, value);`
	`70`	`+ PyCell_SET(op, Py_XNewRef(value));`
`73`	`71`	`Py_XDECREF(old_value);`
`74`	`72`	`return 0;`
`75`	`73`	`}`
`@@ -135,15 +133,13 @@ cell_get_contents(PyCellObject op, void closure)`
`135`	`133`	`PyErr_SetString(PyExc_ValueError, "Cell is empty");`
`136`	`134`	`return NULL;`
`137`	`135`	`}`
`138`		`- Py_INCREF(op->ob_ref);`
`139`		`- return op->ob_ref;`
	`136`	`+ return Py_NewRef(op->ob_ref);`
`140`	`137`	`}`
`141`	`138`
`142`	`139`	`static int`
`143`	`140`	`cell_set_contents(PyCellObject op, PyObject obj, void *Py_UNUSED(ignored))`
`144`	`141`	`{`
`145`		`- Py_XINCREF(obj);`
`146`		`- Py_XSETREF(op->ob_ref, obj);`
	`142`	`+ Py_XSETREF(op->ob_ref, Py_XNewRef(obj));`
`147`	`143`	`return 0;`
`148`	`144`	`}`
`149`	`145`