gh-99300: Use Py_NewRef() in Python/ directory (#99317)

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

Update Parser/asdl_c.py to regenerate Python/Python-ast.c.

10 files changed, 169 insertions, 327 deletions

diff --git a/Parser/asdl_c.py b/Parser/asdl_c.py
index 6bd2e66..972d896 100755
--- a/Parser/asdl_c.py
+++ b/Parser/asdl_c.py
@@ -995,10 +995,11 @@ static PyObject* ast2obj_list(struct ast_state *state, asdl_seq *seq, PyObject*
 
 static PyObject* ast2obj_object(struct ast_state *Py_UNUSED(state), void *o)
 {
-    if (!o)
-        o = Py_None;
-    Py_INCREF((PyObject*)o);
-    return (PyObject*)o;
+    PyObject *op = (PyObject*)o;
+    if (!op) {
+        op = Py_None;
+    }
+    return Py_NewRef(op);
 }
 #define ast2obj_constant ast2obj_object
 #define ast2obj_identifier ast2obj_object
@@ -1032,8 +1033,7 @@ static int obj2ast_constant(struct ast_state *Py_UNUSED(state), PyObject* obj, P
         *out = NULL;
         return -1;
     }
-    Py_INCREF(obj);
-    *out = obj;
+    *out = Py_NewRef(obj);
     return 0;
 }
 
@@ -1301,8 +1301,7 @@ class ObjVisitor(PickleVisitor):
         self.emit("switch(o) {", 1)
         for t in sum.types:
             self.emit("case %s:" % t.name, 2)
-            self.emit("Py_INCREF(state->%s_singleton);" % t.name, 3)
-            self.emit("return state->%s_singleton;" % t.name, 3)
+            self.emit("return Py_NewRef(state->%s_singleton);" % t.name, 3)
         self.emit("}", 1)
         self.emit("Py_UNREACHABLE();", 1);
         self.emit("}", 0)
diff --git a/Python/Python-ast.c b/Python/Python-ast.c
index 2571e28..b57aca3 100644
--- a/Python/Python-ast.c
+++ b/Python/Python-ast.c
@@ -993,10 +993,11 @@ static PyObject* ast2obj_list(struct ast_state *state, asdl_seq *seq, PyObject*
 
 static PyObject* ast2obj_object(struct ast_state *Py_UNUSED(state), void *o)
 {
-    if (!o)
-        o = Py_None;
-    Py_INCREF((PyObject*)o);
-    return (PyObject*)o;
+    PyObject *op = (PyObject*)o;
+    if (!op) {
+        op = Py_None;
+    }
+    return Py_NewRef(op);
 }
 #define ast2obj_constant ast2obj_object
 #define ast2obj_identifier ast2obj_object
@@ -1030,8 +1031,7 @@ static int obj2ast_constant(struct ast_state *Py_UNUSED(state), PyObject* obj, P
         *out = NULL;
         return -1;
     }
-    Py_INCREF(obj);
-    *out = obj;
+    *out = Py_NewRef(obj);
     return 0;
 }
 
@@ -4732,14 +4732,11 @@ PyObject* ast2obj_expr_context(struct ast_state *state, expr_context_ty o)
 {
     switch(o) {
         case Load:
-            Py_INCREF(state->Load_singleton);
-            return state->Load_singleton;
+            return Py_NewRef(state->Load_singleton);
         case Store:
-            Py_INCREF(state->Store_singleton);
-            return state->Store_singleton;
+            return Py_NewRef(state->Store_singleton);
         case Del:
-            Py_INCREF(state->Del_singleton);
-            return state->Del_singleton;
+            return Py_NewRef(state->Del_singleton);
     }
     Py_UNREACHABLE();
 }
@@ -4747,11 +4744,9 @@ PyObject* ast2obj_boolop(struct ast_state *state, boolop_ty o)
 {
     switch(o) {
         case And:
-            Py_INCREF(state->And_singleton);
-            return state->And_singleton;
+            return Py_NewRef(state->And_singleton);
         case Or:
-            Py_INCREF(state->Or_singleton);
-            return state->Or_singleton;
+            return Py_NewRef(state->Or_singleton);
     }
     Py_UNREACHABLE();
 }
@@ -4759,44 +4754,31 @@ PyObject* ast2obj_operator(struct ast_state *state, operator_ty o)
 {
     switch(o) {
         case Add:
-            Py_INCREF(state->Add_singleton);
-            return state->Add_singleton;
+            return Py_NewRef(state->Add_singleton);
         case Sub:
-            Py_INCREF(state->Sub_singleton);
-            return state->Sub_singleton;
+            return Py_NewRef(state->Sub_singleton);
         case Mult:
-            Py_INCREF(state->Mult_singleton);
-            return state->Mult_singleton;
+            return Py_NewRef(state->Mult_singleton);
         case MatMult:
-            Py_INCREF(state->MatMult_singleton);
-            return state->MatMult_singleton;
+            return Py_NewRef(state->MatMult_singleton);
         case Div:
-            Py_INCREF(state->Div_singleton);
-            return state->Div_singleton;
+            return Py_NewRef(state->Div_singleton);
         case Mod:
-            Py_INCREF(state->Mod_singleton);
-            return state->Mod_singleton;
+            return Py_NewRef(state->Mod_singleton);
         case Pow:
-            Py_INCREF(state->Pow_singleton);
-            return state->Pow_singleton;
+            return Py_NewRef(state->Pow_singleton);
         case LShift:
-            Py_INCREF(state->LShift_singleton);
-            return state->LShift_singleton;
+            return Py_NewRef(state->LShift_singleton);
         case RShift:
-            Py_INCREF(state->RShift_singleton);
-            return state->RShift_singleton;
+            return Py_NewRef(state->RShift_singleton);
         case BitOr:
-            Py_INCREF(state->BitOr_singleton);
-            return state->BitOr_singleton;
+            return Py_NewRef(state->BitOr_singleton);
         case BitXor:
-            Py_INCREF(state->BitXor_singleton);
-            return state->BitXor_singleton;
+            return Py_NewRef(state->BitXor_singleton);
         case BitAnd:
-            Py_INCREF(state->BitAnd_singleton);
-            return state->BitAnd_singleton;
+            return Py_NewRef(state->BitAnd_singleton);
         case FloorDiv:
-            Py_INCREF(state->FloorDiv_singleton);
-            return state->FloorDiv_singleton;
+            return Py_NewRef(state->FloorDiv_singleton);
     }
     Py_UNREACHABLE();
 }
@@ -4804,17 +4786,13 @@ PyObject* ast2obj_unaryop(struct ast_state *state, unaryop_ty o)
 {
     switch(o) {
         case Invert:
-            Py_INCREF(state->Invert_singleton);
-            return state->Invert_singleton;
+            return Py_NewRef(state->Invert_singleton);
         case Not:
-            Py_INCREF(state->Not_singleton);
-            return state->Not_singleton;
+            return Py_NewRef(state->Not_singleton);
         case UAdd:
-            Py_INCREF(state->UAdd_singleton);
-            return state->UAdd_singleton;
+            return Py_NewRef(state->UAdd_singleton);
         case USub:
-            Py_INCREF(state->USub_singleton);
-            return state->USub_singleton;
+            return Py_NewRef(state->USub_singleton);
     }
     Py_UNREACHABLE();
 }
@@ -4822,35 +4800,25 @@ PyObject* ast2obj_cmpop(struct ast_state *state, cmpop_ty o)
 {
     switch(o) {
         case Eq:
-            Py_INCREF(state->Eq_singleton);
-            return state->Eq_singleton;
+            return Py_NewRef(state->Eq_singleton);
         case NotEq:
-            Py_INCREF(state->NotEq_singleton);
-            return state->NotEq_singleton;
+            return Py_NewRef(state->NotEq_singleton);
         case Lt:
-            Py_INCREF(state->Lt_singleton);
-            return state->Lt_singleton;
+            return Py_NewRef(state->Lt_singleton);
         case LtE:
-            Py_INCREF(state->LtE_singleton);
-            return state->LtE_singleton;
+            return Py_NewRef(state->LtE_singleton);
         case Gt:
-            Py_INCREF(state->Gt_singleton);
-            return state->Gt_singleton;
+            return Py_NewRef(state->Gt_singleton);
         case GtE:
-            Py_INCREF(state->GtE_singleton);
-            return state->GtE_singleton;
+            return Py_NewRef(state->GtE_singleton);
         case Is:
-            Py_INCREF(state->Is_singleton);
-            return state->Is_singleton;
+            return Py_NewRef(state->Is_singleton);
         case IsNot:
-            Py_INCREF(state->IsNot_singleton);
-            return state->IsNot_singleton;
+            return Py_NewRef(state->IsNot_singleton);
         case In:
-            Py_INCREF(state->In_singleton);
-            return state->In_singleton;
+            return Py_NewRef(state->In_singleton);
         case NotIn:
-            Py_INCREF(state->NotIn_singleton);
-            return state->NotIn_singleton;
+            return Py_NewRef(state->NotIn_singleton);
     }
     Py_UNREACHABLE();
 }
diff --git a/Python/bltinmodule.c b/Python/bltinmodule.c
index 2809b03..b23f52e 100644
--- a/Python/bltinmodule.c
+++ b/Python/bltinmodule.c
@@ -63,8 +63,7 @@ update_bases(PyObject *bases, PyObject *const *args, Py_ssize_t nargs)
             }
             for (j = 0; j < i; j++) {
                 base = args[j];
-                PyList_SET_ITEM(new_bases, j, base);
-                Py_INCREF(base);
+                PyList_SET_ITEM(new_bases, j, Py_NewRef(base));
             }
         }
         j = PyList_GET_SIZE(new_bases);
@@ -170,8 +169,7 @@ builtin___build_class__(PyObject *self, PyObject *const *args, Py_ssize_t nargs,
         }
         if (winner != meta) {
             Py_DECREF(meta);
-            meta = winner;
-            Py_INCREF(meta);
+            meta = Py_NewRef(winner);
         }
     }
     /* else: meta is not a class, so we cannot do the metaclass
@@ -804,8 +802,7 @@ builtin_compile_impl(PyObject *module, PyObject *source, PyObject *filename,
         goto error;
     if (is_ast) {
         if (flags & PyCF_ONLY_AST) {
-            Py_INCREF(source);
-            result = source;
+            result = Py_NewRef(source);
         }
         else {
             PyArena *arena;
@@ -1128,8 +1125,7 @@ builtin_getattr(PyObject *self, PyObject *const *args, Py_ssize_t nargs)
     if (nargs > 2) {
         if (_PyObject_LookupAttr(v, name, &result) == 0) {
             PyObject *dflt = args[2];
-            Py_INCREF(dflt);
-            return dflt;
+            return Py_NewRef(dflt);
         }
     }
     else {
@@ -1162,8 +1158,7 @@ builtin_globals_impl(PyObject *module)
     PyObject *d;
 
     d = PyEval_GetGlobals();
-    Py_XINCREF(d);
-    return d;
+    return Py_XNewRef(d);
 }
 
 
@@ -1390,12 +1385,10 @@ map_reduce(mapobject *lz, PyObject *Py_UNUSED(ignored))
     Py_ssize_t i;
     if (args == NULL)
         return NULL;
-    Py_INCREF(lz->func);
-    PyTuple_SET_ITEM(args, 0, lz->func);
+    PyTuple_SET_ITEM(args, 0, Py_NewRef(lz->func));
     for (i = 0; i<numargs; i++){
         PyObject *it = PyTuple_GET_ITEM(lz->iters, i);
-        Py_INCREF(it);
-        PyTuple_SET_ITEM(args, i+1, it);
+        PyTuple_SET_ITEM(args, i+1, Py_NewRef(it));
     }
 
     return Py_BuildValue("ON", Py_TYPE(lz), args);
@@ -1486,8 +1479,7 @@ builtin_next(PyObject *self, PyObject *const *args, Py_ssize_t nargs)
                 return NULL;
             PyErr_Clear();
         }
-        Py_INCREF(def);
-        return def;
+        return Py_NewRef(def);
     } else if (PyErr_Occurred()) {
         return NULL;
     } else {
@@ -1723,8 +1715,7 @@ builtin_locals_impl(PyObject *module)
     PyObject *d;
 
     d = PyEval_GetLocals();
-    Py_XINCREF(d);
-    return d;
+    return Py_XNewRef(d);
 }
 
 
@@ -1785,8 +1776,7 @@ min_max(PyObject *args, PyObject *kwds, int op)
         }
         /* no key function; the value is the item */
         else {
-            val = item;
-            Py_INCREF(val);
+            val = Py_NewRef(item);
         }
 
         /* maximum value and item are unset; set them */
@@ -1816,8 +1806,7 @@ min_max(PyObject *args, PyObject *kwds, int op)
     if (maxval == NULL) {
         assert(maxitem == NULL);
         if (defaultval != NULL) {
-            Py_INCREF(defaultval);
-            maxitem = defaultval;
+            maxitem = Py_NewRef(defaultval);
         } else {
             PyErr_Format(PyExc_ValueError,
                          "%s() arg is an empty sequence", name);
@@ -2737,8 +2726,7 @@ zip_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
         return NULL;
     }
     for (i=0 ; i < tuplesize ; i++) {
-        Py_INCREF(Py_None);
-        PyTuple_SET_ITEM(result, i, Py_None);
+        PyTuple_SET_ITEM(result, i, Py_NewRef(Py_None));
     }
 
     /* create zipobject structure */
diff --git a/Python/compile.c b/Python/compile.c
index 030378f..177409a 100644
--- a/Python/compile.c
+++ b/Python/compile.c
@@ -530,8 +530,7 @@ _Py_Mangle(PyObject *privateobj, PyObject *ident)
     if (privateobj == NULL || !PyUnicode_Check(privateobj) ||
         PyUnicode_READ_CHAR(ident, 0) != '_' ||
         PyUnicode_READ_CHAR(ident, 1) != '_') {
-        Py_INCREF(ident);
-        return ident;
+        return Py_NewRef(ident);
     }
     nlen = PyUnicode_GET_LENGTH(ident);
     plen = PyUnicode_GET_LENGTH(privateobj);
@@ -547,16 +546,14 @@ _Py_Mangle(PyObject *privateobj, PyObject *ident)
     if ((PyUnicode_READ_CHAR(ident, nlen-1) == '_' &&
          PyUnicode_READ_CHAR(ident, nlen-2) == '_') ||
         PyUnicode_FindChar(ident, '.', 0, nlen, 1) != -1) {
-        Py_INCREF(ident);
-        return ident; /* Don't mangle __whatever__ */
+        return Py_NewRef(ident); /* Don't mangle __whatever__ */
     }
     /* Strip leading underscores from class name */
     ipriv = 0;
     while (PyUnicode_READ_CHAR(privateobj, ipriv) == '_')
         ipriv++;
     if (ipriv == plen) {
-        Py_INCREF(ident);
-        return ident; /* Don't mangle if class is just underscores */
+        return Py_NewRef(ident); /* Don't mangle if class is just underscores */
     }
     plen -= ipriv;
 
@@ -616,8 +613,7 @@ _PyAST_Compile(mod_ty mod, PyObject *filename, PyCompilerFlags *flags,
     int merged;
     if (!compiler_init(&c))
         return NULL;
-    Py_INCREF(filename);
-    c.c_filename = filename;
+    c.c_filename = Py_NewRef(filename);
     c.c_arena = arena;
     if (!_PyFuture_FromAST(mod, filename, &c.c_future)) {
         goto finally;
@@ -859,8 +855,7 @@ compiler_set_qualname(struct compiler *c)
                     return 0;
             }
             else {
-                Py_INCREF(parent->u_qualname);
-                base = parent->u_qualname;
+                base = Py_NewRef(parent->u_qualname);
             }
         }
     }
@@ -876,8 +871,7 @@ compiler_set_qualname(struct compiler *c)
             return 0;
     }
     else {
-        Py_INCREF(u->u_name);
-        name = u->u_name;
+        name = Py_NewRef(u->u_name);
     }
     u->u_qualname = name;
 
@@ -1381,8 +1375,7 @@ merge_consts_recursive(PyObject *const_cache, PyObject *o)
     // None and Ellipsis are singleton, and key is the singleton.
     // No need to merge object and key.
     if (o == Py_None || o == Py_Ellipsis) {
-        Py_INCREF(o);
-        return o;
+        return Py_NewRef(o);
     }
 
     PyObject *key = _PyCode_ConstantKey(o);
@@ -1421,8 +1414,7 @@ merge_consts_recursive(PyObject *const_cache, PyObject *o)
                 v = u;
             }
             if (v != item) {
-                Py_INCREF(v);
-                PyTuple_SET_ITEM(o, i, v);
+                PyTuple_SET_ITEM(o, i, Py_NewRef(v));
                 Py_DECREF(item);
             }
 
@@ -1708,8 +1700,7 @@ compiler_enter_scope(struct compiler *c, identifier name,
         compiler_unit_free(u);
         return 0;
     }
-    Py_INCREF(name);
-    u->u_name = name;
+    u->u_name = Py_NewRef(name);
     u->u_varnames = list2dict(u->u_ste->ste_varnames);
     u->u_cellvars = dictbytype(u->u_ste->ste_symbols, CELL, 0, 0);
     if (!u->u_varnames || !u->u_cellvars) {
@@ -1760,8 +1751,7 @@ compiler_enter_scope(struct compiler *c, identifier name,
             return 0;
         }
         Py_DECREF(capsule);
-        u->u_private = c->u->u_private;
-        Py_XINCREF(u->u_private);
+        u->u_private = Py_XNewRef(c->u->u_private);
     }
     c->u = u;
 
@@ -2671,8 +2661,7 @@ compiler_function(struct compiler *c, stmt_ty s, int is_async)
         }
     }
     co = assemble(c, 1);
-    qualname = c->u->u_qualname;
-    Py_INCREF(qualname);
+    qualname = Py_NewRef(c->u->u_qualname);
     compiler_exit_scope(c);
     if (co == NULL) {
         Py_XDECREF(qualname);
@@ -3053,8 +3042,7 @@ compiler_lambda(struct compiler *c, expr_ty e)
         ADDOP_IN_SCOPE(c, loc, RETURN_VALUE);
         co = assemble(c, 1);
     }
-    qualname = c->u->u_qualname;
-    Py_INCREF(qualname);
+    qualname = Py_NewRef(c->u->u_qualname);
     compiler_exit_scope(c);
     if (co == NULL) {
         Py_DECREF(qualname);
@@ -3925,8 +3913,7 @@ compiler_from_import(struct compiler *c, stmt_ty s)
     /* build up the names */
     for (Py_ssize_t i = 0; i < n; i++) {
         alias_ty alias = (alias_ty)asdl_seq_GET(s->v.ImportFrom.names, i);
-        Py_INCREF(alias->name);
-        PyTuple_SET_ITEM(names, i, alias->name);
+        PyTuple_SET_ITEM(names, i, Py_NewRef(alias->name));
     }
 
     if (location_is_after(LOC(s), c->c_future.ff_location) &&
@@ -4348,8 +4335,7 @@ starunpack_helper(struct compiler *c, location loc,
         PyObject *val;
         for (Py_ssize_t i = 0; i < n; i++) {
             val = ((expr_ty)asdl_seq_GET(elts, i))->v.Constant.value;
-            Py_INCREF(val);
-            PyTuple_SET_ITEM(folded, i, val);
+            PyTuple_SET_ITEM(folded, i, Py_NewRef(val));
         }
         if (tuple && !pushed) {
             ADDOP_LOAD_CONST_NEW(c, loc, folded);
@@ -4530,8 +4516,7 @@ compiler_subdict(struct compiler *c, expr_ty e, Py_ssize_t begin, Py_ssize_t end
         }
         for (i = begin; i < end; i++) {
             key = ((expr_ty)asdl_seq_GET(e->v.Dict.keys, i))->v.Constant.value;
-            Py_INCREF(key);
-            PyTuple_SET_ITEM(keys, i - begin, key);
+            PyTuple_SET_ITEM(keys, i - begin, Py_NewRef(key));
         }
         ADDOP_LOAD_CONST_NEW(c, loc, keys);
         ADDOP_I(c, loc, BUILD_CONST_KEY_MAP, n);
@@ -5014,8 +4999,7 @@ compiler_subkwargs(struct compiler *c, location loc,
         }
         for (i = begin; i < end; i++) {
             key = ((keyword_ty) asdl_seq_GET(keywords, i))->arg;
-            Py_INCREF(key);
-            PyTuple_SET_ITEM(keys, i - begin, key);
+            PyTuple_SET_ITEM(keys, i - begin, Py_NewRef(key));
         }
         ADDOP_LOAD_CONST_NEW(c, loc, keys);
         ADDOP_I(c, loc, BUILD_CONST_KEY_MAP, n);
@@ -5053,8 +5037,7 @@ compiler_call_simple_kw_helper(struct compiler *c, location loc,
     }
     for (int i = 0; i < nkwelts; i++) {
         keyword_ty kw = asdl_seq_GET(keywords, i);
-        Py_INCREF(kw->arg);
-        PyTuple_SET_ITEM(names, i, kw->arg);
+        PyTuple_SET_ITEM(names, i, Py_NewRef(kw->arg));
     }
     Py_ssize_t arg = compiler_add_const(c, names);
     if (arg < 0) {
@@ -5490,8 +5473,7 @@ compiler_comprehension(struct compiler *c, expr_ty e, int type,
     }
 
     co = assemble(c, 1);
-    qualname = c->u->u_qualname;
-    Py_INCREF(qualname);
+    qualname = Py_NewRef(c->u->u_qualname);
     compiler_exit_scope(c);
     if (is_top_level_await && is_async_generator){
         c->u->u_ste->ste_coroutine = 1;
@@ -6170,8 +6152,7 @@ compiler_error(struct compiler *c, location loc,
     }
     PyObject *loc_obj = PyErr_ProgramTextObject(c->c_filename, loc.lineno);
     if (loc_obj == NULL) {
-        Py_INCREF(Py_None);
-        loc_obj = Py_None;
+        loc_obj = Py_NewRef(Py_None);
     }
     PyObject *args = Py_BuildValue("O(OiiOii)", msg, c->c_filename,
                                    loc.lineno, loc.col_offset + 1, loc_obj,
@@ -6605,8 +6586,7 @@ compiler_pattern_class(struct compiler *c, location *ploc,
     Py_ssize_t i;
     for (i = 0; i < nattrs; i++) {
         PyObject *name = asdl_seq_GET(kwd_attrs, i);
-        Py_INCREF(name);
-        PyTuple_SET_ITEM(attr_names, i, name);
+        PyTuple_SET_ITEM(attr_names, i, Py_NewRef(name));
     }
     ADDOP_LOAD_CONST_NEW(c, *ploc, attr_names);
     ADDOP_I(c, *ploc, MATCH_CLASS, nargs);
@@ -6815,8 +6795,7 @@ compiler_pattern_or(struct compiler *c, location *ploc,
             // for the others (they can't bind a different set of names, and
             // might need to be reordered):
             assert(control == NULL);
-            control = pc->stores;
-            Py_INCREF(control);
+            control = Py_NewRef(pc->stores);
         }
         else if (nstores != PyList_GET_SIZE(control)) {
             goto diff;
@@ -8208,10 +8187,9 @@ dict_keys_inorder(PyObject *dict, Py_ssize_t offset)
         return NULL;
     while (PyDict_Next(dict, &pos, &k, &v)) {
         i = PyLong_AS_LONG(v);
-        Py_INCREF(k);
         assert((i - offset) < size);
         assert((i - offset) >= 0);
-        PyTuple_SET_ITEM(tuple, i - offset, k);
+        PyTuple_SET_ITEM(tuple, i - offset, Py_NewRef(k));
     }
     return tuple;
 }
@@ -8233,10 +8211,9 @@ consts_dict_keys_inorder(PyObject *dict)
         if (PyTuple_CheckExact(k)) {
             k = PyTuple_GET_ITEM(k, 1);
         }
-        Py_INCREF(k);
         assert(i < size);
         assert(i >= 0);
-        PyList_SET_ITEM(consts, i, k);
+        PyList_SET_ITEM(consts, i, Py_NewRef(k));
     }
     return consts;
 }
@@ -8936,8 +8913,7 @@ get_const_value(int opcode, int oparg, PyObject *co_consts)
                         "Internal error: failed to get value of a constant");
         return NULL;
     }
-    Py_INCREF(constant);
-    return constant;
+    return Py_NewRef(constant);
 }
 
 /* Replace LOAD_CONST c1, LOAD_CONST c2 ... LOAD_CONST cn, BUILD_TUPLE n
@@ -9978,6 +9954,5 @@ PyObject *
 PyCode_Optimize(PyObject *code, PyObject* Py_UNUSED(consts),
                 PyObject *Py_UNUSED(names), PyObject *Py_UNUSED(lnotab_obj))
 {
-    Py_INCREF(code);
-    return code;
+    return Py_NewRef(code);
 }
diff --git a/Python/context.c b/Python/context.c
index ef9db6a..ee5a671 100644
--- a/Python/context.c
+++ b/Python/context.c
@@ -124,8 +124,7 @@ _PyContext_Enter(PyThreadState *ts, PyObject *octx)
     ctx->ctx_prev = (PyContext *)ts->context;  /* borrow */
     ctx->ctx_entered = 1;
 
-    Py_INCREF(ctx);
-    ts->context = (PyObject *)ctx;
+    ts->context = Py_NewRef(ctx);
     ts->context_ver++;
 
     return 0;
@@ -400,8 +399,7 @@ context_new_from_vars(PyHamtObject *vars)
         return NULL;
     }
 
-    Py_INCREF(vars);
-    ctx->ctx_vars = vars;
+    ctx->ctx_vars = (PyHamtObject*)Py_NewRef(vars);
 
     _PyObject_GC_TRACK(ctx);
     return ctx;
@@ -546,8 +544,7 @@ context_tp_subscript(PyContext *self, PyObject *key)
         PyErr_SetObject(PyExc_KeyError, key);
         return NULL;
     }
-    Py_INCREF(val);
-    return val;
+    return Py_NewRef(val);
 }
 
 static int
@@ -588,11 +585,9 @@ _contextvars_Context_get_impl(PyContext *self, PyObject *key,
         return NULL;
     }
     if (found == 0) {
-        Py_INCREF(default_value);
-        return default_value;
+        return Py_NewRef(default_value);
     }
-    Py_INCREF(val);
-    return val;
+    return Py_NewRef(val);
 }
 
 
@@ -831,11 +826,9 @@ contextvar_new(PyObject *name, PyObject *def)
         return NULL;
     }
 
-    Py_INCREF(name);
-    var->var_name = name;
+    var->var_name = Py_NewRef(name);
 
-    Py_XINCREF(def);
-    var->var_default = def;
+    var->var_default = Py_XNewRef(def);
 
     var->var_cached = NULL;
     var->var_cached_tsid = 0;
@@ -1176,8 +1169,7 @@ error:
 static PyObject *
 token_get_var(PyContextToken *self, void *Py_UNUSED(ignored))
 {
-    Py_INCREF(self->tok_var);
-    return (PyObject *)self->tok_var;
+    return Py_NewRef(self->tok_var);;
 }
 
 static PyObject *
@@ -1187,8 +1179,7 @@ token_get_old_value(PyContextToken *self, void *Py_UNUSED(ignored))
         return get_token_missing();
     }
 
-    Py_INCREF(self->tok_oldval);
-    return self->tok_oldval;
+    return Py_NewRef(self->tok_oldval);
 }
 
 static PyGetSetDef PyContextTokenType_getsetlist[] = {
@@ -1228,14 +1219,11 @@ token_new(PyContext *ctx, PyContextVar *var, PyObject *val)
         return NULL;
     }
 
-    Py_INCREF(ctx);
-    tok->tok_ctx = ctx;
+    tok->tok_ctx = (PyContext*)Py_NewRef(ctx);
 
-    Py_INCREF(var);
-    tok->tok_var = var;
+    tok->tok_var = (PyContextVar*)Py_NewRef(var);
 
-    Py_XINCREF(val);
-    tok->tok_oldval = val;
+    tok->tok_oldval = Py_XNewRef(val);
 
     tok->tok_used = 0;
 
@@ -1276,8 +1264,7 @@ static PyObject *
 get_token_missing(void)
 {
     if (_token_missing != NULL) {
-        Py_INCREF(_token_missing);
-        return _token_missing;
+        return Py_NewRef(_token_missing);
     }
 
     _token_missing = (PyObject *)PyObject_New(
@@ -1286,8 +1273,7 @@ get_token_missing(void)
         return NULL;
     }
 
-    Py_INCREF(_token_missing);
-    return _token_missing;
+    return Py_NewRef(_token_missing);
 }
 
 
diff --git a/Python/hamt.c b/Python/hamt.c
index 3aa31c6..d94d070 100644
--- a/Python/hamt.c
+++ b/Python/hamt.c
@@ -525,8 +525,7 @@ hamt_node_bitmap_new(Py_ssize_t size)
     assert(size % 2 == 0);
 
     if (size == 0 && _empty_bitmap_node != NULL) {
-        Py_INCREF(_empty_bitmap_node);
-        return (PyHamtNode *)_empty_bitmap_node;
+        return (PyHamtNode *)Py_NewRef(_empty_bitmap_node);
     }
 
     /* No freelist; allocate a new bitmap node */
@@ -550,8 +549,7 @@ hamt_node_bitmap_new(Py_ssize_t size)
         /* Since bitmap nodes are immutable, we can cache the instance
            for size=0 and reuse it whenever we need an empty bitmap node.
         */
-        _empty_bitmap_node = node;
-        Py_INCREF(_empty_bitmap_node);
+        _empty_bitmap_node = (PyHamtNode_Bitmap*)Py_NewRef(node);
     }
 
     return (PyHamtNode *)node;
@@ -577,8 +575,7 @@ hamt_node_bitmap_clone(PyHamtNode_Bitmap *node)
     }
 
     for (i = 0; i < Py_SIZE(node); i++) {
-        Py_XINCREF(node->b_array[i]);
-        clone->b_array[i] = node->b_array[i];
+        clone->b_array[i] = Py_XNewRef(node->b_array[i]);
     }
 
     clone->b_bitmap = node->b_bitmap;
@@ -603,14 +600,12 @@ hamt_node_bitmap_clone_without(PyHamtNode_Bitmap *o, uint32_t bit)
     uint32_t i;
 
     for (i = 0; i < key_idx; i++) {
-        Py_XINCREF(o->b_array[i]);
-        new->b_array[i] = o->b_array[i];
+        new->b_array[i] = Py_XNewRef(o->b_array[i]);
     }
 
     assert(Py_SIZE(o) >= 0 && Py_SIZE(o) <= 32);
     for (i = val_idx + 1; i < (uint32_t)Py_SIZE(o); i++) {
-        Py_XINCREF(o->b_array[i]);
-        new->b_array[i - 2] = o->b_array[i];
+        new->b_array[i - 2] = Py_XNewRef(o->b_array[i]);
     }
 
     new->b_bitmap = o->b_bitmap & ~bit;
@@ -643,15 +638,11 @@ hamt_node_new_bitmap_or_collision(uint32_t shift,
             return NULL;
         }
 
-        Py_INCREF(key1);
-        n->c_array[0] = key1;
-        Py_INCREF(val1);
-        n->c_array[1] = val1;
+        n->c_array[0] = Py_NewRef(key1);
+        n->c_array[1] = Py_NewRef(val1);
 
-        Py_INCREF(key2);
-        n->c_array[2] = key2;
-        Py_INCREF(val2);
-        n->c_array[3] = val2;
+        n->c_array[2] = Py_NewRef(key2);
+        n->c_array[3] = Py_NewRef(val2);
 
         return (PyHamtNode *)n;
     }
@@ -736,8 +727,7 @@ hamt_node_bitmap_assoc(PyHamtNode_Bitmap *self,
 
             if (val_or_node == (PyObject *)sub_node) {
                 Py_DECREF(sub_node);
-                Py_INCREF(self);
-                return (PyHamtNode *)self;
+                return (PyHamtNode *)Py_NewRef(self);
             }
 
             PyHamtNode_Bitmap *ret = hamt_node_bitmap_clone(self);
@@ -759,8 +749,7 @@ hamt_node_bitmap_assoc(PyHamtNode_Bitmap *self,
         if (comp_err == 1) {  /* key == key_or_null */
             if (val == val_or_node) {
                 /* we already have the same key/val pair; return self. */
-                Py_INCREF(self);
-                return (PyHamtNode *)self;
+                return (PyHamtNode *)Py_NewRef(self);
             }
 
             /* We're setting a new value for the key we had before.
@@ -769,8 +758,7 @@ hamt_node_bitmap_assoc(PyHamtNode_Bitmap *self,
             if (ret == NULL) {
                 return NULL;
             }
-            Py_INCREF(val);
-            Py_SETREF(ret->b_array[val_idx], val);
+            Py_SETREF(ret->b_array[val_idx], Py_NewRef(val));
             return (PyHamtNode *)ret;
         }
 
@@ -923,22 +911,18 @@ hamt_node_bitmap_assoc(PyHamtNode_Bitmap *self,
             /* Copy all keys/values that will be before the new key/value
                we are adding. */
             for (i = 0; i < key_idx; i++) {
-                Py_XINCREF(self->b_array[i]);
-                new_node->b_array[i] = self->b_array[i];
+                new_node->b_array[i] = Py_XNewRef(self->b_array[i]);
             }
 
             /* Set the new key/value to the new Bitmap node. */
-            Py_INCREF(key);
-            new_node->b_array[key_idx] = key;
-            Py_INCREF(val);
-            new_node->b_array[val_idx] = val;
+            new_node->b_array[key_idx] = Py_NewRef(key);
+            new_node->b_array[val_idx] = Py_NewRef(val);
 
             /* Copy all keys/values that will be after the new key/value
                we are adding. */
             assert(Py_SIZE(self) >= 0 && Py_SIZE(self) <= 32);
             for (i = key_idx; i < (uint32_t)Py_SIZE(self); i++) {
-                Py_XINCREF(self->b_array[i]);
-                new_node->b_array[i + 2] = self->b_array[i];
+                new_node->b_array[i + 2] = Py_XNewRef(self->b_array[i]);
             }
 
             new_node->b_bitmap = self->b_bitmap | bit;
@@ -1019,10 +1003,8 @@ hamt_node_bitmap_without(PyHamtNode_Bitmap *self,
                         PyObject *key = sub_tree->b_array[0];
                         PyObject *val = sub_tree->b_array[1];
 
-                        Py_INCREF(key);
-                        Py_XSETREF(clone->b_array[key_idx], key);
-                        Py_INCREF(val);
-                        Py_SETREF(clone->b_array[val_idx], val);
+                        Py_XSETREF(clone->b_array[key_idx], Py_NewRef(key));
+                        Py_SETREF(clone->b_array[val_idx], Py_NewRef(val));
 
                         Py_DECREF(sub_tree);
 
@@ -1343,14 +1325,11 @@ hamt_node_collision_assoc(PyHamtNode_Collision *self,
                 }
 
                 for (i = 0; i < Py_SIZE(self); i++) {
-                    Py_INCREF(self->c_array[i]);
-                    new_node->c_array[i] = self->c_array[i];
+                    new_node->c_array[i] = Py_NewRef(self->c_array[i]);
                 }
 
-                Py_INCREF(key);
-                new_node->c_array[i] = key;
-                Py_INCREF(val);
-                new_node->c_array[i + 1] = val;
+                new_node->c_array[i] = Py_NewRef(key);
+                new_node->c_array[i + 1] = Py_NewRef(val);
 
                 *added_leaf = 1;
                 return (PyHamtNode *)new_node;
@@ -1364,8 +1343,7 @@ hamt_node_collision_assoc(PyHamtNode_Collision *self,
 
                 if (self->c_array[val_idx] == val) {
                     /* We're setting a key/value pair that's already set. */
-                    Py_INCREF(self);
-                    return (PyHamtNode *)self;
+                    return (PyHamtNode *)Py_NewRef(self);
                 }
 
                 /* We need to replace old value for the key
@@ -1378,14 +1356,12 @@ hamt_node_collision_assoc(PyHamtNode_Collision *self,
 
                 /* Copy all elements of the old node to the new one. */
                 for (i = 0; i < Py_SIZE(self); i++) {
-                    Py_INCREF(self->c_array[i]);
-                    new_node->c_array[i] = self->c_array[i];
+                    new_node->c_array[i] = Py_NewRef(self->c_array[i]);
                 }
 
                 /* Replace the old value with the new value for the our key. */
                 Py_DECREF(new_node->c_array[val_idx]);
-                Py_INCREF(val);
-                new_node->c_array[val_idx] = val;
+                new_node->c_array[val_idx] = Py_NewRef(val);
 
                 return (PyHamtNode *)new_node;
 
@@ -1410,8 +1386,7 @@ hamt_node_collision_assoc(PyHamtNode_Collision *self,
             return NULL;
         }
         new_node->b_bitmap = hamt_bitpos(self->c_hash, shift);
-        Py_INCREF(self);
-        new_node->b_array[1] = (PyObject*) self;
+        new_node->b_array[1] = Py_NewRef(self);
 
         assoc_res = hamt_node_bitmap_assoc(
             new_node, shift, hash, key, val, added_leaf);
@@ -1473,17 +1448,13 @@ hamt_node_collision_without(PyHamtNode_Collision *self,
                 }
 
                 if (key_idx == 0) {
-                    Py_INCREF(self->c_array[2]);
-                    node->b_array[0] = self->c_array[2];
-                    Py_INCREF(self->c_array[3]);
-                    node->b_array[1] = self->c_array[3];
+                    node->b_array[0] = Py_NewRef(self->c_array[2]);
+                    node->b_array[1] = Py_NewRef(self->c_array[3]);
                 }
                 else {
                     assert(key_idx == 2);
-                    Py_INCREF(self->c_array[0]);
-                    node->b_array[0] = self->c_array[0];
-                    Py_INCREF(self->c_array[1]);
-                    node->b_array[1] = self->c_array[1];
+                    node->b_array[0] = Py_NewRef(self->c_array[0]);
+                    node->b_array[1] = Py_NewRef(self->c_array[1]);
                 }
 
                 node->b_bitmap = hamt_bitpos(hash, shift);
@@ -1504,12 +1475,10 @@ hamt_node_collision_without(PyHamtNode_Collision *self,
             /* Copy all other keys from `self` to `new` */
             Py_ssize_t i;
             for (i = 0; i < key_idx; i++) {
-                Py_INCREF(self->c_array[i]);
-                new->c_array[i] = self->c_array[i];
+                new->c_array[i] = Py_NewRef(self->c_array[i]);
             }
             for (i = key_idx + 2; i < Py_SIZE(self); i++) {
-                Py_INCREF(self->c_array[i]);
-                new->c_array[i - 2] = self->c_array[i];
+                new->c_array[i - 2] = Py_NewRef(self->c_array[i]);
             }
 
             *new_node = (PyHamtNode*)new;
@@ -1661,8 +1630,7 @@ hamt_node_array_clone(PyHamtNode_Array *node)
 
     /* Copy all elements from the current Array node to the new one. */
     for (i = 0; i < HAMT_ARRAY_NODE_SIZE; i++) {
-        Py_XINCREF(node->a_array[i]);
-        clone->a_array[i] = node->a_array[i];
+        clone->a_array[i] = (PyHamtNode*)Py_XNewRef(node->a_array[i]);
     }
 
     VALIDATE_ARRAY_NODE(clone)
@@ -1719,8 +1687,7 @@ hamt_node_array_assoc(PyHamtNode_Array *self,
         /* Copy all elements from the current Array node to the
            new one. */
         for (i = 0; i < HAMT_ARRAY_NODE_SIZE; i++) {
-            Py_XINCREF(self->a_array[i]);
-            new_node->a_array[i] = self->a_array[i];
+            new_node->a_array[i] = (PyHamtNode*)Py_XNewRef(self->a_array[i]);
         }
 
         assert(new_node->a_array[idx] == NULL);
@@ -1868,15 +1835,12 @@ hamt_node_array_without(PyHamtNode_Array *self,
                         PyObject *key = child->b_array[0];
                         PyObject *val = child->b_array[1];
 
-                        Py_INCREF(key);
-                        new->b_array[new_i] = key;
-                        Py_INCREF(val);
-                        new->b_array[new_i + 1] = val;
+                        new->b_array[new_i] = Py_NewRef(key);
+                        new->b_array[new_i + 1] = Py_NewRef(val);
                     }
                     else {
                         new->b_array[new_i] = NULL;
-                        Py_INCREF(node);
-                        new->b_array[new_i + 1] = (PyObject*)node;
+                        new->b_array[new_i + 1] = Py_NewRef(node);
                     }
                 }
                 else {
@@ -1894,8 +1858,7 @@ hamt_node_array_without(PyHamtNode_Array *self,
 
                     /* Just copy the node into our new Bitmap */
                     new->b_array[new_i] = NULL;
-                    Py_INCREF(node);
-                    new->b_array[new_i + 1] = (PyObject*)node;
+                    new->b_array[new_i + 1] = Py_NewRef(node);
                 }
 
                 new_i += 2;
@@ -2311,8 +2274,7 @@ _PyHamt_Assoc(PyHamtObject *o, PyObject *key, PyObject *val)
 
     if (new_root == o->h_root) {
         Py_DECREF(new_root);
-        Py_INCREF(o);
-        return o;
+        return (PyHamtObject*)Py_NewRef(o);
     }
 
     new_o = hamt_alloc();
@@ -2348,8 +2310,7 @@ _PyHamt_Without(PyHamtObject *o, PyObject *key)
         case W_EMPTY:
             return _PyHamt_New();
         case W_NOT_FOUND:
-            Py_INCREF(o);
-            return o;
+            return (PyHamtObject*)Py_NewRef(o);
         case W_NEWNODE: {
             assert(new_root != NULL);
 
@@ -2476,8 +2437,7 @@ _PyHamt_New(void)
     if (_empty_hamt != NULL) {
         /* HAMT is an immutable object so we can easily cache an
            empty instance. */
-        Py_INCREF(_empty_hamt);
-        return _empty_hamt;
+        return (PyHamtObject*)Py_NewRef(_empty_hamt);
     }
 
     PyHamtObject *o = hamt_alloc();
@@ -2494,8 +2454,7 @@ _PyHamt_New(void)
     o->h_count = 0;
 
     if (_empty_hamt == NULL) {
-        Py_INCREF(o);
-        _empty_hamt = o;
+        _empty_hamt = (PyHamtObject*)Py_NewRef(o);
     }
 
     return o;
@@ -2591,8 +2550,7 @@ hamt_baseiter_new(PyTypeObject *type, binaryfunc yield, PyHamtObject *o)
         return NULL;
     }
 
-    Py_INCREF(o);
-    it->hi_obj = o;
+    it->hi_obj = (PyHamtObject*)Py_NewRef(o);
     it->hi_yield = yield;
 
     hamt_iterator_init(&it->hi_iter, o->h_root);
@@ -2648,8 +2606,7 @@ PyTypeObject _PyHamtKeys_Type = {
 static PyObject *
 hamt_iter_yield_keys(PyObject *key, PyObject *val)
 {
-    Py_INCREF(key);
-    return key;
+    return Py_NewRef(key);
 }
 
 PyObject *
@@ -2672,8 +2629,7 @@ PyTypeObject _PyHamtValues_Type = {
 static PyObject *
 hamt_iter_yield_values(PyObject *key, PyObject *val)
 {
-    Py_INCREF(val);
-    return val;
+    return Py_NewRef(val);
 }
 
 PyObject *
@@ -2766,8 +2722,7 @@ hamt_tp_subscript(PyHamtObject *self, PyObject *key)
         case F_ERROR:
             return NULL;
         case F_FOUND:
-            Py_INCREF(val);
-            return val;
+            return Py_NewRef(val);
         case F_NOT_FOUND:
             PyErr_SetObject(PyExc_KeyError, key);
             return NULL;
@@ -2817,14 +2772,12 @@ hamt_py_get(PyHamtObject *self, PyObject *args)
         case F_ERROR:
             return NULL;
         case F_FOUND:
-            Py_INCREF(val);
-            return val;
+            return Py_NewRef(val);
         case F_NOT_FOUND:
             if (def == NULL) {
                 Py_RETURN_NONE;
             }
-            Py_INCREF(def);
-            return def;
+            return Py_NewRef(def);
         default:
             Py_UNREACHABLE();
     }
diff --git a/Python/import.c b/Python/import.c
index 9d35d26..2fd2d1b 100644
--- a/Python/import.c
+++ b/Python/import.c
@@ -810,8 +810,7 @@ update_code_filenames(PyCodeObject *co, PyObject *oldname, PyObject *newname)
     if (PyUnicode_Compare(co->co_filename, oldname))
         return;
 
-    Py_INCREF(newname);
-    Py_XSETREF(co->co_filename, newname);
+    Py_XSETREF(co->co_filename, Py_NewRef(newname));
 
     constants = co->co_consts;
     n = PyTuple_GET_SIZE(constants);
@@ -905,8 +904,7 @@ get_path_importer(PyThreadState *tstate, PyObject *path_importer_cache,
 
     importer = PyDict_GetItemWithError(path_importer_cache, p);
     if (importer != NULL || _PyErr_Occurred(tstate)) {
-        Py_XINCREF(importer);
-        return importer;
+        return Py_XNewRef(importer);
     }
 
     /* set path_importer_cache[p] to None to avoid recursion */
@@ -1403,8 +1401,7 @@ PyImport_ImportFrozenModuleObject(PyObject *name)
         }
     }
     else {
-        Py_INCREF(Py_None);
-        origname = Py_None;
+        origname = Py_NewRef(Py_None);
     }
     err = PyDict_SetItemString(d, "__origname__", origname);
     Py_DECREF(origname);
@@ -1516,8 +1513,7 @@ remove_importlib_frames(PyThreadState *tstate)
         if (in_importlib &&
             (always_trim ||
              _PyUnicode_EqualToASCIIString(code->co_name, remove_frames))) {
-            Py_XINCREF(next);
-            Py_XSETREF(*outer_link, next);
+            Py_XSETREF(*outer_link, Py_XNewRef(next));
             prev_link = outer_link;
         }
         else {
@@ -1813,8 +1809,7 @@ PyImport_ImportModuleLevelObject(PyObject *name, PyObject *globals,
             _PyErr_SetString(tstate, PyExc_ValueError, "Empty module name");
             goto error;
         }
-        abs_name = name;
-        Py_INCREF(abs_name);
+        abs_name = Py_NewRef(name);
     }
 
     mod = import_get_module(tstate, abs_name);
@@ -1853,8 +1848,7 @@ PyImport_ImportModuleLevelObject(PyObject *name, PyObject *globals,
 
             if (dot == -1) {
                 /* No dot in module name, simple exit */
-                final_mod = mod;
-                Py_INCREF(mod);
+                final_mod = Py_NewRef(mod);
                 goto error;
             }
 
@@ -1889,8 +1883,7 @@ PyImport_ImportModuleLevelObject(PyObject *name, PyObject *globals,
             }
         }
         else {
-            final_mod = mod;
-            Py_INCREF(mod);
+            final_mod = Py_NewRef(mod);
         }
     }
     else {
@@ -1905,8 +1898,7 @@ PyImport_ImportModuleLevelObject(PyObject *name, PyObject *globals,
                         mod, fromlist, interp->import_func, NULL);
         }
         else {
-            final_mod = mod;
-            Py_INCREF(mod);
+            final_mod = Py_NewRef(mod);
         }
     }
 
diff --git a/Python/structmember.c b/Python/structmember.c
index c7e3188..b94f512 100644
--- a/Python/structmember.c
+++ b/Python/structmember.c
@@ -49,8 +49,7 @@ PyMember_GetOne(const char *obj_addr, PyMemberDef *l)
         break;
     case T_STRING:
         if (*(char**)addr == NULL) {
-            Py_INCREF(Py_None);
-            v = Py_None;
+            v = Py_NewRef(Py_None);
         }
         else
             v = PyUnicode_FromString(*(char**)addr);
@@ -85,8 +84,7 @@ PyMember_GetOne(const char *obj_addr, PyMemberDef *l)
         v = PyLong_FromUnsignedLongLong(*(unsigned long long *)addr);
         break;
     case T_NONE:
-        v = Py_None;
-        Py_INCREF(v);
+        v = Py_NewRef(Py_None);
         break;
     default:
         PyErr_SetString(PyExc_SystemError, "bad memberdescr type");
@@ -247,9 +245,8 @@ PyMember_SetOne(char *addr, PyMemberDef *l, PyObject *v)
         break;
     case T_OBJECT:
     case T_OBJECT_EX:
-        Py_XINCREF(v);
         oldv = *(PyObject **)addr;
-        *(PyObject **)addr = v;
+        *(PyObject **)addr = Py_XNewRef(v);
         Py_XDECREF(oldv);
         break;
     case T_CHAR: {
diff --git a/Python/sysmodule.c b/Python/sysmodule.c
index 55cd059..5de684e 100644
--- a/Python/sysmodule.c
+++ b/Python/sysmodule.c
@@ -838,8 +838,7 @@ sys_getdefaultencoding_impl(PyObject *module)
 {
     _Py_DECLARE_STR(utf_8, "utf-8");
     PyObject *ret = &_Py_STR(utf_8);
-    Py_INCREF(ret);
-    return ret;
+    return Py_NewRef(ret);
 }
 
 /*[clinic input]
@@ -1068,8 +1067,7 @@ sys_gettrace_impl(PyObject *module)
 
     if (temp == NULL)
         temp = Py_None;
-    Py_INCREF(temp);
-    return temp;
+    return Py_NewRef(temp);
 }
 
 static PyObject *
@@ -1142,8 +1140,7 @@ sys_getprofile_impl(PyObject *module)
 
     if (temp == NULL)
         temp = Py_None;
-    Py_INCREF(temp);
-    return temp;
+    return Py_NewRef(temp);
 }
 
 
@@ -1368,11 +1365,8 @@ sys_get_asyncgen_hooks_impl(PyObject *module)
         finalizer = Py_None;
     }
 
-    Py_INCREF(firstiter);
-    PyStructSequence_SET_ITEM(res, 0, firstiter);
-
-    Py_INCREF(finalizer);
-    PyStructSequence_SET_ITEM(res, 1, finalizer);
+    PyStructSequence_SET_ITEM(res, 0, Py_NewRef(firstiter));
+    PyStructSequence_SET_ITEM(res, 1, Py_NewRef(finalizer));
 
     return res;
 }
@@ -1805,8 +1799,7 @@ sys_getsizeof(PyObject *self, PyObject *args, PyObject *kwds)
         /* Has a default value been given */
         if (dflt != NULL && _PyErr_ExceptionMatches(tstate, PyExc_TypeError)) {
             _PyErr_Clear(tstate);
-            Py_INCREF(dflt);
-            return dflt;
+            return Py_NewRef(dflt);
         }
         else
             return NULL;
@@ -2572,8 +2565,7 @@ _PySys_AddXOptionWithError(const wchar_t *s)
     const wchar_t *name_end = wcschr(s, L'=');
     if (!name_end) {
         name = PyUnicode_FromWideChar(s, -1);
-        value = Py_True;
-        Py_INCREF(value);
+        value = Py_NewRef(Py_True);
     }
     else {
         name = PyUnicode_FromWideChar(s, name_end - s);
@@ -3028,8 +3020,7 @@ make_emscripten_info(void)
         }
         PyStructSequence_SET_ITEM(emscripten_info, pos++, oua);
     } else {
-        Py_INCREF(Py_None);
-        PyStructSequence_SET_ITEM(emscripten_info, pos++, Py_None);
+        PyStructSequence_SET_ITEM(emscripten_info, pos++, Py_NewRef(Py_None));
     }
 
 #define SetBoolItem(flag) \
@@ -3226,8 +3217,7 @@ sys_add_xoption(PyObject *opts, const wchar_t *s)
     const wchar_t *name_end = wcschr(s, L'=');
     if (!name_end) {
         name = PyUnicode_FromWideChar(s, -1);
-        value = Py_True;
-        Py_INCREF(value);
+        value = Py_NewRef(Py_True);
     }
     else {
         name = PyUnicode_FromWideChar(s, name_end - s);
@@ -3404,8 +3394,7 @@ _PySys_Create(PyThreadState *tstate, PyObject **sysmod_p)
     if (sysdict == NULL) {
         goto error;
     }
-    Py_INCREF(sysdict);
-    interp->sysdict = sysdict;
+    interp->sysdict = Py_NewRef(sysdict);
 
     if (PyDict_SetItemString(sysdict, "modules", interp->modules) < 0) {
         goto error;
diff --git a/Python/traceback.c b/Python/traceback.c
index de658b9..2d9da0e 100644
--- a/Python/traceback.c
+++ b/Python/traceback.c
@@ -52,10 +52,8 @@ tb_create_raw(PyTracebackObject *next, PyFrameObject *frame, int lasti,
     }
     tb = PyObject_GC_New(PyTracebackObject, &PyTraceBack_Type);
     if (tb != NULL) {
-        Py_XINCREF(next);
-        tb->tb_next = next;
-        Py_XINCREF(frame);
-        tb->tb_frame = frame;
+        tb->tb_next = (PyTracebackObject*)Py_XNewRef(next);
+        tb->tb_frame = (PyFrameObject*)Py_XNewRef(frame);
         tb->tb_lasti = lasti;
         tb->tb_lineno = lineno;
         PyObject_GC_Track(tb);
@@ -106,8 +104,7 @@ tb_next_get(PyTracebackObject *self, void *Py_UNUSED(_))
     if (!ret) {
         ret = Py_None;
     }
-    Py_INCREF(ret);
-    return ret;
+    return Py_NewRef(ret);
 }
 
 static int
@@ -140,8 +137,7 @@ tb_next_set(PyTracebackObject *self, PyObject *new_next, void *Py_UNUSED(_))
     }
 
     PyObject *old_next = (PyObject*)self->tb_next;
-    Py_XINCREF(new_next);
-    self->tb_next = (PyTracebackObject *)new_next;
+    self->tb_next = (PyTracebackObject *)Py_XNewRef(new_next);
     Py_XDECREF(old_next);
 
     return 0;
@@ -522,8 +518,7 @@ display_source_line_with_margin(PyObject *f, PyObject *filename, int lineno, int
     }
 
     if (line) {
-        Py_INCREF(lineobj);
-        *line = lineobj;
+        *line = Py_NewRef(lineobj);
     }
 
     /* remove the indentation of the line */