pythongh-111789: Use PyDict_GetItemRef()

Modules/_asynciomodule.c

@@ -3514,15 +3514,11 @@ _asyncio_current_task_impl(PyObject *module, PyObject *loop)
  Py_INCREF(loop);
  }
 
- ret = PyDict_GetItemWithError(state->current_tasks, loop);
+ int rc = PyDict_GetItemRef(state->current_tasks, loop, &ret);
  Py_DECREF(loop);
- if (ret == NULL && PyErr_Occurred()) {
- return NULL;
- }
- else if (ret == NULL) {
+ if (rc == 0) {
  Py_RETURN_NONE;
  }
- Py_INCREF(ret);
  return ret;
 }
 

Modules/_csv.c

@@ -160,15 +160,9 @@ static PyObject *
 get_dialect_from_registry(PyObject *name_obj, _csvstate *module_state)
 {
  PyObject *dialect_obj;
-
- dialect_obj = PyDict_GetItemWithError(module_state->dialects, name_obj);
- if (dialect_obj == NULL) {
- if (!PyErr_Occurred())
- PyErr_Format(module_state->error_obj, "unknown dialect");
+ if (PyDict_GetItemRef(module_state->dialects, name_obj, &dialect_obj) == 0) {
+ PyErr_SetString(module_state->error_obj, "unknown dialect");
  }
- else
- Py_INCREF(dialect_obj);
-
  return dialect_obj;
 }
 

Modules/_ctypes/_ctypes.c

@@ -243,26 +243,19 @@ PyDict_SetItemProxy(PyObject *dict, PyObject *key, PyObject *item)
 static int
 _PyDict_GetItemProxy(PyObject *dict, PyObject *key, PyObject **presult)
 {
- PyObject *item = PyDict_GetItemWithError(dict, key);
- if (item == NULL) {
- if (PyErr_Occurred()) {
- return -1;
- }
+ int rc = PyDict_GetItemRef(dict, key, presult);
+ if (rc <= 0) { // error or not found
  *presult = NULL;
- return 0;
+ return rc;
  }
 
+ PyObject *item = *presult;
  if (!PyWeakref_CheckProxy(item)) {
- *presult = Py_NewRef(item);
- return 0;
- }
- PyObject *ref;
- if (PyWeakref_GetRef(item, &ref) < 0) {
- return -1;
+ return 1;
  }
- // ref is NULL if the referenced object was destroyed
- *presult = ref;
- return 0;
+ rc = PyWeakref_GetRef(item, presult);
+ Py_DECREF(item);
+ return rc;
 }
 
 /******************************************************************/
@@ -565,18 +558,19 @@ StructUnionType_new(PyTypeObject *type, PyObject *args, PyObject *kwds, int isSt
 
  dict->paramfunc = StructUnionType_paramfunc;
 
- fields = PyDict_GetItemWithError((PyObject *)dict, &_Py_ID(_fields_));
+ if (PyDict_GetItemRef((PyObject *)dict, &_Py_ID(_fields_), &fields) < 0) {
+ Py_DECREF(result);
+ return NULL;
+ }
  if (fields) {
  if (PyObject_SetAttr((PyObject *)result, &_Py_ID(_fields_), fields) < 0) {
  Py_DECREF(result);
+ Py_DECREF(fields);
  return NULL;
  }
+ Py_DECREF(fields);
  return (PyObject *)result;
  }
- else if (PyErr_Occurred()) {
- Py_DECREF(result);
- return NULL;
- }
  else {
  StgDictObject *basedict = PyType_stgdict((PyObject *)result->tp_base);
 
@@ -1110,11 +1104,15 @@ PyCPointerType_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
  stgdict->paramfunc = PyCPointerType_paramfunc;
  stgdict->flags |= TYPEFLAG_ISPOINTER;
 
- proto = PyDict_GetItemWithError(typedict, &_Py_ID(_type_)); /* Borrowed ref */
+ if (PyDict_GetItemRef(typedict, &_Py_ID(_type_), &proto) < 0) {
+ Py_DECREF((PyObject *)stgdict);
+ return NULL;
+ }
  if (proto) {
  StgDictObject *itemdict;
  const char *current_format;
  if (-1 == PyCPointerType_SetProto(stgdict, proto)) {
+ Py_DECREF(proto);
  Py_DECREF((PyObject *)stgdict);
  return NULL;
  }
@@ -1134,15 +1132,12 @@ PyCPointerType_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
  } else {
  stgdict->format = _ctypes_alloc_format_string("&", current_format);
  }
+ Py_DECREF(proto);
  if (stgdict->format == NULL) {
  Py_DECREF((PyObject *)stgdict);
  return NULL;
  }
  }
- else if (PyErr_Occurred()) {
- Py_DECREF((PyObject *)stgdict);
- return NULL;
- }
 
  /* create the new instance (which is a class,
  since we are a metatype!) */
@@ -2461,58 +2456,61 @@ make_funcptrtype_dict(StgDictObject *stgdict)
  stgdict->getfunc = NULL;
  stgdict->ffi_type_pointer = ffi_type_pointer;
 
- ob = PyDict_GetItemWithError((PyObject *)stgdict, &_Py_ID(_flags_));
+ if (PyDict_GetItemRef((PyObject *)stgdict, &_Py_ID(_flags_), &ob) < 0) {
+ return -1;
+ }
  if (!ob || !PyLong_Check(ob)) {
- if (!PyErr_Occurred()) {
- PyErr_SetString(PyExc_TypeError,
+ PyErr_SetString(PyExc_TypeError,
  "class must define _flags_ which must be an integer");
- }
+ Py_XDECREF(ob);
  return -1;
  }
  stgdict->flags = PyLong_AsUnsignedLongMask(ob) | TYPEFLAG_ISPOINTER;
+ Py_DECREF(ob);
 
  /* _argtypes_ is optional... */
- ob = PyDict_GetItemWithError((PyObject *)stgdict, &_Py_ID(_argtypes_));
+ if (PyDict_GetItemRef((PyObject *)stgdict, &_Py_ID(_argtypes_), &ob) < 0) {
+ return -1;
+ }
  if (ob) {
  converters = converters_from_argtypes(ob);
- if (!converters)
+ if (!converters) {
+ Py_DECREF(ob);
  return -1;
- stgdict->argtypes = Py_NewRef(ob);
+ }
+ stgdict->argtypes = ob;
  stgdict->converters = converters;
  }
- else if (PyErr_Occurred()) {
+
+ if (PyDict_GetItemRef((PyObject *)stgdict, &_Py_ID(_restype_), &ob) < 0) {
  return -1;
  }
-
- ob = PyDict_GetItemWithError((PyObject *)stgdict, &_Py_ID(_restype_));
  if (ob) {
  if (ob != Py_None && !PyType_stgdict(ob) && !PyCallable_Check(ob)) {
  PyErr_SetString(PyExc_TypeError,
  "_restype_ must be a type, a callable, or None");
+ Py_DECREF(ob);
  return -1;
  }
- stgdict->restype = Py_NewRef(ob);
+ stgdict->restype = ob;
  if (PyObject_GetOptionalAttr(ob, &_Py_ID(_check_retval_),
  &stgdict->checker) < 0)
  {
  return -1;
  }
  }
- else if (PyErr_Occurred()) {
+/* XXX later, maybe.
+ if (PyDict_GetItemRef((PyObject *)stgdict, &_Py _ID(_errcheck_), &ob) < 0) {
  return -1;
  }
-/* XXX later, maybe.
- ob = _PyDict_GetItemIdWithError((PyObject *)stgdict, &PyId__errcheck_);
  if (ob) {
  if (!PyCallable_Check(ob)) {
  PyErr_SetString(PyExc_TypeError,
  "_errcheck_ must be callable");
+ Py_DECREF(ob);
  return -1;
  }
- stgdict->errcheck = Py_NewRef(ob);
- }
- else if (PyErr_Occurred()) {
- return -1;
+ stgdict->errcheck = ob;
  }
 */
  return 0;
@@ -3812,13 +3810,12 @@ _get_arg(int *pindex, PyObject *name, PyObject *defval, PyObject *inargs, PyObje
  return Py_NewRef(v);
  }
  if (kwds && name) {
- v = PyDict_GetItemWithError(kwds, name);
+ if (PyDict_GetItemRef(kwds, name, &v) < 0) {
+ return NULL;
+ }
  if (v) {
  ++*pindex;
- return Py_NewRef(v);
- }
- else if (PyErr_Occurred()) {
- return NULL;
+ return v;
  }
  }
  if (defval) {
@@ -4870,11 +4867,8 @@ PyCArrayType_from_ctype(PyObject *itemtype, Py_ssize_t length)
  return NULL;
 
  PyObject *result;
- if (_PyDict_GetItemProxy(cache, key, &result) < 0) {
- Py_DECREF(key);
- return NULL;
- }
- if (result) {
+ if (_PyDict_GetItemProxy(cache, key, &result) != 0) {
+ // error or found
  Py_DECREF(key);
  return result;
  }

Modules/_ctypes/callproc.c

@@ -168,16 +168,18 @@ _ctypes_get_errobj(int **pspace)
  if (error_object_name == NULL)
  return NULL;
  }
- errobj = PyDict_GetItemWithError(dict, error_object_name);
+ if (PyDict_GetItemRef(dict, error_object_name, &errobj) < 0) {
+ return NULL;
+ }
  if (errobj) {
  if (!PyCapsule_IsValid(errobj, CTYPES_CAPSULE_NAME_PYMEM)) {
  PyErr_SetString(PyExc_RuntimeError,
  "ctypes.error_object is an invalid capsule");
+ Py_DECREF(errobj);
  return NULL;
  }
- Py_INCREF(errobj);
  }
- else if (!PyErr_Occurred()) {
+ else {
  void *space = PyMem_Calloc(2, sizeof(int));
  if (space == NULL)
  return NULL;
@@ -192,9 +194,6 @@ _ctypes_get_errobj(int **pspace)
  return NULL;
  }
  }
- else {
- return NULL;
- }
  *pspace = (int *)PyCapsule_GetPointer(errobj, CTYPES_CAPSULE_NAME_PYMEM);
  return errobj;
 }
@@ -1922,12 +1921,8 @@ create_pointer_type(PyObject *module, PyObject *cls)
  PyTypeObject *typ;
  PyObject *key;
 
- result = PyDict_GetItemWithError(_ctypes_ptrtype_cache, cls);
- if (result) {
- return Py_NewRef(result);
- }
- else if (PyErr_Occurred()) {
- return NULL;
+ if (PyDict_GetItemRef(_ctypes_ptrtype_cache, cls, &result) != 0) {
+ return result;
  }
  if (PyUnicode_CheckExact(cls)) {
  PyObject *name = PyUnicode_FromFormat("LP_%U", cls);
@@ -1986,16 +1981,14 @@ create_pointer_inst(PyObject *module, PyObject *arg)
  PyObject *result;
  PyObject *typ;
 
- typ = PyDict_GetItemWithError(_ctypes_ptrtype_cache, (PyObject *)Py_TYPE(arg));
- if (typ) {
- return PyObject_CallOneArg(typ, arg);
- }
- else if (PyErr_Occurred()) {
+ if (PyDict_GetItemRef(_ctypes_ptrtype_cache, (PyObject *)Py_TYPE(arg), &typ) < 0) {
  return NULL;
  }
- typ = create_pointer_type(NULL, (PyObject *)Py_TYPE(arg));
- if (typ == NULL)
- return NULL;
+ if (typ == NULL) {
+ typ = create_pointer_type(NULL, (PyObject *)Py_TYPE(arg));
+ if (typ == NULL)
+ return NULL;
+ }
  result = PyObject_CallOneArg(typ, arg);
  Py_DECREF(typ);
  return result;

Modules/_elementtree.c

@@ -372,26 +372,26 @@ get_attrib_from_keywords(PyObject *kwds)
  if (attrib_str == NULL) {
  return NULL;
  }
- PyObject *attrib = PyDict_GetItemWithError(kwds, attrib_str);
-
- if (attrib) {
+ PyObject *attrib;
+ if (PyDict_GetItemRef(kwds, attrib_str, &attrib) == 0) {
+ attrib = PyDict_New();
+ }
+ else if (attrib) {
  /* If attrib was found in kwds, copy its value and remove it from
  * kwds
  */
  if (!PyDict_Check(attrib)) {
  Py_DECREF(attrib_str);
  PyErr_Format(PyExc_TypeError, "attrib must be dict, not %.100s",
  Py_TYPE(attrib)->tp_name);
+ Py_DECREF(attrib);
  return NULL;
  }
- attrib = PyDict_Copy(attrib);
+ Py_SETREF(attrib, PyDict_Copy(attrib));
  if (attrib && PyDict_DelItem(kwds, attrib_str) < 0) {
  Py_SETREF(attrib, NULL);
  }
  }
- else if (!PyErr_Occurred()) {
- attrib = PyDict_New();
- }
 
  Py_DECREF(attrib_str);
 
@@ -1421,11 +1421,12 @@ _elementtree_Element_get_impl(ElementObject *self, PyObject *key,
 {
  if (self->extra && self->extra->attrib) {
  PyObject *attrib = Py_NewRef(self->extra->attrib);
- PyObject *value = Py_XNewRef(PyDict_GetItemWithError(attrib, key));
- Py_DECREF(attrib);
- if (value != NULL || PyErr_Occurred()) {
+ PyObject *value;
+ if (PyDict_GetItemRef(attrib, key, &value) != 0) {
+  Py_DECREF(attrib);
  return value;
  }
+ Py_DECREF(attrib);
  }
 
  return Py_NewRef(default_value);
@@ -3085,9 +3086,7 @@ makeuniversal(XMLParserObject* self, const char* string)
  if (!key)
  return NULL;
 
- value = Py_XNewRef(PyDict_GetItemWithError(self->names, key));
-
- if (value == NULL && !PyErr_Occurred()) {
+ if (PyDict_GetItemRef(self->names, key, &value) == 0) {
  /* new name. convert to universal name, and decode as
  necessary */
 

Modules/_sqlite/cursor.c

@@ -737,12 +737,8 @@ bind_parameters(pysqlite_state *state, pysqlite_Statement *self,
  if (!binding_name_obj) {
  return;
  }
- if (PyDict_CheckExact(parameters)) {
- PyObject *item = PyDict_GetItemWithError(parameters, binding_name_obj);
- current_param = Py_XNewRef(item);
- } else {
- current_param = PyObject_GetItem(parameters, binding_name_obj);
- }
+ PyObject *current_param;
+ (void)PyMapping_GetOptionalItem(parameters, binding_name_obj, &current_param);
  Py_DECREF(binding_name_obj);
  if (!current_param) {
  if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_LookupError)) {