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

Replace Py_INCREF() and Py_XINCREF() with Py_NewRef() and
Py_XNewRef() in test C files of the Modules/ directory.

10 files changed, 92 insertions, 173 deletions

diff --git a/Modules/_sre/sre.c b/Modules/_sre/sre.c
index 44039ce..4b6290a 100644
--- a/Modules/_sre/sre.c
+++ b/Modules/_sre/sre.c
@@ -459,8 +459,7 @@ state_init(SRE_STATE* state, PatternObject* pattern, PyObject* string,
     state->start = (void*) ((char*) ptr + start * state->charsize);
     state->end = (void*) ((char*) ptr + end * state->charsize);
 
-    Py_INCREF(string);
-    state->string = string;
+    state->string = Py_NewRef(string);
     state->pos = start;
     state->endpos = end;
 
@@ -499,8 +498,7 @@ getslice(int isbytes, const void *ptr,
     if (isbytes) {
         if (PyBytes_CheckExact(string) &&
             start == 0 && end == PyBytes_GET_SIZE(string)) {
-            Py_INCREF(string);
-            return string;
+            return Py_NewRef(string);
         }
         return PyBytes_FromStringAndSize(
                 (const char *)ptr + start, end - start);
@@ -1089,8 +1087,7 @@ pattern_subx(_sremodulestate* module_state,
 
     if (PyCallable_Check(ptemplate)) {
         /* sub/subn takes either a function or a template */
-        filter = ptemplate;
-        Py_INCREF(filter);
+        filter = Py_NewRef(ptemplate);
         filter_type = CALLABLE;
     } else {
         /* if not callable, check if it's a literal string */
@@ -1109,8 +1106,7 @@ pattern_subx(_sremodulestate* module_state,
         if (view.buf)
             PyBuffer_Release(&view);
         if (literal) {
-            filter = ptemplate;
-            Py_INCREF(filter);
+            filter = Py_NewRef(ptemplate);
             filter_type = LITERAL;
         } else {
             /* not a literal; hand it over to the template compiler */
@@ -1120,8 +1116,8 @@ pattern_subx(_sremodulestate* module_state,
 
             assert(Py_TYPE(filter) == module_state->Template_Type);
             if (Py_SIZE(filter) == 0) {
-                Py_INCREF(((TemplateObject *)filter)->literal);
-                Py_SETREF(filter, ((TemplateObject *)filter)->literal);
+                Py_SETREF(filter,
+                          Py_NewRef(((TemplateObject *)filter)->literal));
                 filter_type = LITERAL;
             }
             else {
@@ -1195,8 +1191,7 @@ pattern_subx(_sremodulestate* module_state,
                 goto error;
         } else {
             /* filter is literal string */
-            item = filter;
-            Py_INCREF(item);
+            item = Py_NewRef(filter);
         }
 
         /* add to list */
@@ -1317,8 +1312,7 @@ static PyObject *
 _sre_SRE_Pattern___copy___impl(PatternObject *self)
 /*[clinic end generated code: output=85dedc2db1bd8694 input=a730a59d863bc9f5]*/
 {
-    Py_INCREF(self);
-    return (PyObject *)self;
+    return Py_NewRef(self);
 }
 
 /*[clinic input]
@@ -1333,8 +1327,7 @@ static PyObject *
 _sre_SRE_Pattern___deepcopy__(PatternObject *self, PyObject *memo)
 /*[clinic end generated code: output=2ad25679c1f1204a input=a465b1602f997bed]*/
 {
-    Py_INCREF(self);
-    return (PyObject *)self;
+    return Py_NewRef(self);
 }
 
 static PyObject *
@@ -1500,19 +1493,16 @@ _sre_compile_impl(PyObject *module, PyObject *pattern, int flags,
             PyBuffer_Release(&view);
     }
 
-    Py_INCREF(pattern);
-    self->pattern = pattern;
+    self->pattern = Py_NewRef(pattern);
 
     self->flags = flags;
 
     self->groups = groups;
 
     if (PyDict_GET_SIZE(groupindex) > 0) {
-        Py_INCREF(groupindex);
-        self->groupindex = groupindex;
+        self->groupindex = Py_NewRef(groupindex);
         if (PyTuple_GET_SIZE(indexgroup) > 0) {
-            Py_INCREF(indexgroup);
-            self->indexgroup = indexgroup;
+            self->indexgroup = Py_NewRef(indexgroup);
         }
     }
 
@@ -1555,8 +1545,7 @@ _sre_template_impl(PyObject *module, PyObject *pattern, PyObject *template)
     if (!self)
         return NULL;
     self->chunks = 1 + 2*n;
-    self->literal = PyList_GET_ITEM(template, 0);
-    Py_INCREF(self->literal);
+    self->literal = Py_NewRef(PyList_GET_ITEM(template, 0));
     for (Py_ssize_t i = 0; i < n; i++) {
         Py_ssize_t index = PyLong_AsSsize_t(PyList_GET_ITEM(template, 2*i+1));
         if (index == -1 && PyErr_Occurred()) {
@@ -1576,8 +1565,7 @@ _sre_template_impl(PyObject *module, PyObject *pattern, PyObject *template)
             literal = NULL;
             self->chunks--;
         }
-        Py_XINCREF(literal);
-        self->items[i].literal = literal;
+        self->items[i].literal = Py_XNewRef(literal);
     }
     return (PyObject*) self;
 
@@ -2128,8 +2116,7 @@ match_getslice_by_index(MatchObject* self, Py_ssize_t index, PyObject* def)
 
     if (self->string == Py_None || self->mark[index] < 0) {
         /* return default value if the string or group is undefined */
-        Py_INCREF(def);
-        return def;
+        return Py_NewRef(def);
     }
 
     ptr = getstring(self->string, &length, &isbytes, &charsize, &view);
@@ -2448,8 +2435,7 @@ match_regs(MatchObject* self)
         PyTuple_SET_ITEM(regs, index, item);
     }
 
-    Py_INCREF(regs);
-    self->regs = regs;
+    self->regs = Py_NewRef(regs);
 
     return regs;
 }
@@ -2463,8 +2449,7 @@ static PyObject *
 _sre_SRE_Match___copy___impl(MatchObject *self)
 /*[clinic end generated code: output=a779c5fc8b5b4eb4 input=3bb4d30b6baddb5b]*/
 {
-    Py_INCREF(self);
-    return (PyObject *)self;
+    return Py_NewRef(self);
 }
 
 /*[clinic input]
@@ -2479,8 +2464,7 @@ static PyObject *
 _sre_SRE_Match___deepcopy__(MatchObject *self, PyObject *memo)
 /*[clinic end generated code: output=ba7cb46d655e4ee2 input=779d12a31c2c325e]*/
 {
-    Py_INCREF(self);
-    return (PyObject *)self;
+    return Py_NewRef(self);
 }
 
 PyDoc_STRVAR(match_doc,
@@ -2509,8 +2493,7 @@ match_lastgroup_get(MatchObject *self, void *Py_UNUSED(ignored))
     {
         PyObject *result = PyTuple_GET_ITEM(self->pattern->indexgroup,
                                             self->lastindex);
-        Py_INCREF(result);
-        return result;
+        return Py_NewRef(result);
     }
     Py_RETURN_NONE;
 }
@@ -2519,8 +2502,7 @@ static PyObject *
 match_regs_get(MatchObject *self, void *Py_UNUSED(ignored))
 {
     if (self->regs) {
-        Py_INCREF(self->regs);
-        return self->regs;
+        return Py_NewRef(self->regs);
     } else
         return match_regs(self);
 }
@@ -2564,11 +2546,9 @@ pattern_new_match(_sremodulestate* module_state,
         if (!match)
             return NULL;
 
-        Py_INCREF(pattern);
-        match->pattern = pattern;
+        match->pattern = (PatternObject*)Py_NewRef(pattern);
 
-        Py_INCREF(state->string);
-        match->string = state->string;
+        match->string = Py_NewRef(state->string);
 
         match->regs = NULL;
         match->groups = pattern->groups+1;
@@ -2788,8 +2768,7 @@ pattern_scanner(_sremodulestate *module_state,
         return NULL;
     }
 
-    Py_INCREF(self);
-    scanner->pattern = (PyObject*) self;
+    scanner->pattern = Py_NewRef(self);
 
     PyObject_GC_Track(scanner);
     return (PyObject*) scanner;
@@ -2834,8 +2813,7 @@ static PyObject *
 expand_template(TemplateObject *self, MatchObject *match)
 {
     if (Py_SIZE(self) == 0) {
-        Py_INCREF(self->literal);
-        return self->literal;
+        return Py_NewRef(self->literal);
     }
 
     PyObject *result = NULL;
@@ -2855,8 +2833,7 @@ expand_template(TemplateObject *self, MatchObject *match)
         out = &PyList_GET_ITEM(list, 0);
     }
 
-    Py_INCREF(self->literal);
-    out[count++] = self->literal;
+    out[count++] = Py_NewRef(self->literal);
     for (Py_ssize_t i = 0; i < Py_SIZE(self); i++) {
         Py_ssize_t index = self->items[i].index;
         if (index >= match->groups) {
@@ -2868,15 +2845,13 @@ expand_template(TemplateObject *self, MatchObject *match)
             goto cleanup;
         }
         if (item != Py_None) {
-            Py_INCREF(item);
-            out[count++] = item;
+            out[count++] = Py_NewRef(item);
         }
         Py_DECREF(item);
 
         PyObject *literal = self->items[i].literal;
         if (literal != NULL) {
-            Py_INCREF(literal);
-            out[count++] = literal;
+            out[count++] = Py_NewRef(literal);
         }
     }
 
diff --git a/Modules/_ssl.c b/Modules/_ssl.c
index bf8bd9d..2826d15 100644
--- a/Modules/_ssl.c
+++ b/Modules/_ssl.c
@@ -415,8 +415,7 @@ static PyObject *
 SSLError_str(PyOSErrorObject *self)
 {
     if (self->strerror != NULL && PyUnicode_Check(self->strerror)) {
-        Py_INCREF(self->strerror);
-        return self->strerror;
+        return Py_NewRef(self->strerror);
     }
     else
         return PyObject_Str(self->args);
@@ -500,8 +499,7 @@ fill_and_set_sslerror(_sslmodulestate *state,
             if (verify_str != NULL) {
                 verify_obj = PyUnicode_FromString(verify_str);
             } else {
-                verify_obj = Py_None;
-                Py_INCREF(verify_obj);
+                verify_obj = Py_NewRef(Py_None);
             }
             break;
         }
@@ -800,8 +798,7 @@ newPySSLSocket(PySSLContext *sslctx, PySocketSockObject *sock,
 
     self->ssl = NULL;
     self->Socket = NULL;
-    self->ctx = sslctx;
-    Py_INCREF(sslctx);
+    self->ctx = (PySSLContext*)Py_NewRef(sslctx);
     self->shutdown_seen_zero = 0;
     self->owner = NULL;
     self->server_hostname = NULL;
@@ -1026,8 +1023,7 @@ _asn1obj2py(_sslmodulestate *state, const ASN1_OBJECT *name, int no_name)
         }
     }
     if (!buflen && no_name) {
-        Py_INCREF(Py_None);
-        name_obj = Py_None;
+        name_obj = Py_NewRef(Py_None);
     }
     else {
         name_obj = PyUnicode_FromStringAndSize(namebuf, buflen);
@@ -1876,8 +1872,7 @@ _ssl__SSLSocket_get_unverified_chain_impl(PySSLSocket *self)
         X509 *peer = SSL_get_peer_certificate(self->ssl);
 
         if (peer == NULL) {
-            peerobj = Py_None;
-            Py_INCREF(peerobj);
+            peerobj = Py_NewRef(Py_None);
         } else {
             /* consume X509 reference on success */
             peerobj = _PySSL_CertificateFromX509(self->ctx->state, peer, 0);
@@ -1907,8 +1902,7 @@ cipher_to_tuple(const SSL_CIPHER *cipher)
 
     cipher_name = SSL_CIPHER_get_name(cipher);
     if (cipher_name == NULL) {
-        Py_INCREF(Py_None);
-        PyTuple_SET_ITEM(retval, 0, Py_None);
+        PyTuple_SET_ITEM(retval, 0, Py_NewRef(Py_None));
     } else {
         v = PyUnicode_FromString(cipher_name);
         if (v == NULL)
@@ -1918,8 +1912,7 @@ cipher_to_tuple(const SSL_CIPHER *cipher)
 
     cipher_protocol = SSL_CIPHER_get_version(cipher);
     if (cipher_protocol == NULL) {
-        Py_INCREF(Py_None);
-        PyTuple_SET_ITEM(retval, 1, Py_None);
+        PyTuple_SET_ITEM(retval, 1, Py_NewRef(Py_None));
     } else {
         v = PyUnicode_FromString(cipher_protocol);
         if (v == NULL)
@@ -2103,16 +2096,14 @@ _ssl__SSLSocket_compression_impl(PySSLSocket *self)
 }
 
 static PySSLContext *PySSL_get_context(PySSLSocket *self, void *closure) {
-    Py_INCREF(self->ctx);
-    return self->ctx;
+    return (PySSLContext*)Py_NewRef(self->ctx);
 }
 
 static int PySSL_set_context(PySSLSocket *self, PyObject *value,
                                    void *closure) {
 
     if (PyObject_TypeCheck(value, self->ctx->state->PySSLContext_Type)) {
-        Py_INCREF(value);
-        Py_SETREF(self->ctx, (PySSLContext *)value);
+        Py_SETREF(self->ctx, (PySSLContext *)Py_NewRef(value));
         SSL_set_SSL_CTX(self->ssl, self->ctx->ctx);
         /* Set SSL* internal msg_callback to state of new context's state */
         SSL_set_msg_callback(
@@ -2150,8 +2141,7 @@ PySSL_get_server_hostname(PySSLSocket *self, void *c)
 {
     if (self->server_hostname == NULL)
         Py_RETURN_NONE;
-    Py_INCREF(self->server_hostname);
-    return self->server_hostname;
+    return Py_NewRef(self->server_hostname);
 }
 
 PyDoc_STRVAR(PySSL_get_server_hostname_doc,
@@ -2166,8 +2156,7 @@ PySSL_get_owner(PySSLSocket *self, void *c)
         Py_RETURN_NONE;
 
     owner = PyWeakref_GetObject(self->owner);
-    Py_INCREF(owner);
-    return owner;
+    return Py_NewRef(owner);
 }
 
 static int
@@ -2820,8 +2809,7 @@ PySSL_get_session(PySSLSocket *self, void *closure) {
     }
 
     assert(self->ctx);
-    pysess->ctx = self->ctx;
-    Py_INCREF(pysess->ctx);
+    pysess->ctx = (PySSLContext*)Py_NewRef(self->ctx);
     pysess->session = session;
     PyObject_GC_Track(pysess);
     return (PyObject *)pysess;
@@ -4459,8 +4447,7 @@ get_sni_callback(PySSLContext *self, void *c)
     if (cb == NULL) {
         Py_RETURN_NONE;
     }
-    Py_INCREF(cb);
-    return cb;
+    return Py_NewRef(cb);
 }
 
 static int
@@ -4482,8 +4469,7 @@ set_sni_callback(PySSLContext *self, PyObject *arg, void *c)
                             "not a callable object");
             return -1;
         }
-        Py_INCREF(arg);
-        self->set_sni_cb = arg;
+        self->set_sni_cb = Py_NewRef(arg);
         SSL_CTX_set_tlsext_servername_callback(self->ctx, _servername_callback);
         SSL_CTX_set_tlsext_servername_arg(self->ctx, self);
     }
@@ -5196,7 +5182,7 @@ _ssl_get_default_verify_paths_impl(PyObject *module)
 #define CONVERT(info, target) { \
         const char *tmp = (info); \
         target = NULL; \
-        if (!tmp) { Py_INCREF(Py_None); target = Py_None; } \
+        if (!tmp) { target = Py_NewRef(Py_None); } \
         else if ((target = PyUnicode_DecodeFSDefault(tmp)) == NULL) { \
             target = PyBytes_FromString(tmp); } \
         if (!target) goto error; \
@@ -5311,11 +5297,9 @@ certEncodingType(DWORD encodingType)
     }
     switch(encodingType) {
     case X509_ASN_ENCODING:
-        Py_INCREF(x509_asn);
-        return x509_asn;
+        return Py_NewRef(x509_asn);
     case PKCS_7_ASN_ENCODING:
-        Py_INCREF(pkcs_7_asn);
-        return pkcs_7_asn;
+        return Py_NewRef(pkcs_7_asn);
     default:
         return PyLong_FromLong(encodingType);
     }
@@ -5717,8 +5701,7 @@ sslmodule_init_socketapi(PyObject *module)
     if ((sockmod == NULL) || (sockmod->Sock_Type == NULL)) {
         return -1;
     }
-    state->Sock_Type = sockmod->Sock_Type;
-    Py_INCREF(state->Sock_Type);
+    state->Sock_Type = (PyTypeObject*)Py_NewRef(sockmod->Sock_Type);
     return 0;
 }
 
@@ -5925,8 +5908,7 @@ sslmodule_init_constants(PyObject *m)
 #define addbool(m, key, value) \
     do { \
         PyObject *bool_obj = (value) ? Py_True : Py_False; \
-        Py_INCREF(bool_obj); \
-        PyModule_AddObject((m), (key), bool_obj); \
+        PyModule_AddObject((m), (key), Py_NewRef(bool_obj)); \
     } while (0)
 
     addbool(m, "HAS_SNI", 1);
diff --git a/Modules/_ssl/debughelpers.c b/Modules/_ssl/debughelpers.c
index 03c125e..08f3457 100644
--- a/Modules/_ssl/debughelpers.c
+++ b/Modules/_ssl/debughelpers.c
@@ -87,8 +87,7 @@ _PySSL_msg_callback(int write_p, int version, int content_type,
 static PyObject *
 _PySSLContext_get_msg_callback(PySSLContext *self, void *c) {
     if (self->msg_cb != NULL) {
-        Py_INCREF(self->msg_cb);
-        return self->msg_cb;
+        return Py_NewRef(self->msg_cb);
     } else {
         Py_RETURN_NONE;
     }
@@ -107,8 +106,7 @@ _PySSLContext_set_msg_callback(PySSLContext *self, PyObject *arg, void *c) {
                             "not a callable object");
             return -1;
         }
-        Py_INCREF(arg);
-        self->msg_cb = arg;
+        self->msg_cb = Py_NewRef(arg);
         SSL_CTX_set_msg_callback(self->ctx, _PySSL_msg_callback);
     }
     return 0;
@@ -166,8 +164,7 @@ _PySSL_keylog_callback(const SSL *ssl, const char *line)
 static PyObject *
 _PySSLContext_get_keylog_filename(PySSLContext *self, void *c) {
     if (self->keylog_filename != NULL) {
-        Py_INCREF(self->keylog_filename);
-        return self->keylog_filename;
+        return Py_NewRef(self->keylog_filename);
     } else {
         Py_RETURN_NONE;
     }
@@ -203,8 +200,7 @@ _PySSLContext_set_keylog_filename(PySSLContext *self, PyObject *arg, void *c) {
                         "Can't malloc memory for keylog file");
         return -1;
     }
-    Py_INCREF(arg);
-    self->keylog_filename = arg;
+    self->keylog_filename = Py_NewRef(arg);
 
     /* Write a header for seekable, empty files (this excludes pipes). */
     PySSL_BEGIN_ALLOW_THREADS
diff --git a/Modules/_struct.c b/Modules/_struct.c
index f9bac34..2f2eb25 100644
--- a/Modules/_struct.c
+++ b/Modules/_struct.c
@@ -1829,8 +1829,7 @@ Struct_iter_unpack(PyStructObject *self, PyObject *buffer)
         Py_DECREF(iter);
         return NULL;
     }
-    Py_INCREF(self);
-    iter->so = self;
+    iter->so = (PyStructObject*)Py_NewRef(self);
     iter->index = 0;
     return (PyObject *)iter;
 }
@@ -2178,8 +2177,7 @@ cache_struct_converter(PyObject *module, PyObject *fmt, PyStructObject **ptr)
 
     s_object = PyDict_GetItemWithError(state->cache, fmt);
     if (s_object != NULL) {
-        Py_INCREF(s_object);
-        *ptr = (PyStructObject *)s_object;
+        *ptr = (PyStructObject *)Py_NewRef(s_object);
         return Py_CLEANUP_SUPPORTED;
     }
     else if (PyErr_Occurred()) {
diff --git a/Modules/_tkinter.c b/Modules/_tkinter.c
index 4807ad5..a5d5428 100644
--- a/Modules/_tkinter.c
+++ b/Modules/_tkinter.c
@@ -784,16 +784,14 @@ PyTclObject_string(PyTclObject *self, void *ignored)
         if (!self->string)
             return NULL;
     }
-    Py_INCREF(self->string);
-    return self->string;
+    return Py_NewRef(self->string);
 }
 
 static PyObject *
 PyTclObject_str(PyTclObject *self)
 {
     if (self->string) {
-        Py_INCREF(self->string);
-        return self->string;
+        return Py_NewRef(self->string);
     }
     /* XXX Could cache result if it is non-ASCII. */
     return unicodeFromTclObj(self->value);
@@ -1736,8 +1734,7 @@ SetVar(TkappObject *self, PyObject *args, int flags)
         if (!ok)
             Tkinter_Error(self);
         else {
-            res = Py_None;
-            Py_INCREF(res);
+            res = Py_NewRef(Py_None);
         }
         LEAVE_OVERLAP_TCL
         break;
@@ -1755,8 +1752,7 @@ SetVar(TkappObject *self, PyObject *args, int flags)
         if (!ok)
             Tkinter_Error(self);
         else {
-            res = Py_None;
-            Py_INCREF(res);
+            res = Py_NewRef(Py_None);
         }
         LEAVE_OVERLAP_TCL
         break;
@@ -1842,8 +1838,7 @@ UnsetVar(TkappObject *self, PyObject *args, int flags)
     if (code == TCL_ERROR)
         res = Tkinter_Error(self);
     else {
-        Py_INCREF(Py_None);
-        res = Py_None;
+        res = Py_NewRef(Py_None);
     }
     LEAVE_OVERLAP_TCL
     return res;
@@ -1883,8 +1878,7 @@ _tkinter_tkapp_getint(TkappObject *self, PyObject *arg)
     PyObject *result;
 
     if (PyLong_Check(arg)) {
-        Py_INCREF(arg);
-        return arg;
+        return Py_NewRef(arg);
     }
 
     if (PyTclObject_Check(arg)) {
@@ -1928,8 +1922,7 @@ _tkinter_tkapp_getdouble(TkappObject *self, PyObject *arg)
     double v;
 
     if (PyFloat_Check(arg)) {
-        Py_INCREF(arg);
-        return arg;
+        return Py_NewRef(arg);
     }
 
     if (PyNumber_Check(arg)) {
@@ -2145,8 +2138,7 @@ _tkinter_tkapp_splitlist(TkappObject *self, PyObject *arg)
         return v;
     }
     if (PyTuple_Check(arg)) {
-        Py_INCREF(arg);
-        return arg;
+        return Py_NewRef(arg);
     }
     if (PyList_Check(arg)) {
         return PySequence_Tuple(arg);
@@ -2322,10 +2314,8 @@ _tkinter_tkapp_createcommand_impl(TkappObject *self, const char *name,
     data = PyMem_NEW(PythonCmd_ClientData, 1);
     if (!data)
         return PyErr_NoMemory();
-    Py_INCREF(self);
-    Py_INCREF(func);
-    data->self = (PyObject *) self;
-    data->func = func;
+    data->self = Py_NewRef(self);
+    data->func = Py_NewRef(func);
     if (self->threaded && self->thread_id != Tcl_GetCurrentThread()) {
         Tcl_Condition cond = NULL;
         CommandEvent *ev = (CommandEvent*)attemptckalloc(sizeof(CommandEvent));
@@ -2430,10 +2420,8 @@ NewFHCD(PyObject *func, PyObject *file, int id)
     FileHandler_ClientData *p;
     p = PyMem_NEW(FileHandler_ClientData, 1);
     if (p != NULL) {
-        Py_XINCREF(func);
-        Py_XINCREF(file);
-        p->func = func;
-        p->file = file;
+        p->func = Py_XNewRef(func);
+        p->file = Py_XNewRef(file);
         p->id = id;
         p->next = HeadFHCD;
         HeadFHCD = p;
@@ -2591,13 +2579,11 @@ Tktt_New(PyObject *func)
     if (v == NULL)
         return NULL;
 
-    Py_INCREF(func);
     v->token = NULL;
-    v->func = func;
+    v->func = Py_NewRef(func);
 
     /* Extra reference, deleted when called or when handler is deleted */
-    Py_INCREF(v);
-    return v;
+    return (TkttObject*)Py_NewRef(v);
 }
 
 static void
@@ -2940,9 +2926,8 @@ _flatten1(FlattenContext* context, PyObject* item, int depth)
                 if (context->size + 1 > context->maxsize &&
                     !_bump(context, 1))
                     return 0;
-                Py_INCREF(o);
                 PyTuple_SET_ITEM(context->tuple,
-                                 context->size++, o);
+                                 context->size++, Py_NewRef(o));
             }
         }
     } else {
@@ -3266,8 +3251,7 @@ PyInit__tkinter(void)
         Py_DECREF(m);
         return NULL;
     }
-    Py_INCREF(o);
-    if (PyModule_AddObject(m, "TclError", o)) {
+    if (PyModule_AddObject(m, "TclError", Py_NewRef(o))) {
         Py_DECREF(o);
         Py_DECREF(m);
         return NULL;
diff --git a/Modules/_tracemalloc.c b/Modules/_tracemalloc.c
index 44a1f7b..fe73d63 100644
--- a/Modules/_tracemalloc.c
+++ b/Modules/_tracemalloc.c
@@ -347,8 +347,8 @@ tracemalloc_get_frame(_PyInterpreterFrame *pyframe, frame_t *frame)
     else {
         /* tracemalloc_filenames is responsible to keep a reference
            to the filename */
-        Py_INCREF(filename);
-        if (_Py_hashtable_set(tracemalloc_filenames, filename, NULL) < 0) {
+        if (_Py_hashtable_set(tracemalloc_filenames, Py_NewRef(filename),
+                              NULL) < 0) {
             Py_DECREF(filename);
 #ifdef TRACE_DEBUG
             tracemalloc_error("failed to intern the filename");
@@ -1085,8 +1085,7 @@ frame_to_pyobject(frame_t *frame)
     if (frame_obj == NULL)
         return NULL;
 
-    Py_INCREF(frame->filename);
-    PyTuple_SET_ITEM(frame_obj, 0, frame->filename);
+    PyTuple_SET_ITEM(frame_obj, 0, Py_NewRef(frame->filename));
 
     lineno_obj = PyLong_FromUnsignedLong(frame->lineno);
     if (lineno_obj == NULL) {
@@ -1107,8 +1106,7 @@ traceback_to_pyobject(traceback_t *traceback, _Py_hashtable_t *intern_table)
     if (intern_table != NULL) {
         frames = _Py_hashtable_get(intern_table, (const void *)traceback);
         if (frames) {
-            Py_INCREF(frames);
-            return frames;
+            return Py_NewRef(frames);
         }
     }
 
diff --git a/Modules/_typingmodule.c b/Modules/_typingmodule.c
index 8b6faa6..262dddb 100644
--- a/Modules/_typingmodule.c
+++ b/Modules/_typingmodule.c
@@ -23,8 +23,7 @@ static PyObject *
 _typing__idfunc(PyObject *module, PyObject *x)
 /*[clinic end generated code: output=63c38be4a6ec5f2c input=49f17284b43de451]*/
 {
-    Py_INCREF(x);
-    return x;
+    return Py_NewRef(x);
 }
 
 
diff --git a/Modules/_winapi.c b/Modules/_winapi.c
index 71e74d1..7a9bedb 100644
--- a/Modules/_winapi.c
+++ b/Modules/_winapi.c
@@ -291,8 +291,7 @@ _winapi_Overlapped_getbuffer_impl(OverlappedObject *self)
         return NULL;
     }
     res = self->read_buffer ? self->read_buffer : Py_None;
-    Py_INCREF(res);
-    return res;
+    return Py_NewRef(res);
 }
 
 /*[clinic input]
diff --git a/Modules/_xxsubinterpretersmodule.c b/Modules/_xxsubinterpretersmodule.c
index 9d979ef..e65137e 100644
--- a/Modules/_xxsubinterpretersmodule.c
+++ b/Modules/_xxsubinterpretersmodule.c
@@ -1722,8 +1722,7 @@ _channelid_shared(PyObject *obj, _PyCrossInterpreterData *data)
     xid->resolve = ((channelid *)obj)->resolve;
 
     data->data = xid;
-    Py_INCREF(obj);
-    data->obj = obj;
+    data->obj = Py_NewRef(obj);
     data->new_object = _channelid_from_xid;
     data->free = PyMem_Free;
     return 0;
@@ -2634,12 +2633,12 @@ PyInit__xxsubinterpreters(void)
     }
 
     /* Add other types */
-    Py_INCREF(&ChannelIDtype);
-    if (PyDict_SetItemString(ns, "ChannelID", (PyObject *)&ChannelIDtype) != 0) {
+    if (PyDict_SetItemString(ns, "ChannelID",
+                             Py_NewRef(&ChannelIDtype)) != 0) {
         return NULL;
     }
-    Py_INCREF(&_PyInterpreterID_Type);
-    if (PyDict_SetItemString(ns, "InterpreterID", (PyObject *)&_PyInterpreterID_Type) != 0) {
+    if (PyDict_SetItemString(ns, "InterpreterID",
+                             Py_NewRef(&_PyInterpreterID_Type)) != 0) {
         return NULL;
     }
 
diff --git a/Modules/arraymodule.c b/Modules/arraymodule.c
index 8013c5c..dcf510e 100644
--- a/Modules/arraymodule.c
+++ b/Modules/arraymodule.c
@@ -709,8 +709,7 @@ array_richcompare(PyObject *v, PyObject *w, int op)
             res = Py_False;
         else
             res = Py_True;
-        Py_INCREF(res);
-        return res;
+        return Py_NewRef(res);
     }
 
     if (va->ob_descr == wa->ob_descr && va->ob_descr->compareitems != NULL) {
@@ -733,8 +732,7 @@ array_richcompare(PyObject *v, PyObject *w, int op)
         default: return NULL; /* cannot happen */
         }
         PyObject *res = cmp ? Py_True : Py_False;
-        Py_INCREF(res);
-        return res;
+        return Py_NewRef(res);
     }
 
 
@@ -778,18 +776,15 @@ array_richcompare(PyObject *v, PyObject *w, int op)
             res = Py_True;
         else
             res = Py_False;
-        Py_INCREF(res);
-        return res;
+        return Py_NewRef(res);
     }
 
     /* We have an item that differs.  First, shortcuts for EQ/NE */
     if (op == Py_EQ) {
-        Py_INCREF(Py_False);
-        res = Py_False;
+        res = Py_NewRef(Py_False);
     }
     else if (op == Py_NE) {
-        Py_INCREF(Py_True);
-        res = Py_True;
+        res = Py_NewRef(Py_True);
     }
     else {
         /* Compare the final item again using the proper operator */
@@ -1060,8 +1055,7 @@ array_inplace_concat(arrayobject *self, PyObject *bb)
     }
     if (array_do_extend(state, self, bb) == -1)
         return NULL;
-    Py_INCREF(self);
-    return (PyObject *)self;
+    return Py_NewRef(self);
 }
 
 static PyObject *
@@ -1085,8 +1079,7 @@ array_inplace_repeat(arrayobject *self, Py_ssize_t n)
 
         _PyBytes_Repeat(self->ob_item, n*size, self->ob_item, size);
     }
-    Py_INCREF(self);
-    return (PyObject *)self;
+    return Py_NewRef(self);
 }
 
 
@@ -1947,9 +1940,8 @@ make_array(PyTypeObject *arraytype, char typecode, PyObject *items)
         Py_DECREF(typecode_obj);
         return NULL;
     }
-    Py_INCREF(items);
     PyTuple_SET_ITEM(new_args, 0, typecode_obj);
-    PyTuple_SET_ITEM(new_args, 1, items);
+    PyTuple_SET_ITEM(new_args, 1, Py_NewRef(items));
 
     array_obj = array_new(arraytype, new_args, NULL);
     Py_DECREF(new_args);
@@ -2219,8 +2211,7 @@ array_array___reduce_ex___impl(arrayobject *self, PyTypeObject *cls,
         return NULL;
     }
     if (dict == NULL) {
-        dict = Py_None;
-        Py_INCREF(dict);
+        dict = Py_NewRef(Py_None);
     }
 
     mformat_code = typecode_to_mformat_code(typecode);
@@ -2572,8 +2563,7 @@ array_buffer_getbuf(arrayobject *self, Py_buffer *view, int flags)
     }
 
     view->buf = (void *)self->ob_item;
-    view->obj = (PyObject*)self;
-    Py_INCREF(self);
+    view->obj = Py_NewRef(self);
     if (view->buf == NULL)
         view->buf = (void *)emptybuf;
     view->len = Py_SIZE(self) * self->ob_descr->itemsize;
@@ -2885,8 +2875,7 @@ array_iter(arrayobject *ao)
     if (it == NULL)
         return NULL;
 
-    Py_INCREF(ao);
-    it->ao = ao;
+    it->ao = (arrayobject*)Py_NewRef(ao);
     it->index = 0;
     it->getitem = ao->ob_descr->getitem;
     PyObject_GC_Track(it);
@@ -3083,8 +3072,8 @@ array_modexec(PyObject *m)
     CREATE_TYPE(m, state->ArrayIterType, &arrayiter_spec);
     Py_SET_TYPE(state->ArrayIterType, &PyType_Type);
 
-    Py_INCREF((PyObject *)state->ArrayType);
-    if (PyModule_AddObject(m, "ArrayType", (PyObject *)state->ArrayType) < 0) {
+    if (PyModule_AddObject(m, "ArrayType",
+                           Py_NewRef((PyObject *)state->ArrayType)) < 0) {
         Py_DECREF((PyObject *)state->ArrayType);
         return -1;
     }