gh-99300: Use Py_NewRef() in Modules/ directory (#99467)

vstinner · web-flow · commit 7e4dec02ac86 · 2022-11-14T13:08:43.000+01:00
Replace Py_INCREF() and Py_XINCREF() with Py_NewRef() and
Py_XNewRef() in test C files of the Modules/ directory.
diff --git a/Modules/_io/_iomodule.c b/Modules/_io/_iomodule.c
@@ -212,8 +212,7 @@ _io_open_impl(PyObject *module, PyObject *file, const char *mode,
     is_number = PyNumber_Check(file);
 
     if (is_number) {
-        path_or_fd = file;
-        Py_INCREF(path_or_fd);
+        path_or_fd = Py_NewRef(file);
     } else {
         path_or_fd = PyOS_FSPath(file);
         if (path_or_fd == NULL) {
@@ -489,8 +488,7 @@ _io_text_encoding_impl(PyObject *module, PyObject *encoding, int stacklevel)
             encoding = &_Py_ID(locale);
         }
     }
-    Py_INCREF(encoding);
-    return encoding;
+    return Py_NewRef(encoding);
 }
 
 
@@ -697,9 +695,8 @@ PyInit__io(void)
         "UnsupportedOperation", PyExc_OSError, PyExc_ValueError);
     if (state->unsupported_operation == NULL)
         goto fail;
-    Py_INCREF(state->unsupported_operation);
     if (PyModule_AddObject(m, "UnsupportedOperation",
-                           state->unsupported_operation) < 0)
+                           Py_NewRef(state->unsupported_operation)) < 0)
         goto fail;
 
     /* BlockingIOError, for compatibility */
diff --git a/Modules/_io/bufferedio.c b/Modules/_io/bufferedio.c
@@ -481,8 +481,7 @@ buffered_close(buffered *self, PyObject *args)
     if (r < 0)
         goto end;
     if (r > 0) {
-        res = Py_None;
-        Py_INCREF(res);
+        res = Py_NewRef(Py_None);
         goto end;
     }
 
@@ -1007,8 +1006,7 @@ _buffered_readinto_generic(buffered *self, Py_buffer *buffer, char readinto1)
             break;
         if (n < 0) {
             if (n == -2) {
-                Py_INCREF(Py_None);
-                res = Py_None;
+                res = Py_NewRef(Py_None);
             }
             goto end;
         }
@@ -1422,8 +1420,7 @@ _io_BufferedReader___init___impl(buffered *self, PyObject *raw,
     if (_PyIOBase_check_readable(raw, Py_True) == NULL)
         return -1;
 
-    Py_INCREF(raw);
-    Py_XSETREF(self->raw, raw);
+    Py_XSETREF(self->raw, Py_NewRef(raw));
     self->buffer_size = buffer_size;
     self->readable = 1;
     self->writable = 0;
diff --git a/Modules/_io/bytesio.c b/Modules/_io/bytesio.c
@@ -324,8 +324,7 @@ _io_BytesIO_getbuffer_impl(bytesio *self)
     buf = (bytesiobuf *) type->tp_alloc(type, 0);
     if (buf == NULL)
         return NULL;
-    Py_INCREF(self);
-    buf->source = self;
+    buf->source = (bytesio*)Py_NewRef(self);
     view = PyMemoryView_FromObject((PyObject *) buf);
     Py_DECREF(buf);
     return view;
@@ -356,8 +355,7 @@ _io_BytesIO_getvalue_impl(bytesio *self)
                 return NULL;
         }
     }
-    Py_INCREF(self->buf);
-    return self->buf;
+    return Py_NewRef(self->buf);
 }
 
 /*[clinic input]
@@ -401,8 +399,7 @@ read_bytes(bytesio *self, Py_ssize_t size)
         self->pos == 0 && size == PyBytes_GET_SIZE(self->buf) &&
         self->exports == 0) {
         self->pos += size;
-        Py_INCREF(self->buf);
-        return self->buf;
+        return Py_NewRef(self->buf);
     }
 
     output = PyBytes_AS_STRING(self->buf) + self->pos;
@@ -791,8 +788,7 @@ bytesio_getstate(bytesio *self, PyObject *Py_UNUSED(ignored))
     if (initvalue == NULL)
         return NULL;
     if (self->dict == NULL) {
-        Py_INCREF(Py_None);
-        dict = Py_None;
+        dict = Py_NewRef(Py_None);
     }
     else {
         dict = PyDict_Copy(self->dict);
@@ -875,8 +871,7 @@ bytesio_setstate(bytesio *self, PyObject *state)
                 return NULL;
         }
         else {
-            Py_INCREF(dict);
-            self->dict = dict;
+            self->dict = Py_NewRef(dict);
         }
     }
 
@@ -943,8 +938,7 @@ _io_BytesIO___init___impl(bytesio *self, PyObject *initvalue)
     }
     if (initvalue && initvalue != Py_None) {
         if (PyBytes_CheckExact(initvalue)) {
-            Py_INCREF(initvalue);
-            Py_XSETREF(self->buf, initvalue);
+            Py_XSETREF(self->buf, Py_NewRef(initvalue));
             self->string_size = PyBytes_GET_SIZE(initvalue);
         }
         else {
diff --git a/Modules/_io/iobase.c b/Modules/_io/iobase.c
@@ -464,8 +464,7 @@ iobase_enter(PyObject *self, PyObject *args)
     if (iobase_check_closed(self))
         return NULL;
 
-    Py_INCREF(self);
-    return self;
+    return Py_NewRef(self);
 }
 
 static PyObject *
@@ -642,8 +641,7 @@ iobase_iter(PyObject *self)
     if (iobase_check_closed(self))
         return NULL;
 
-    Py_INCREF(self);
-    return self;
+    return Py_NewRef(self);
 }
 
 static PyObject *
diff --git a/Modules/_io/stringio.c b/Modules/_io/stringio.c
@@ -188,8 +188,7 @@ write_str(stringio *self, PyObject *obj)
             self->decoder, obj, 1 /* always final */);
     }
     else {
-        decoded = obj;
-        Py_INCREF(decoded);
+        decoded = Py_NewRef(obj);
     }
     if (self->writenl) {
         PyObject *translated = PyUnicode_Replace(
@@ -710,8 +709,7 @@ _io_StringIO___init___impl(stringio *self, PyObject *value,
        is pointless for StringIO)
     */
     if (newline != NULL && newline[0] == '\r') {
-        self->writenl = self->readnl;
-        Py_INCREF(self->writenl);
+        self->writenl = Py_NewRef(self->readnl);
     }
 
     if (self->readuniversal) {
@@ -823,8 +821,7 @@ stringio_getstate(stringio *self, PyObject *Py_UNUSED(ignored))
     if (initvalue == NULL)
         return NULL;
     if (self->dict == NULL) {
-        Py_INCREF(Py_None);
-        dict = Py_None;
+        dict = Py_NewRef(Py_None);
     }
     else {
         dict = PyDict_Copy(self->dict);
@@ -934,8 +931,7 @@ stringio_setstate(stringio *self, PyObject *state)
                 return NULL;
         }
         else {
-            Py_INCREF(dict);
-            self->dict = dict;
+            self->dict = Py_NewRef(dict);
         }
     }
 
diff --git a/Modules/_io/textio.c b/Modules/_io/textio.c
@@ -231,16 +231,14 @@ _io_IncrementalNewlineDecoder___init___impl(nldecoder_object *self,
                                             PyObject *errors)
 /*[clinic end generated code: output=fbd04d443e764ec2 input=89db6b19c6b126bf]*/
 {
-    self->decoder = decoder;
-    Py_INCREF(decoder);
+    self->decoder = Py_NewRef(decoder);
 
     if (errors == NULL) {
-        self->errors = &_Py_ID(strict);
+        self->errors = Py_NewRef(&_Py_ID(strict));
     }
     else {
-        self->errors = errors;
+        self->errors = Py_NewRef(errors);
     }
-    Py_INCREF(self->errors);
 
     self->translate = translate ? 1 : 0;
     self->seennl = 0;
@@ -301,8 +299,7 @@ _PyIncrementalNewlineDecoder_decode(PyObject *myself,
             &_Py_ID(decode), input, final ? Py_True : Py_False, NULL);
     }
     else {
-        output = input;
-        Py_INCREF(output);
+        output = Py_NewRef(input);
     }
 
     if (check_decoded(output) < 0)
@@ -1148,17 +1145,15 @@ _io_TextIOWrapper___init___impl(textio *self, PyObject *buffer,
      * of the partially constructed object (like self->encoding)
      */
 
-    Py_INCREF(errors);
-    self->errors = errors;
+    self->errors = Py_NewRef(errors);
     self->chunk_size = 8192;
     self->line_buffering = line_buffering;
     self->write_through = write_through;
     if (set_newline(self, newline) < 0) {
         goto error;
     }
 
-    self->buffer = buffer;
-    Py_INCREF(buffer);
+    self->buffer = Py_NewRef(buffer);
 
     /* Build the decoder object */
     if (_textiowrapper_set_decoder(self, codec_info, PyUnicode_AsUTF8(errors)) != 0)
@@ -1284,9 +1279,8 @@ textiowrapper_change_encoding(textio *self, PyObject *encoding,
     }
     Py_DECREF(codec_info);
 
-    Py_INCREF(errors);
     Py_SETREF(self->encoding, encoding);
-    Py_SETREF(self->errors, errors);
+    Py_SETREF(self->errors, Py_NewRef(errors));
 
     return _textiowrapper_fix_encoder_state(self);
 }
@@ -1502,8 +1496,7 @@ _textiowrapper_writeflush(textio *self)
     PyObject *b;
 
     if (PyBytes_Check(pending)) {
-        b = pending;
-        Py_INCREF(b);
+        b = Py_NewRef(pending);
     }
     else if (PyUnicode_Check(pending)) {
         assert(PyUnicode_IS_ASCII(pending));
@@ -1618,8 +1611,7 @@ _io_TextIOWrapper_write_impl(textio *self, PyObject *text)
                 // See bpo-43260
                 PyUnicode_GET_LENGTH(text) <= self->chunk_size &&
                 is_asciicompat_encoding(self->encodefunc)) {
-            b = text;
-            Py_INCREF(b);
+            b = Py_NewRef(text);
         }
         else {
             b = (*self->encodefunc)((PyObject *) self, text);
@@ -1741,8 +1733,7 @@ textiowrapper_get_decoded_chars(textio *self, Py_ssize_t n)
             return NULL;
     }
     else {
-        chars = self->decoded_chars;
-        Py_INCREF(chars);
+        chars = Py_NewRef(self->decoded_chars);
     }
 
     self->decoded_chars_used += n;
@@ -2139,10 +2130,9 @@ _textiowrapper_readline(textio *self, Py_ssize_t limit)
         }
 
         if (remaining == NULL) {
-            line = self->decoded_chars;
+            line = Py_NewRef(self->decoded_chars);
             start = self->decoded_chars_used;
             offset_to_buffer = 0;
-            Py_INCREF(line);
         }
         else {
             assert(self->decoded_chars_used == 0);
@@ -3115,8 +3105,7 @@ static PyObject *
 textiowrapper_errors_get(textio *self, void *context)
 {
     CHECK_INITIALIZED(self);
-    Py_INCREF(self->errors);
-    return self->errors;
+    return Py_NewRef(self->errors);
 }
 
 static PyObject *
diff --git a/Modules/_json.c b/Modules/_json.c
@@ -1243,16 +1243,17 @@ encoder_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
     if (s == NULL)
         return NULL;
 
-    s->markers = markers;
-    s->defaultfn = defaultfn;
-    s->encoder = encoder;
-    s->indent = indent;
-    s->key_separator = key_separator;
-    s->item_separator = item_separator;
+    s->markers = Py_NewRef(markers);
+    s->defaultfn = Py_NewRef(defaultfn);
+    s->encoder = Py_NewRef(encoder);
+    s->indent = Py_NewRef(indent);
+    s->key_separator = Py_NewRef(key_separator);
+    s->item_separator = Py_NewRef(item_separator);
     s->sort_keys = sort_keys;
     s->skipkeys = skipkeys;
     s->allow_nan = allow_nan;
     s->fast_encode = NULL;
+
     if (PyCFunction_Check(s->encoder)) {
         PyCFunction f = PyCFunction_GetFunction(s->encoder);
         if (f == (PyCFunction)py_encode_basestring_ascii ||
@@ -1261,12 +1262,6 @@ encoder_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
         }
     }
 
-    Py_INCREF(s->markers);
-    Py_INCREF(s->defaultfn);
-    Py_INCREF(s->encoder);
-    Py_INCREF(s->indent);
-    Py_INCREF(s->key_separator);
-    Py_INCREF(s->item_separator);
     return (PyObject *)s;
 }
 
@@ -1480,8 +1475,7 @@ encoder_encode_key_value(PyEncoderObject *s, _PyUnicodeWriter *writer, bool *fir
     PyObject *encoded;
 
     if (PyUnicode_Check(key)) {
-        Py_INCREF(key);
-        keystr = key;
+        keystr = Py_NewRef(key);
     }
     else if (PyFloat_Check(key)) {
         keystr = encoder_encode_float(s, key);
diff --git a/Modules/_lsprof.c b/Modules/_lsprof.c
@@ -128,8 +128,7 @@ normalizeUserObj(PyObject *obj)
 {
     PyCFunctionObject *fn;
     if (!PyCFunction_Check(obj)) {
-        Py_INCREF(obj);
-        return obj;
+        return Py_NewRef(obj);
     }
     /* Replace built-in function objects with a descriptive string
        because of built-in methods -- keeping a reference to
@@ -142,8 +141,7 @@ normalizeUserObj(PyObject *obj)
         PyObject *modname = NULL;
         if (mod != NULL) {
             if (PyUnicode_Check(mod)) {
-                modname = mod;
-                Py_INCREF(modname);
+                modname = Py_NewRef(mod);
             }
             else if (PyModule_Check(mod)) {
                 modname = PyModule_GetNameObject(mod);
@@ -555,8 +553,7 @@ static int statsForEntry(rotating_node_t *node, void *arg)
         }
     }
     else {
-        Py_INCREF(Py_None);
-        collect->sublist = Py_None;
+        collect->sublist = Py_NewRef(Py_None);
     }
 
     info = PyObject_CallFunction((PyObject*) collect->state->stats_entry_type,
@@ -781,8 +778,7 @@ profiler_init(ProfilerObject *pObj, PyObject *args, PyObject *kw)
     if (setSubcalls(pObj, subcalls) < 0 || setBuiltins(pObj, builtins) < 0)
         return -1;
     pObj->externalTimerUnit = timeunit;
-    Py_XINCREF(timer);
-    Py_XSETREF(pObj->externalTimer, timer);
+    Py_XSETREF(pObj->externalTimer, Py_XNewRef(timer));
     return 0;
 }
 
diff --git a/Modules/_operator.c b/Modules/_operator.c
diff --git a/Modules/_pickle.c b/Modules/_pickle.c

Original file line number	Diff line number	Diff line change
`@@ -324,8 +324,7 @@ _io_BytesIO_getbuffer_impl(bytesio *self)`
`324`	`324`	`buf = (bytesiobuf *) type->tp_alloc(type, 0);`
`325`	`325`	`if (buf == NULL)`
`326`	`326`	`return NULL;`
`327`		`- Py_INCREF(self);`
`328`		`- buf->source = self;`
	`327`	`+ buf->source = (bytesio*)Py_NewRef(self);`
`329`	`328`	`view = PyMemoryView_FromObject((PyObject *) buf);`
`330`	`329`	`Py_DECREF(buf);`
`331`	`330`	`return view;`
`@@ -356,8 +355,7 @@ _io_BytesIO_getvalue_impl(bytesio *self)`
`356`	`355`	`return NULL;`
`357`	`356`	`}`
`358`	`357`	`}`
`359`		`- Py_INCREF(self->buf);`
`360`		`- return self->buf;`
	`358`	`+ return Py_NewRef(self->buf);`
`361`	`359`	`}`
`362`	`360`
`363`	`361`	`/*[clinic input]`
`@@ -401,8 +399,7 @@ read_bytes(bytesio *self, Py_ssize_t size)`
`401`	`399`	`self->pos == 0 && size == PyBytes_GET_SIZE(self->buf) &&`
`402`	`400`	`self->exports == 0) {`
`403`	`401`	`self->pos += size;`
`404`		`- Py_INCREF(self->buf);`
`405`		`- return self->buf;`
	`402`	`+ return Py_NewRef(self->buf);`
`406`	`403`	`}`
`407`	`404`
`408`	`405`	`output = PyBytes_AS_STRING(self->buf) + self->pos;`
`@@ -791,8 +788,7 @@ bytesio_getstate(bytesio self, PyObject Py_UNUSED(ignored))`
`791`	`788`	`if (initvalue == NULL)`
`792`	`789`	`return NULL;`
`793`	`790`	`if (self->dict == NULL) {`
`794`		`- Py_INCREF(Py_None);`
`795`		`- dict = Py_None;`
	`791`	`+ dict = Py_NewRef(Py_None);`
`796`	`792`	`}`
`797`	`793`	`else {`
`798`	`794`	`dict = PyDict_Copy(self->dict);`
`@@ -875,8 +871,7 @@ bytesio_setstate(bytesio self, PyObject state)`
`875`	`871`	`return NULL;`
`876`	`872`	`}`
`877`	`873`	`else {`
`878`		`- Py_INCREF(dict);`
`879`		`- self->dict = dict;`
	`874`	`+ self->dict = Py_NewRef(dict);`
`880`	`875`	`}`
`881`	`876`	`}`
`882`	`877`
`@@ -943,8 +938,7 @@ _io_BytesIO___init___impl(bytesio self, PyObject initvalue)`
`943`	`938`	`}`
`944`	`939`	`if (initvalue && initvalue != Py_None) {`
`945`	`940`	`if (PyBytes_CheckExact(initvalue)) {`
`946`		`- Py_INCREF(initvalue);`
`947`		`- Py_XSETREF(self->buf, initvalue);`
	`941`	`+ Py_XSETREF(self->buf, Py_NewRef(initvalue));`
`948`	`942`	`self->string_size = PyBytes_GET_SIZE(initvalue);`
`949`	`943`	`}`
`950`	`944`	`else {`
Original file line number	Diff line number	Diff line change
`@@ -188,8 +188,7 @@ write_str(stringio self, PyObject obj)`
`188`	`188`	`self->decoder, obj, 1 /* always final */);`
`189`	`189`	`}`
`190`	`190`	`else {`
`191`		`- decoded = obj;`
`192`		`- Py_INCREF(decoded);`
	`191`	`+ decoded = Py_NewRef(obj);`
`193`	`192`	`}`
`194`	`193`	`if (self->writenl) {`
`195`	`194`	`PyObject *translated = PyUnicode_Replace(`
`@@ -710,8 +709,7 @@ _io_StringIO___init___impl(stringio self, PyObject value,`
`710`	`709`	`is pointless for StringIO)`
`711`	`710`	`*/`
`712`	`711`	`if (newline != NULL && newline[0] == '\r') {`
`713`		`- self->writenl = self->readnl;`
`714`		`- Py_INCREF(self->writenl);`
	`712`	`+ self->writenl = Py_NewRef(self->readnl);`
`715`	`713`	`}`
`716`	`714`
`717`	`715`	`if (self->readuniversal) {`
`@@ -823,8 +821,7 @@ stringio_getstate(stringio self, PyObject Py_UNUSED(ignored))`
`823`	`821`	`if (initvalue == NULL)`
`824`	`822`	`return NULL;`
`825`	`823`	`if (self->dict == NULL) {`
`826`		`- Py_INCREF(Py_None);`
`827`		`- dict = Py_None;`
	`824`	`+ dict = Py_NewRef(Py_None);`
`828`	`825`	`}`
`829`	`826`	`else {`
`830`	`827`	`dict = PyDict_Copy(self->dict);`
`@@ -934,8 +931,7 @@ stringio_setstate(stringio self, PyObject state)`
`934`	`931`	`return NULL;`
`935`	`932`	`}`
`936`	`933`	`else {`
`937`		`- Py_INCREF(dict);`
`938`		`- self->dict = dict;`
	`934`	`+ self->dict = Py_NewRef(dict);`
`939`	`935`	`}`
`940`	`936`	`}`
`941`	`937`
Original file line number	Diff line number	Diff line change
`@@ -128,8 +128,7 @@ normalizeUserObj(PyObject *obj)`
`128`	`128`	`{`
`129`	`129`	`PyCFunctionObject *fn;`
`130`	`130`	`if (!PyCFunction_Check(obj)) {`
`131`		`- Py_INCREF(obj);`
`132`		`- return obj;`
	`131`	`+ return Py_NewRef(obj);`
`133`	`132`	`}`
`134`	`133`	`/* Replace built-in function objects with a descriptive string`
`135`	`134`	`because of built-in methods -- keeping a reference to`
`@@ -142,8 +141,7 @@ normalizeUserObj(PyObject *obj)`
`142`	`141`	`PyObject *modname = NULL;`
`143`	`142`	`if (mod != NULL) {`
`144`	`143`	`if (PyUnicode_Check(mod)) {`
`145`		`- modname = mod;`
`146`		`- Py_INCREF(modname);`
	`144`	`+ modname = Py_NewRef(mod);`
`147`	`145`	`}`
`148`	`146`	`else if (PyModule_Check(mod)) {`
`149`	`147`	`modname = PyModule_GetNameObject(mod);`
`@@ -555,8 +553,7 @@ static int statsForEntry(rotating_node_t node, void arg)`
`555`	`553`	`}`
`556`	`554`	`}`
`557`	`555`	`else {`
`558`		`- Py_INCREF(Py_None);`
`559`		`- collect->sublist = Py_None;`
	`556`	`+ collect->sublist = Py_NewRef(Py_None);`
`560`	`557`	`}`
`561`	`558`
`562`	`559`	`info = PyObject_CallFunction((PyObject*) collect->state->stats_entry_type,`
`@@ -781,8 +778,7 @@ profiler_init(ProfilerObject pObj, PyObject args, PyObject *kw)`
`781`	`778`	`if (setSubcalls(pObj, subcalls) < 0 \|\| setBuiltins(pObj, builtins) < 0)`
`782`	`779`	`return -1;`
`783`	`780`	`pObj->externalTimerUnit = timeunit;`
`784`		`- Py_XINCREF(timer);`
`785`		`- Py_XSETREF(pObj->externalTimer, timer);`
	`781`	`+ Py_XSETREF(pObj->externalTimer, Py_XNewRef(timer));`
`786`	`782`	`return 0;`
`787`	`783`	`}`
`788`	`784`