diff --git a/Modules/cjkcodecs/multibytecodec.c b/Modules/cjkcodecs/multibytecodec.c
index 4769ab26b1b9e0..6d67fce1da0353 100644
--- a/Modules/cjkcodecs/multibytecodec.c
+++ b/Modules/cjkcodecs/multibytecodec.c
@@ -141,8 +141,7 @@ codecctx_errors_get(MultibyteStatefulCodecContext *self, void *Py_UNUSED(ignored
     else if (self->errors == ERROR_REPLACE)
         errors = "replace";
     else {
-        Py_INCREF(self->errors);
-        return self->errors;
+        return Py_NewRef(self->errors);
     }
 
     return PyUnicode_FromString(errors);
@@ -341,8 +340,7 @@ multibytecodec_encerror(MultibyteCodec *codec,
             goto errorexit;
     }
     else {
-        Py_INCREF(tobj);
-        retstr = tobj;
+        retstr = Py_NewRef(tobj);
     }
 
     assert(PyBytes_Check(retstr));
@@ -786,11 +784,9 @@ encoder_encode_stateful(MultibyteStatefulEncoderContext *ctx,
     if (ctx->pending) {
         PyObject *inbuf_tmp;
 
-        Py_INCREF(ctx->pending);
-        origpending = ctx->pending;
+        origpending = Py_NewRef(ctx->pending);
 
-        Py_INCREF(ctx->pending);
-        inbuf_tmp = ctx->pending;
+        inbuf_tmp = Py_NewRef(ctx->pending);
         PyUnicode_Append(&inbuf_tmp, unistr);
         if (inbuf_tmp == NULL)
             goto errorexit;
@@ -800,8 +796,7 @@ encoder_encode_stateful(MultibyteStatefulEncoderContext *ctx,
     else {
         origpending = NULL;
 
-        Py_INCREF(unistr);
-        inbuf = unistr;
+        inbuf = Py_NewRef(unistr);
     }
     if (PyUnicode_READY(inbuf) < 0)
         goto errorexit;
@@ -1645,8 +1640,7 @@ mbstreamreader_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
     }
 
     self->codec = ((MultibyteCodecObject *)codec)->codec;
-    self->stream = stream;
-    Py_INCREF(stream);
+    self->stream = Py_NewRef(stream);
     self->pendingsize = 0;
     self->errors = internal_error_callback(errors);
     if (self->errors == NULL)
@@ -1869,8 +1863,7 @@ mbstreamwriter_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
     }
 
     self->codec = ((MultibyteCodecObject *)codec)->codec;
-    self->stream = stream;
-    Py_INCREF(stream);
+    self->stream = Py_NewRef(stream);
     self->pending = NULL;
     self->errors = internal_error_callback(errors);
     if (self->errors == NULL)
diff --git a/Modules/gcmodule.c b/Modules/gcmodule.c
index 75832e9dd3da63..cacfad7335634c 100644
--- a/Modules/gcmodule.c
+++ b/Modules/gcmodule.c
@@ -1870,8 +1870,7 @@ gc_is_tracked(PyObject *module, PyObject *obj)
         result = Py_True;
     else
         result = Py_False;
-    Py_INCREF(result);
-    return result;
+    return Py_NewRef(result);
 }
 
 /*[clinic input]
diff --git a/Modules/getpath.c b/Modules/getpath.c
index ceacf36d8968a1..13db010649fed8 100644
--- a/Modules/getpath.c
+++ b/Modules/getpath.c
@@ -125,8 +125,7 @@ getpath_isabs(PyObject *Py_UNUSED(self), PyObject *args)
         r = _Py_isabs(path) ? Py_True : Py_False;
         PyMem_Free((void *)path);
     }
-    Py_XINCREF(r);
-    return r;
+    return Py_XNewRef(r);
 }
 
 
@@ -153,11 +152,10 @@ getpath_hassuffix(PyObject *Py_UNUSED(self), PyObject *args)
                 wcscmp(&path[len - suffixLen], suffix) != 0
 #endif
             ) {
-                r = Py_False;
+                r = Py_NewRef(Py_False);
             } else {
-                r = Py_True;
+                r = Py_NewRef(Py_True);
             }
-            Py_INCREF(r);
             PyMem_Free((void *)suffix);
         }
         PyMem_Free((void *)path);
@@ -187,8 +185,7 @@ getpath_isdir(PyObject *Py_UNUSED(self), PyObject *args)
 #endif
         PyMem_Free((void *)path);
     }
-    Py_XINCREF(r);
-    return r;
+    return Py_XNewRef(r);
 }
 
 
@@ -213,8 +210,7 @@ getpath_isfile(PyObject *Py_UNUSED(self), PyObject *args)
 #endif
         PyMem_Free((void *)path);
     }
-    Py_XINCREF(r);
-    return r;
+    return Py_XNewRef(r);
 }
 
 
@@ -247,8 +243,7 @@ getpath_isxfile(PyObject *Py_UNUSED(self), PyObject *args)
 #endif
         PyMem_Free((void *)path);
     }
-    Py_XINCREF(r);
-    return r;
+    return Py_XNewRef(r);
 }
 
 
@@ -488,8 +483,7 @@ getpath_realpath(PyObject *Py_UNUSED(self) , PyObject *args)
         goto done;
     }
     if (!S_ISLNK(st.st_mode)) {
-        Py_INCREF(pathobj);
-        r = pathobj;
+        r = Py_NewRef(pathobj);
         goto done;
     }
     wchar_t resolved[MAXPATHLEN+1];
@@ -504,8 +498,7 @@ getpath_realpath(PyObject *Py_UNUSED(self) , PyObject *args)
     return r;
 #endif
 
-    Py_INCREF(pathobj);
-    return pathobj;
+    return Py_NewRef(pathobj);
 }
 
 
@@ -591,8 +584,7 @@ wchar_to_dict(PyObject *dict, const char *key, const wchar_t *s)
             return 0;
         }
     } else {
-        u = Py_None;
-        Py_INCREF(u);
+        u = Py_NewRef(Py_None);
     }
     r = PyDict_SetItemString(dict, key, u) == 0;
     Py_DECREF(u);
@@ -617,8 +609,7 @@ decode_to_dict(PyObject *dict, const char *key, const char *s)
             return 0;
         }
     } else {
-        u = Py_None;
-        Py_INCREF(u);
+        u = Py_NewRef(Py_None);
     }
     r = PyDict_SetItemString(dict, key, u) == 0;
     Py_DECREF(u);
diff --git a/Modules/mathmodule.c b/Modules/mathmodule.c
index 46427876b8f4b5..16a2f45c8b84df 100644
--- a/Modules/mathmodule.c
+++ b/Modules/mathmodule.c
@@ -2048,8 +2048,7 @@ factorial_odd_part(unsigned long n)
     inner = PyLong_FromLong(1);
     if (inner == NULL)
         return NULL;
-    outer = inner;
-    Py_INCREF(outer);
+    outer = Py_NewRef(inner);
 
     upper = 3;
     for (i = _Py_bit_length(n) - 2; i >= 0; i--) {
@@ -3521,8 +3520,7 @@ perm_comb(PyObject *n, unsigned long long k, int iscomb)
         return PyLong_FromLong(1);
     }
     if (k == 1) {
-        Py_INCREF(n);
-        return n;
+        return Py_NewRef(n);
     }
 
     /* P(n, k) = P(n, j) * P(n-j, k-j) */
diff --git a/Modules/ossaudiodev.c b/Modules/ossaudiodev.c
index f1c126f06bd5b7..79f4ebad836c8b 100644
--- a/Modules/ossaudiodev.c
+++ b/Modules/ossaudiodev.c
@@ -534,8 +534,7 @@ oss_close(oss_audio_t *self, PyObject *unused)
 static PyObject *
 oss_self(PyObject *self, PyObject *unused)
 {
-    Py_INCREF(self);
-    return self;
+    return Py_NewRef(self);
 }
 
 static PyObject *
@@ -1135,10 +1134,8 @@ PyInit_ossaudiodev(void)
                                        NULL, NULL);
     if (OSSAudioError) {
         /* Each call to PyModule_AddObject decrefs it; compensate: */
-        Py_INCREF(OSSAudioError);
-        Py_INCREF(OSSAudioError);
-        PyModule_AddObject(m, "error", OSSAudioError);
-        PyModule_AddObject(m, "OSSAudioError", OSSAudioError);
+        PyModule_AddObject(m, "error", Py_NewRef(OSSAudioError));
+        PyModule_AddObject(m, "OSSAudioError", Py_NewRef(OSSAudioError));
     }
 
     /* Build 'control_labels' and 'control_names' lists and add them
diff --git a/Modules/overlapped.c b/Modules/overlapped.c
index deb772e9eff487..02c0f401be4c9e 100644
--- a/Modules/overlapped.c
+++ b/Modules/overlapped.c
@@ -912,8 +912,7 @@ _overlapped_Overlapped_getresult_impl(OverlappedObject *self, BOOL wait)
                 _PyBytes_Resize(&self->allocated_buffer, transferred))
                 return NULL;
 
-            Py_INCREF(self->allocated_buffer);
-            return self->allocated_buffer;
+            return Py_NewRef(self->allocated_buffer);
         case TYPE_READ_FROM:
             assert(PyBytes_CheckExact(self->read_from.allocated_buffer));
 
@@ -940,14 +939,12 @@ _overlapped_Overlapped_getresult_impl(OverlappedObject *self, BOOL wait)
             }
 
             // first item: message
-            Py_INCREF(self->read_from.allocated_buffer);
             PyTuple_SET_ITEM(self->read_from.result, 0,
-                             self->read_from.allocated_buffer);
+                             Py_NewRef(self->read_from.allocated_buffer));
             // second item: address
             PyTuple_SET_ITEM(self->read_from.result, 1, addr);
 
-            Py_INCREF(self->read_from.result);
-            return self->read_from.result;
+            return Py_NewRef(self->read_from.result);
         case TYPE_READ_FROM_INTO:
             // unparse the address
             addr = unparse_address((SOCKADDR*)&self->read_from_into.address,
@@ -970,8 +967,7 @@ _overlapped_Overlapped_getresult_impl(OverlappedObject *self, BOOL wait)
             // second item: address
             PyTuple_SET_ITEM(self->read_from_into.result, 1, addr);
 
-            Py_INCREF(self->read_from_into.result);
-            return self->read_from_into.result;
+            return Py_NewRef(self->read_from_into.result);
         default:
             return PyLong_FromUnsignedLong((unsigned long) transferred);
     }
diff --git a/Modules/posixmodule.c b/Modules/posixmodule.c
index d863f9f63248f5..5968c1940e76f4 100644
--- a/Modules/posixmodule.c
+++ b/Modules/posixmodule.c
@@ -1221,8 +1221,7 @@ path_converter(PyObject *o, void *p)
 #endif
     }
     else if (is_bytes) {
-        bytes = o;
-        Py_INCREF(bytes);
+        bytes = Py_NewRef(o);
     }
     else if (is_index) {
         if (!_fd_converter(o, &path->fd)) {
@@ -2240,8 +2239,7 @@ statresult_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
     for (i = 7; i <= 9; i++) {
         if (result->ob_item[i+3] == Py_None) {
             Py_DECREF(Py_None);
-            Py_INCREF(result->ob_item[i]);
-            result->ob_item[i+3] = result->ob_item[i];
+            result->ob_item[i+3] = Py_NewRef(result->ob_item[i]);
         }
     }
     return (PyObject*)result;
@@ -6888,8 +6886,7 @@ os_sched_param_impl(PyTypeObject *type, PyObject *sched_priority)
     res = PyStructSequence_New(type);
     if (!res)
         return NULL;
-    Py_INCREF(sched_priority);
-    PyStructSequence_SET_ITEM(res, 0, sched_priority);
+    PyStructSequence_SET_ITEM(res, 0, Py_NewRef(sched_priority));
     return res;
 }
 
@@ -8017,8 +8014,7 @@ os_kill_impl(PyObject *module, pid_t pid, Py_ssize_t signal)
         err = GetLastError();
         result = PyErr_SetFromWindowsErr(err);
     } else {
-        Py_INCREF(Py_None);
-        result = Py_None;
+        result = Py_NewRef(Py_None);
     }
 
     CloseHandle(handle);
@@ -8647,7 +8643,7 @@ os_unshare_impl(PyObject *module, int flags)
     if (res != 0) {
         return posix_error();
     }
-    
+
     Py_RETURN_NONE;
 }
 #endif
@@ -13693,8 +13689,7 @@ DirEntry_get_lstat(PyTypeObject *defining_class, DirEntry *self)
         self->lstat = DirEntry_fetch_stat(module, self, 0);
 #endif
     }
-    Py_XINCREF(self->lstat);
-    return self->lstat;
+    return Py_XNewRef(self->lstat);
 }
 
 /*[clinic input]
@@ -13730,8 +13725,7 @@ os_DirEntry_stat_impl(DirEntry *self, PyTypeObject *defining_class,
         }
     }
 
-    Py_XINCREF(self->stat);
-    return self->stat;
+    return Py_XNewRef(self->stat);
 }
 
 /* Set exception and return -1 on error, 0 for False, 1 for True */
@@ -13905,8 +13899,7 @@ static PyObject *
 os_DirEntry___fspath___impl(DirEntry *self)
 /*[clinic end generated code: output=6dd7f7ef752e6f4f input=3c49d0cf38df4fac]*/
 {
-    Py_INCREF(self->path);
-    return self->path;
+    return Py_NewRef(self->path);
 }
 
 static PyMemberDef DirEntry_members[] = {
@@ -14114,8 +14107,7 @@ DirEntry_from_posix_info(PyObject *module, path_t *path, const char *name,
         goto error;
 
     if (path->fd != -1) {
-        entry->path = entry->name;
-        Py_INCREF(entry->path);
+        entry->path = Py_NewRef(entry->name);
     }
     else if (!entry->path)
         goto error;
@@ -14306,8 +14298,7 @@ ScandirIterator_close(ScandirIterator *self, PyObject *args)
 static PyObject *
 ScandirIterator_enter(PyObject *self, PyObject *args)
 {
-    Py_INCREF(self);
-    return self;
+    return Py_NewRef(self);
 }
 
 static PyObject *
@@ -14515,8 +14506,7 @@ PyOS_FSPath(PyObject *path)
     PyObject *path_repr = NULL;
 
     if (PyUnicode_Check(path) || PyBytes_Check(path)) {
-        Py_INCREF(path);
-        return path;
+        return Py_NewRef(path);
     }
 
     func = _PyObject_LookupSpecial(path, &_Py_ID(__fspath__));
@@ -15881,8 +15871,7 @@ posixmodule_exec(PyObject *m)
     if (setup_confname_tables(m))
         return -1;
 
-    Py_INCREF(PyExc_OSError);
-    PyModule_AddObject(m, "error", PyExc_OSError);
+    PyModule_AddObject(m, "error", Py_NewRef(PyExc_OSError));
 
 #if defined(HAVE_WAITID) && !defined(__APPLE__)
     waitid_result_desc.name = MODNAME ".waitid_result";
@@ -15890,8 +15879,7 @@ posixmodule_exec(PyObject *m)
     if (WaitidResultType == NULL) {
         return -1;
     }
-    Py_INCREF(WaitidResultType);
-    PyModule_AddObject(m, "waitid_result", WaitidResultType);
+    PyModule_AddObject(m, "waitid_result", Py_NewRef(WaitidResultType));
     state->WaitidResultType = WaitidResultType;
 #endif
 
@@ -15903,8 +15891,7 @@ posixmodule_exec(PyObject *m)
     if (StatResultType == NULL) {
         return -1;
     }
-    Py_INCREF(StatResultType);
-    PyModule_AddObject(m, "stat_result", StatResultType);
+    PyModule_AddObject(m, "stat_result", Py_NewRef(StatResultType));
     state->StatResultType = StatResultType;
     structseq_new = ((PyTypeObject *)StatResultType)->tp_new;
     ((PyTypeObject *)StatResultType)->tp_new = statresult_new;
@@ -15914,8 +15901,7 @@ posixmodule_exec(PyObject *m)
     if (StatVFSResultType == NULL) {
         return -1;
     }
-    Py_INCREF(StatVFSResultType);
-    PyModule_AddObject(m, "statvfs_result", StatVFSResultType);
+    PyModule_AddObject(m, "statvfs_result", Py_NewRef(StatVFSResultType));
     state->StatVFSResultType = StatVFSResultType;
 #ifdef NEED_TICKS_PER_SECOND
 #  if defined(HAVE_SYSCONF) && defined(_SC_CLK_TCK)
@@ -15933,8 +15919,7 @@ posixmodule_exec(PyObject *m)
     if (SchedParamType == NULL) {
         return -1;
     }
-    Py_INCREF(SchedParamType);
-    PyModule_AddObject(m, "sched_param", SchedParamType);
+    PyModule_AddObject(m, "sched_param", Py_NewRef(SchedParamType));
     state->SchedParamType = SchedParamType;
     ((PyTypeObject *)SchedParamType)->tp_new = os_sched_param;
 #endif
@@ -15944,8 +15929,7 @@ posixmodule_exec(PyObject *m)
     if (TerminalSizeType == NULL) {
         return -1;
     }
-    Py_INCREF(TerminalSizeType);
-    PyModule_AddObject(m, "terminal_size", TerminalSizeType);
+    PyModule_AddObject(m, "terminal_size", Py_NewRef(TerminalSizeType));
     state->TerminalSizeType = TerminalSizeType;
 
     /* initialize scandir types */
@@ -15959,8 +15943,7 @@ posixmodule_exec(PyObject *m)
     if (DirEntryType == NULL) {
         return -1;
     }
-    Py_INCREF(DirEntryType);
-    PyModule_AddObject(m, "DirEntry", DirEntryType);
+    PyModule_AddObject(m, "DirEntry", Py_NewRef(DirEntryType));
     state->DirEntryType = DirEntryType;
 
     times_result_desc.name = MODNAME ".times_result";
@@ -15968,16 +15951,15 @@ posixmodule_exec(PyObject *m)
     if (TimesResultType == NULL) {
         return -1;
     }
-    Py_INCREF(TimesResultType);
-    PyModule_AddObject(m, "times_result", TimesResultType);
+    PyModule_AddObject(m, "times_result", Py_NewRef(TimesResultType));
     state->TimesResultType = TimesResultType;
 
     PyTypeObject *UnameResultType = PyStructSequence_NewType(&uname_result_desc);
     if (UnameResultType == NULL) {
         return -1;
     }
-    Py_INCREF(UnameResultType);
-    PyModule_AddObject(m, "uname_result", (PyObject *)UnameResultType);
+    ;
+    PyModule_AddObject(m, "uname_result", Py_NewRef(UnameResultType));
     state->UnameResultType = (PyObject *)UnameResultType;
 
     if ((state->billion = PyLong_FromLong(1000000000)) == NULL)
diff --git a/Modules/pyexpat.c b/Modules/pyexpat.c
index 70222adc242068..0e0a9cf7cc2c5c 100644
--- a/Modules/pyexpat.c
+++ b/Modules/pyexpat.c
@@ -959,8 +959,7 @@ pyexpat_xmlparser_ExternalEntityParserCreate_impl(xmlparseobject *self,
     new_parser->itself = XML_ExternalEntityParserCreate(self->itself, context,
                                                         encoding);
     new_parser->handlers = 0;
-    new_parser->intern = self->intern;
-    Py_XINCREF(new_parser->intern);
+    new_parser->intern = Py_XNewRef(self->intern);
 
     if (self->buffer != NULL) {
         new_parser->buffer = PyMem_Malloc(new_parser->buffer_size);
@@ -991,8 +990,7 @@ pyexpat_xmlparser_ExternalEntityParserCreate_impl(xmlparseobject *self,
     for (i = 0; handler_info[i].name != NULL; i++) {
         PyObject *handler = self->handlers[i];
         if (handler != NULL) {
-            Py_INCREF(handler);
-            new_parser->handlers[i] = handler;
+            new_parser->handlers[i] = Py_NewRef(handler);
             handler_info[i].setter(new_parser->itself,
                                    handler_info[i].handler);
         }
@@ -1148,8 +1146,7 @@ newxmlparseobject(pyexpat_state *state, const char *encoding,
     self->in_callback = 0;
     self->ns_prefixes = 0;
     self->handlers = NULL;
-    self->intern = intern;
-    Py_XINCREF(self->intern);
+    self->intern = Py_XNewRef(intern);
 
     /* namespace_separator is either NULL or contains one char + \0 */
     self->itself = XML_ParserCreate_MM(encoding, &ExpatMemoryHandler,
@@ -1232,8 +1229,7 @@ xmlparse_handler_getter(xmlparseobject *self, struct HandlerInfo *hi)
     PyObject *result = self->handlers[handlernum];
     if (result == NULL)
         result = Py_None;
-    Py_INCREF(result);
-    return result;
+    return Py_NewRef(result);
 }
 
 static int
@@ -1794,15 +1790,13 @@ add_errors_module(PyObject *mod)
         goto error;
     }
 
-    Py_INCREF(codes_dict);
-    if (PyModule_AddObject(errors_module, "codes", codes_dict) < 0) {
+    if (PyModule_AddObject(errors_module, "codes", Py_NewRef(codes_dict)) < 0) {
         Py_DECREF(codes_dict);
         goto error;
     }
     Py_CLEAR(codes_dict);
 
-    Py_INCREF(rev_codes_dict);
-    if (PyModule_AddObject(errors_module, "messages", rev_codes_dict) < 0) {
+    if (PyModule_AddObject(errors_module, "messages", Py_NewRef(rev_codes_dict)) < 0) {
         Py_DECREF(rev_codes_dict);
         goto error;
     }
diff --git a/Modules/readline.c b/Modules/readline.c
index 27b89de7279464..fdb6356e1c84b5 100644
--- a/Modules/readline.c
+++ b/Modules/readline.c
@@ -402,8 +402,7 @@ set_hook(const char *funcname, PyObject **hook_var, PyObject *function)
         Py_CLEAR(*hook_var);
     }
     else if (PyCallable_Check(function)) {
-        Py_INCREF(function);
-        Py_XSETREF(*hook_var, function);
+        Py_XSETREF(*hook_var, Py_NewRef(function));
     }
     else {
         PyErr_Format(PyExc_TypeError,
@@ -524,8 +523,7 @@ static PyObject *
 readline_get_begidx_impl(PyObject *module)
 /*[clinic end generated code: output=362616ee8ed1b2b1 input=e083b81c8eb4bac3]*/
 {
-    Py_INCREF(readlinestate_global->begidx);
-    return readlinestate_global->begidx;
+    return Py_NewRef(readlinestate_global->begidx);
 }
 
 /* Get the ending index for the scope of the tab-completion */
@@ -540,8 +538,7 @@ static PyObject *
 readline_get_endidx_impl(PyObject *module)
 /*[clinic end generated code: output=7f763350b12d7517 input=d4c7e34a625fd770]*/
 {
-    Py_INCREF(readlinestate_global->endidx);
-    return readlinestate_global->endidx;
+    return Py_NewRef(readlinestate_global->endidx);
 }
 
 /* Set the tab-completion word-delimiters that readline uses */
@@ -784,8 +781,7 @@ readline_get_completer_impl(PyObject *module)
     if (readlinestate_global->completer == NULL) {
         Py_RETURN_NONE;
     }
-    Py_INCREF(readlinestate_global->completer);
-    return readlinestate_global->completer;
+    return Py_NewRef(readlinestate_global->completer);
 }
 
 /* Private function to get current length of history.  XXX It may be
diff --git a/Modules/socketmodule.c b/Modules/socketmodule.c
index e99dfc643f94fc..4ecb88cef7224e 100644
--- a/Modules/socketmodule.c
+++ b/Modules/socketmodule.c
@@ -4110,8 +4110,7 @@ makeval_recvmsg(ssize_t received, void *data)
 
     if (received < PyBytes_GET_SIZE(*buf))
         _PyBytes_Resize(buf, received);
-    Py_XINCREF(*buf);
-    return *buf;
+    return Py_XNewRef(*buf);
 }
 
 /* s.recvmsg(bufsize[, ancbufsize[, flags]]) method */
@@ -4390,8 +4389,7 @@ sock_sendall(PySocketSockObject *s, PyObject *args)
     } while (len > 0);
     PyBuffer_Release(&pbuf);
 
-    Py_INCREF(Py_None);
-    res = Py_None;
+    res = Py_NewRef(Py_None);
 
 done:
     PyBuffer_Release(&pbuf);
@@ -7346,29 +7344,22 @@ PyInit__socket(void)
     if (m == NULL)
         return NULL;
 
-    Py_INCREF(PyExc_OSError);
-    PyModule_AddObject(m, "error", PyExc_OSError);
+    PyModule_AddObject(m, "error", Py_NewRef(PyExc_OSError));
     socket_herror = PyErr_NewException("socket.herror",
                                        PyExc_OSError, NULL);
     if (socket_herror == NULL)
         return NULL;
-    Py_INCREF(socket_herror);
-    PyModule_AddObject(m, "herror", socket_herror);
+    PyModule_AddObject(m, "herror", Py_NewRef(socket_herror));
     socket_gaierror = PyErr_NewException("socket.gaierror", PyExc_OSError,
         NULL);
     if (socket_gaierror == NULL)
         return NULL;
-    Py_INCREF(socket_gaierror);
-    PyModule_AddObject(m, "gaierror", socket_gaierror);
+    PyModule_AddObject(m, "gaierror", Py_NewRef(socket_gaierror));
     PyModule_AddObjectRef(m, "timeout", PyExc_TimeoutError);
 
-    Py_INCREF((PyObject *)&sock_type);
-    if (PyModule_AddObject(m, "SocketType",
-                           (PyObject *)&sock_type) != 0)
+    if (PyModule_AddObject(m, "SocketType", Py_NewRef(&sock_type)) != 0)
         return NULL;
-    Py_INCREF((PyObject *)&sock_type);
-    if (PyModule_AddObject(m, "socket",
-                           (PyObject *)&sock_type) != 0)
+    if (PyModule_AddObject(m, "socket", Py_NewRef(&sock_type)) != 0)
         return NULL;
 
 #ifdef ENABLE_IPV6
@@ -7376,8 +7367,7 @@ PyInit__socket(void)
 #else
     has_ipv6 = Py_False;
 #endif
-    Py_INCREF(has_ipv6);
-    PyModule_AddObject(m, "has_ipv6", has_ipv6);
+    PyModule_AddObject(m, "has_ipv6", Py_NewRef(has_ipv6));
 
     /* Export C API */
     PySocketModule_APIObject *capi = sock_get_api();