Add bindings for PyDict_SetDefaultRef and use them in PyCode::run

Author: ngoldbaum

pyo3-ffi/src/compat/py_3_13.rs

@@ -130,3 +130,51 @@ compat_function!(
         crate::_PyThreadState_UncheckedGet()
     }
 );
+
+compat_function! {
+    originally_defined_for(any(Py_3_13, all(Py_LIMITED_API, Py_3_15)));
+
+    #[inline]
+    pub unsafe fn PyDict_SetDefaultRef(
+        mp: *mut crate::PyObject,
+        key: *mut crate::PyObject,
+        default_value: *mut crate::PyObject,
+        result: *mut *mut crate::PyObject,
+    ) -> std::ffi::c_int {
+        use crate::{
+            compat::{PyDict_GetItemRef, Py_NewRef},
+            PyDict_SetItem, PyObject, Py_DECREF,
+        };
+        let mut value: *mut PyObject = std::ptr::null_mut();
+        if PyDict_GetItemRef(mp, key, &mut value) < 0 {
+            // get error
+            if !result.is_null() {
+                *result = std::ptr::null_mut();
+            }
+            return -1;
+        }
+        if !value.is_null() {
+            // present
+            if !result.is_null() {
+                *result = value;
+            }
+            else {
+                Py_DECREF(value);
+            }
+            return 1;
+        }
+
+        // missing, set the item
+        if PyDict_SetItem(mp, key, default_value) < 0 {
+            // set error
+            if !result.is_null() {
+                *result = std::ptr::null_mut();
+            }
+            return -1;
+        }
+        if !result.is_null() {
+            *result = Py_NewRef(default_value);
+        }
+        return 0;
+    }
+}

pyo3-ffi/src/cpython/dictobject.rs

@@ -43,7 +43,6 @@ pub struct PyDictObject {
 // skipped private _PyDict_GetItemStringWithError
 
 // skipped PyDict_SetDefault
-// skipped PyDict_SetDefaultRef
 
 // skipped PyDict_GET_SIZE
 // skipped PyDict_ContainsString

pyo3-ffi/src/dictobject.rs

@@ -78,6 +78,13 @@ extern_libpython! {
         key: *const c_char,
         result: *mut *mut PyObject,
     ) -> c_int;
+    #[cfg(any(Py_3_13, all(Py_LIMITED_API, Py_3_15)))]
+    pub fn PyDict_SetDefaultRef(
+        mp: *mut PyObject,
+        key: *mut PyObject,
+        default_value: *mut PyObject,
+        result: *mut *mut PyObject,
+    ) -> c_int;
     // skipped 3.10 / ex-non-limited PyObject_GenericGetDict
 }
 

src/types/code.rs

@@ -127,28 +127,23 @@ impl<'py> PyCodeMethods<'py> for Bound<'py, PyCode> {
         // - https://github.com/python/cpython/pull/24564 (the same fix in CPython 3.10)
         // - https://github.com/PyO3/pyo3/issues/3370
         let builtins_s = crate::intern!(self.py(), "__builtins__");
-        let has_builtins = globals.contains(builtins_s)?;
-        if !has_builtins {
-            crate::sync::critical_section::with_critical_section(globals, || {
-                // check if another thread set __builtins__ while this thread was blocked on the critical section
-                let has_builtins = globals.contains(builtins_s)?;
-                if !has_builtins {
-                    // Inherit current builtins.
-                    let builtins = unsafe { ffi::PyEval_GetBuiltins() };
-
-                    // `PyDict_SetItem` doesn't take ownership of `builtins`, but `PyEval_GetBuiltins`
-                    // seems to return a borrowed reference, so no leak here.
-                    if unsafe {
-                        ffi::PyDict_SetItem(globals.as_ptr(), builtins_s.as_ptr(), builtins)
-                    } == -1
-                    {
-                        return Err(PyErr::fetch(self.py()));
-                    }
-                }
-                Ok(())
-            })?;
+        let mut result: *mut ffi::PyObject = std::ptr::null_mut();
+        if unsafe {
+            ffi::compat::PyDict_SetDefaultRef(
+                globals.as_ptr(),
+                builtins_s.as_ptr(),
+                // borrowed reference
+                ffi::PyEval_GetBuiltins(),
+                &mut result,
+            )
+        } == -1
+        {
+            return Err(PyErr::fetch(self.py()));
         }
 
+        // release ownership of result
+        unsafe { ffi::Py_DECREF(result) };
+
         unsafe {
             ffi::PyEval_EvalCode(self.as_ptr(), globals.as_ptr(), locals.as_ptr())
                 .assume_owned_or_err(self.py())