gh-99300: Replace Py_INCREF() with Py_NewRef() (#99530)

Replace Py_INCREF() and Py_XINCREF() using a cast with Py_NewRef()
and Py_XNewRef().

Objects/dictobject.c

@@ -1883,13 +1883,11 @@ _PyDict_SetItem_KnownHash(PyObject *op, PyObject *key, PyObject *value,
     assert(hash != -1);
     mp = (PyDictObject *)op;
 
-    Py_INCREF(key);
-    Py_INCREF(value);
     if (mp->ma_keys == Py_EMPTY_KEYS) {
-        return insert_to_emptydict(mp, key, hash, value);
+        return insert_to_emptydict(mp, Py_NewRef(key), hash, Py_NewRef(value));
     }
     /* insertdict() handles any resizing that might be necessary */
-    return insertdict(mp, key, hash, value);
+    return insertdict(mp, Py_NewRef(key), hash, Py_NewRef(value));
 }
 
 static void
@@ -2197,9 +2195,8 @@ _PyDict_Pop_KnownHash(PyObject *dict, PyObject *key, Py_hash_t hash, PyObject *d
         return NULL;
     }
     assert(old_value != NULL);
-    Py_INCREF(old_value);
     uint64_t new_version = _PyDict_NotifyEvent(PyDict_EVENT_DELETED, mp, key, NULL);
-    delitem_common(mp, hash, ix, old_value, new_version);
+    delitem_common(mp, hash, ix, Py_NewRef(old_value), new_version);
 
     ASSERT_CONSISTENT(mp);
     return old_value;

Objects/funcobject.c

@@ -47,9 +47,8 @@ PyFunction_NewWithQualName(PyObject *code, PyObject *globals, PyObject *qualname
 
     PyCodeObject *code_obj = (PyCodeObject *)Py_NewRef(code);
 
-    PyObject *name = code_obj->co_name;
+    assert(code_obj->co_name != NULL);
-    assert(name != NULL);
+    PyObject *name = Py_NewRef(code_obj->co_name);
-    Py_INCREF(name);
 
     if (!qualname) {
         qualname = code_obj->co_qualname;
@@ -525,10 +524,7 @@ func_get_annotations(PyFunctionObject *op, void *Py_UNUSED(ignored))
             return NULL;
     }
     PyObject *d = func_get_annotation_dict(op);
-    if (d) {
+    return Py_XNewRef(d);
-        Py_INCREF(d);
-    }
-    return d;
 }
 
 static int

Objects/genobject.c

@@ -341,8 +341,7 @@ _PyGen_yf(PyGenObject *gen)
             /* Not in a yield from */
             return NULL;
         }
-        yf = _PyFrame_StackPeek(frame);
+        yf = Py_NewRef(_PyFrame_StackPeek(frame));
-        Py_INCREF(yf);
     }
 
     return yf;
@@ -494,8 +493,7 @@ throw_here:
             /* Normalize to raise <class>, <instance> */
             Py_XDECREF(val);
             val = typ;
-            typ = PyExceptionInstance_Class(typ);
+            typ = Py_NewRef(PyExceptionInstance_Class(typ));
-            Py_INCREF(typ);
 
             if (tb == NULL)
                 /* Returns NULL if there's no traceback */

Objects/namespaceobject.c

@@ -85,9 +85,8 @@ namespace_repr(PyObject *ns)
     if (pairs == NULL)
         goto error;
 
-    d = ((_PyNamespaceObject *)ns)->ns_dict;
+    assert(((_PyNamespaceObject *)ns)->ns_dict != NULL);
-    assert(d != NULL);
+    d = Py_NewRef(((_PyNamespaceObject *)ns)->ns_dict);
-    Py_INCREF(d);
 
     keys = PyDict_Keys(d);
     if (keys == NULL)

Objects/odictobject.c

@@ -1114,8 +1114,7 @@ OrderedDict_popitem_impl(PyODictObject *self, int last)
     }
 
     node = last ? _odict_LAST(self) : _odict_FIRST(self);
-    key = _odictnode_KEY(node);
+    key = Py_NewRef(_odictnode_KEY(node));
-    Py_INCREF(key);
     value = _odict_popkey_hash((PyObject *)self, key, NULL, _odictnode_HASH(node));
     if (value == NULL)
         return NULL;

Objects/rangeobject.c

@@ -936,10 +936,8 @@ longrangeiter_reduce(longrangeiterobject *r, PyObject *Py_UNUSED(ignored))
     Py_DECREF(product);
     if (stop ==  NULL)
         return NULL;
-    Py_INCREF(r->start);
-    Py_INCREF(r->step);
     range =  (PyObject*)make_range_object(&PyRange_Type,
-                               r->start, stop, r->step);
+                               Py_NewRef(r->start), stop, Py_NewRef(r->step));
     if (range == NULL) {
         Py_DECREF(r->start);
         Py_DECREF(stop);

Objects/typeobject.c

@@ -5437,8 +5437,7 @@ object_getstate_default(PyObject *obj, int required)
         for (i = 0; i < slotnames_size; i++) {
             PyObject *name, *value;
 
-            name = PyList_GET_ITEM(slotnames, i);
+            name = Py_NewRef(PyList_GET_ITEM(slotnames, i));
-            Py_INCREF(name);
             if (_PyObject_LookupAttr(obj, name, &value) < 0) {
                 Py_DECREF(name);
                 goto error;
@@ -5570,10 +5569,8 @@ _PyObject_GetNewArguments(PyObject *obj, PyObject **args, PyObject **kwargs)
             Py_DECREF(newargs);
             return -1;
         }
-        *args = PyTuple_GET_ITEM(newargs, 0);
+        *args = Py_NewRef(PyTuple_GET_ITEM(newargs, 0));
-        Py_INCREF(*args);
+        *kwargs = Py_NewRef(PyTuple_GET_ITEM(newargs, 1));
-        *kwargs = PyTuple_GET_ITEM(newargs, 1);
-        Py_INCREF(*kwargs);
         Py_DECREF(newargs);
 
         /* XXX We should perhaps allow None to be passed here. */
@@ -9601,8 +9598,7 @@ super_init_impl(PyObject *self, PyTypeObject *type, PyObject *obj) {
             return -1;
         Py_INCREF(obj);
     }
-    Py_INCREF(type);
+    Py_XSETREF(su->type, Py_NewRef(type));
-    Py_XSETREF(su->type, type);
     Py_XSETREF(su->obj, obj);
     Py_XSETREF(su->obj_type, obj_type);
     return 0;

Objects/unionobject.c

@@ -295,8 +295,7 @@ union_getitem(PyObject *self, PyObject *item)
         res = make_union(newargs);
     }
     else {
-        res = PyTuple_GET_ITEM(newargs, 0);
+        res = Py_NewRef(PyTuple_GET_ITEM(newargs, 0));
-        Py_INCREF(res);
         for (Py_ssize_t iarg = 1; iarg < nargs; iarg++) {
             PyObject *arg = PyTuple_GET_ITEM(newargs, iarg);
             Py_SETREF(res, PyNumber_Or(res, arg));

Python/bltinmodule.c

@@ -2402,8 +2402,7 @@ builtin_vars(PyObject *self, PyObject *args)
     if (!PyArg_UnpackTuple(args, "vars", 0, 1, &v))
         return NULL;
     if (v == NULL) {
-        d = PyEval_GetLocals();
+        d = Py_XNewRef(PyEval_GetLocals());
-        Py_XINCREF(d);
     }
     else {
         if (_PyObject_LookupAttr(v, &_Py_ID(__dict__), &d) == 0) {

Python/codecs.c

@@ -428,8 +428,7 @@ _PyCodec_EncodeInternal(PyObject *object,
                         "encoder must return a tuple (object, integer)");
         goto onError;
     }
-    v = PyTuple_GET_ITEM(result,0);
+    v = Py_NewRef(PyTuple_GET_ITEM(result,0));
-    Py_INCREF(v);
     /* We don't check or use the second (integer) entry. */
 
     Py_DECREF(args);
@@ -473,8 +472,7 @@ _PyCodec_DecodeInternal(PyObject *object,
                         "decoder must return a tuple (object,integer)");
         goto onError;
     }
-    v = PyTuple_GET_ITEM(result,0);
+    v = Py_NewRef(PyTuple_GET_ITEM(result,0));
-    Py_INCREF(v);
     /* We don't check or use the second (integer) entry. */
 
     Py_DECREF(args);
@@ -569,8 +567,7 @@ PyObject *codec_getitem_checked(const char *encoding,
     if (codec == NULL)
         return NULL;
 
-    v = PyTuple_GET_ITEM(codec, index);
+    v = Py_NewRef(PyTuple_GET_ITEM(codec, index));
-    Py_INCREF(v);
     Py_DECREF(codec);
     return v;
 }

Python/compile.c

@@ -1459,8 +1459,7 @@ merge_consts_recursive(PyObject *const_cache, PyObject *o)
             }
             PyObject *u;
             if (PyTuple_CheckExact(k)) {
-                u = PyTuple_GET_ITEM(k, 1);
+                u = Py_NewRef(PyTuple_GET_ITEM(k, 1));
-                Py_INCREF(u);
                 Py_DECREF(k);
             }
             else {
@@ -2732,8 +2731,7 @@ compiler_class(struct compiler *c, stmt_ty s)
     {
         location loc = LOCATION(firstlineno, firstlineno, 0, 0);
         /* use the class name for name mangling */
-        Py_INCREF(s->v.ClassDef.name);
+        Py_XSETREF(c->u->u_private, Py_NewRef(s->v.ClassDef.name));
-        Py_XSETREF(c->u->u_private, s->v.ClassDef.name);
         /* load (global) __name__ ... */
         if (!compiler_nameop(c, loc, &_Py_ID(__name__), Load)) {
             compiler_exit_scope(c);

Python/errors.c

@@ -178,8 +178,7 @@ _PyErr_SetObject(PyThreadState *tstate, PyObject *exception, PyObject *value)
     }
     if (value != NULL && PyExceptionInstance_Check(value))
         tb = PyException_GetTraceback(value);
-    Py_XINCREF(exception);
+    _PyErr_Restore(tstate, Py_XNewRef(exception), value, tb);
-    _PyErr_Restore(tstate, exception, value, tb);
 }
 
 void
@@ -489,13 +488,9 @@ _PyErr_GetExcInfo(PyThreadState *tstate,
 {
     _PyErr_StackItem *exc_info = _PyErr_GetTopmostException(tstate);
 
-    *p_type = get_exc_type(exc_info->exc_value);
+    *p_type = Py_XNewRef(get_exc_type(exc_info->exc_value));
-    *p_value = exc_info->exc_value;
+    *p_value = Py_XNewRef(exc_info->exc_value);
-    *p_traceback = get_exc_traceback(exc_info->exc_value);
+    *p_traceback = Py_XNewRef(get_exc_traceback(exc_info->exc_value));
-
-    Py_XINCREF(*p_type);
-    Py_XINCREF(*p_value);
-    Py_XINCREF(*p_traceback);
 }
 
 PyObject*
@@ -674,9 +669,9 @@ _PyErr_FormatVFromCause(PyThreadState *tstate, PyObject *exception,
 
     _PyErr_Fetch(tstate, &exc, &val2, &tb);
     _PyErr_NormalizeException(tstate, &exc, &val2, &tb);
-    Py_INCREF(val);
+    PyException_SetCause(val2, Py_NewRef(val));
-    PyException_SetCause(val2, val);
+    PyException_SetContext(val2, Py_NewRef(val));
-    PyException_SetContext(val2, val);
+    Py_DECREF(val);
     _PyErr_Restore(tstate, exc, val2, tb);
 
     return NULL;
@@ -1165,9 +1160,7 @@ PyErr_NewException(const char *name, PyObject *base, PyObject *dict)
             goto failure;
     }
     if (PyTuple_Check(base)) {
-        bases = base;
+        bases = Py_NewRef(base);
-        /* INCREF as we create a new ref in the else branch */
-        Py_INCREF(bases);
     } else {
         bases = PyTuple_Pack(1, base);
         if (bases == NULL)

Python/hamt.c

@@ -838,8 +838,7 @@ hamt_node_bitmap_assoc(PyHamtNode_Bitmap *self,
 
                     if (self->b_array[j] == NULL) {
                         new_node->a_array[i] =
-                            (PyHamtNode *)self->b_array[j + 1];
+                            (PyHamtNode *)Py_NewRef(self->b_array[j + 1]);
-                        Py_INCREF(new_node->a_array[i]);
                     }
                     else {
                         int32_t rehash = hamt_hash(self->b_array[j]);

Python/import.c

@@ -625,8 +625,7 @@ import_add_module(PyThreadState *tstate, PyObject *name)
 
     PyObject *m;
     if (PyDict_CheckExact(modules)) {
-        m = PyDict_GetItemWithError(modules, name);
+        m = Py_XNewRef(PyDict_GetItemWithError(modules, name));
-        Py_XINCREF(m);
     }
     else {
         m = PyObject_GetItem(modules, name);

Python/marshal.c

@@ -326,8 +326,8 @@ w_ref(PyObject *v, char *flag, WFILE *p)
             goto err;
         }
         w = (int)s;
-        Py_INCREF(v);
+        if (_Py_hashtable_set(p->hashtable, Py_NewRef(v),
-        if (_Py_hashtable_set(p->hashtable, v, (void *)(uintptr_t)w) < 0) {
+                              (void *)(uintptr_t)w) < 0) {
             Py_DECREF(v);
             goto err;
         }

Python/pythonrun.c

@@ -515,8 +515,7 @@ parse_syntax_error(PyObject *err, PyObject **message, PyObject **filename,
     if (v == Py_None) {
         Py_DECREF(v);
         _Py_DECLARE_STR(anon_string, "<string>");
-        *filename = &_Py_STR(anon_string);
+        *filename = Py_NewRef(&_Py_STR(anon_string));
-        Py_INCREF(*filename);
     }
     else {
         *filename = v;

Python/structmember.c

@@ -74,7 +74,7 @@ PyMember_GetOne(const char *obj_addr, PyMemberDef *l)
             PyErr_Format(PyExc_AttributeError,
                          "'%.200s' object has no attribute '%s'",
                          tp->tp_name, l->name);
-       }
+        }
         Py_XINCREF(v);
         break;
     case T_LONGLONG:

Python/symtable.c

@@ -373,17 +373,17 @@ PySymtable_Lookup(struct symtable *st, void *key)
     if (k == NULL)
         return NULL;
     v = PyDict_GetItemWithError(st->st_blocks, k);
+    Py_DECREF(k);
+
     if (v) {
         assert(PySTEntry_Check(v));
-        Py_INCREF(v);
     }
     else if (!PyErr_Occurred()) {
         PyErr_SetString(PyExc_KeyError,
                         "unknown symbol table entry");
     }
 
-    Py_DECREF(k);
+    return (PySTEntryObject *)Py_XNewRef(v);
-    return (PySTEntryObject *)v;
 }
 
 long