From f4c7003fbe4bf345fef32e0a18e1fc50d50f09f6 Mon Sep 17 00:00:00 2001 From: person93 Date: Fri, 8 May 2026 17:34:52 -0400 Subject: [PATCH 1/7] replace `std::` with `core::` in ffi crate --- pyo3-ffi/src/abstract_.rs | 8 ++--- pyo3-ffi/src/boolobject.rs | 2 +- pyo3-ffi/src/bytearrayobject.rs | 2 +- pyo3-ffi/src/bytesobject.rs | 2 +- pyo3-ffi/src/ceval.rs | 4 +-- pyo3-ffi/src/codecs.rs | 2 +- pyo3-ffi/src/compat/py_3_10.rs | 4 +-- pyo3-ffi/src/compat/py_3_13.rs | 40 ++++++++++++------------- pyo3-ffi/src/compat/py_3_14.rs | 6 ++-- pyo3-ffi/src/compat/py_3_15.rs | 34 ++++++++++----------- pyo3-ffi/src/compat/py_3_9.rs | 4 +-- pyo3-ffi/src/compile.rs | 2 +- pyo3-ffi/src/complexobject.rs | 2 +- pyo3-ffi/src/context.rs | 2 +- pyo3-ffi/src/cpython/abstract_.rs | 24 +++++++-------- pyo3-ffi/src/cpython/bytearrayobject.rs | 4 +-- pyo3-ffi/src/cpython/bytesobject.rs | 6 ++-- pyo3-ffi/src/cpython/cellobject.rs | 2 +- pyo3-ffi/src/cpython/ceval.rs | 2 +- pyo3-ffi/src/cpython/code.rs | 4 +-- pyo3-ffi/src/cpython/compile.rs | 4 +-- pyo3-ffi/src/cpython/complexobject.rs | 2 +- pyo3-ffi/src/cpython/descrobject.rs | 2 +- pyo3-ffi/src/cpython/dictobject.rs | 4 +-- pyo3-ffi/src/cpython/floatobject.rs | 2 +- pyo3-ffi/src/cpython/frameobject.rs | 4 +-- pyo3-ffi/src/cpython/funcobject.rs | 2 +- pyo3-ffi/src/cpython/genobject.rs | 4 +-- pyo3-ffi/src/cpython/import.rs | 4 +-- pyo3-ffi/src/cpython/initconfig.rs | 2 +- pyo3-ffi/src/cpython/lock.rs | 4 +-- pyo3-ffi/src/cpython/longobject.rs | 6 ++-- pyo3-ffi/src/cpython/marshal.rs | 2 +- pyo3-ffi/src/cpython/methodobject.rs | 6 ++-- pyo3-ffi/src/cpython/object.rs | 10 +++---- pyo3-ffi/src/cpython/objimpl.rs | 6 ++-- pyo3-ffi/src/cpython/pydebug.rs | 4 +-- pyo3-ffi/src/cpython/pyframe.rs | 4 +-- pyo3-ffi/src/cpython/pyhash.rs | 6 ++-- pyo3-ffi/src/cpython/pylifecycle.rs | 2 +- pyo3-ffi/src/cpython/pymem.rs | 2 +- pyo3-ffi/src/cpython/pystate.rs | 2 +- pyo3-ffi/src/cpython/pythonrun.rs | 4 +-- pyo3-ffi/src/cpython/traceback.rs | 2 +- pyo3-ffi/src/cpython/unicodeobject.rs | 26 ++++++++-------- pyo3-ffi/src/cpython/warnings.rs | 2 +- pyo3-ffi/src/datetime.rs | 18 +++++------ pyo3-ffi/src/descrobject.rs | 4 +-- pyo3-ffi/src/dictobject.rs | 2 +- pyo3-ffi/src/fileobject.rs | 2 +- pyo3-ffi/src/fileutils.rs | 2 +- pyo3-ffi/src/floatobject.rs | 2 +- pyo3-ffi/src/impl_/mod.rs | 6 ++-- pyo3-ffi/src/import.rs | 2 +- pyo3-ffi/src/intrcheck.rs | 2 +- pyo3-ffi/src/iterobject.rs | 2 +- pyo3-ffi/src/lib.rs | 22 +++++++------- pyo3-ffi/src/listobject.rs | 2 +- pyo3-ffi/src/longobject.rs | 2 +- pyo3-ffi/src/memoryobject.rs | 2 +- pyo3-ffi/src/methodobject.rs | 14 ++++----- pyo3-ffi/src/modsupport.rs | 2 +- pyo3-ffi/src/moduleobject.rs | 6 ++-- pyo3-ffi/src/object.rs | 16 +++++----- pyo3-ffi/src/objimpl.rs | 2 +- pyo3-ffi/src/pybuffer.rs | 4 +-- pyo3-ffi/src/pycapsule.rs | 2 +- pyo3-ffi/src/pyerrors.rs | 2 +- pyo3-ffi/src/pyframe.rs | 2 +- pyo3-ffi/src/pyhash.rs | 4 +-- pyo3-ffi/src/pylifecycle.rs | 4 +-- pyo3-ffi/src/pymem.rs | 2 +- pyo3-ffi/src/pyport.rs | 2 +- pyo3-ffi/src/pystate.rs | 6 ++-- pyo3-ffi/src/pystrtod.rs | 2 +- pyo3-ffi/src/pythonrun.rs | 10 +++---- pyo3-ffi/src/rangeobject.rs | 2 +- pyo3-ffi/src/refcount.rs | 18 +++++------ pyo3-ffi/src/setobject.rs | 2 +- pyo3-ffi/src/sliceobject.rs | 2 +- pyo3-ffi/src/structmember.rs | 2 +- pyo3-ffi/src/structseq.rs | 2 +- pyo3-ffi/src/sysmodule.rs | 2 +- pyo3-ffi/src/traceback.rs | 2 +- pyo3-ffi/src/tupleobject.rs | 2 +- pyo3-ffi/src/typeslots.rs | 2 +- pyo3-ffi/src/unicodeobject.rs | 2 +- pyo3-ffi/src/warnings.rs | 2 +- pyo3-ffi/src/weakrefobject.rs | 2 +- 89 files changed, 233 insertions(+), 233 deletions(-) diff --git a/pyo3-ffi/src/abstract_.rs b/pyo3-ffi/src/abstract_.rs index c2b141b0c6e..fe04b66e62f 100644 --- a/pyo3-ffi/src/abstract_.rs +++ b/pyo3-ffi/src/abstract_.rs @@ -1,8 +1,8 @@ use crate::object::*; use crate::pyport::Py_ssize_t; +use core::ffi::{c_char, c_int}; #[cfg(any(Py_3_12, not(Py_LIMITED_API)))] use libc::size_t; -use std::ffi::{c_char, c_int}; #[inline] #[cfg(all( @@ -10,7 +10,7 @@ use std::ffi::{c_char, c_int}; not(all(PyPy, not(Py_3_11))) // PyPy exposed as a function until PyPy 3.10, macro in 3.11+ ))] pub unsafe fn PyObject_DelAttrString(o: *mut PyObject, attr_name: *const c_char) -> c_int { - PyObject_SetAttrString(o, attr_name, std::ptr::null_mut()) + PyObject_SetAttrString(o, attr_name, core::ptr::null_mut()) } #[inline] @@ -19,7 +19,7 @@ pub unsafe fn PyObject_DelAttrString(o: *mut PyObject, attr_name: *const c_char) not(all(PyPy, not(Py_3_11))) // PyPy exposed as a function until PyPy 3.10, macro in 3.11+ ))] pub unsafe fn PyObject_DelAttr(o: *mut PyObject, attr_name: *mut PyObject) -> c_int { - PyObject_SetAttr(o, attr_name, std::ptr::null_mut()) + PyObject_SetAttr(o, attr_name, core::ptr::null_mut()) } extern_libpython! { @@ -86,7 +86,7 @@ extern_libpython! { #[cfg(any(Py_3_12, not(Py_LIMITED_API)))] pub const PY_VECTORCALL_ARGUMENTS_OFFSET: size_t = (1 as size_t) - .checked_shl((8 * std::mem::size_of::() - 1) as u32) + .checked_shl((8 * core::mem::size_of::() - 1) as u32) .expect("size_t should fit the flag bits"); extern_libpython! { diff --git a/pyo3-ffi/src/boolobject.rs b/pyo3-ffi/src/boolobject.rs index 5294756cb88..bf55c1dedc6 100644 --- a/pyo3-ffi/src/boolobject.rs +++ b/pyo3-ffi/src/boolobject.rs @@ -1,7 +1,7 @@ #[cfg(all(not(GraalPy), not(all(Py_3_13, Py_LIMITED_API))))] use crate::longobject::PyLongObject; use crate::object::*; -use std::ffi::{c_int, c_long}; +use core::ffi::{c_int, c_long}; #[inline] #[cfg(not(RustPython))] diff --git a/pyo3-ffi/src/bytearrayobject.rs b/pyo3-ffi/src/bytearrayobject.rs index 95db8c1e590..713a352c530 100644 --- a/pyo3-ffi/src/bytearrayobject.rs +++ b/pyo3-ffi/src/bytearrayobject.rs @@ -1,6 +1,6 @@ use crate::object::*; use crate::pyport::Py_ssize_t; -use std::ffi::{c_char, c_int}; +use core::ffi::{c_char, c_int}; #[cfg(not(RustPython))] extern_libpython! { diff --git a/pyo3-ffi/src/bytesobject.rs b/pyo3-ffi/src/bytesobject.rs index dd966807996..c99e0dabefa 100644 --- a/pyo3-ffi/src/bytesobject.rs +++ b/pyo3-ffi/src/bytesobject.rs @@ -1,6 +1,6 @@ use crate::object::*; use crate::pyport::Py_ssize_t; -use std::ffi::{c_char, c_int}; +use core::ffi::{c_char, c_int}; #[cfg(not(RustPython))] extern_libpython! { diff --git a/pyo3-ffi/src/ceval.rs b/pyo3-ffi/src/ceval.rs index 83814ada606..37294d7e59b 100644 --- a/pyo3-ffi/src/ceval.rs +++ b/pyo3-ffi/src/ceval.rs @@ -1,6 +1,6 @@ use crate::object::PyObject; use crate::pytypedefs::PyThreadState; -use std::ffi::{c_char, c_int, c_void}; +use core::ffi::{c_char, c_int, c_void}; extern_libpython! { #[cfg_attr(PyPy, link_name = "PyPyEval_EvalCode")] @@ -39,7 +39,7 @@ extern_libpython! { #[inline] pub unsafe fn PyEval_CallObject(func: *mut PyObject, arg: *mut PyObject) -> *mut PyObject { #[allow(deprecated)] - PyEval_CallObjectWithKeywords(func, arg, std::ptr::null_mut()) + PyEval_CallObjectWithKeywords(func, arg, core::ptr::null_mut()) } extern_libpython! { diff --git a/pyo3-ffi/src/codecs.rs b/pyo3-ffi/src/codecs.rs index bf397cd0584..4d53f4e354f 100644 --- a/pyo3-ffi/src/codecs.rs +++ b/pyo3-ffi/src/codecs.rs @@ -1,5 +1,5 @@ use crate::object::PyObject; -use std::ffi::{c_char, c_int}; +use core::ffi::{c_char, c_int}; extern_libpython! { pub fn PyCodec_Register(search_function: *mut PyObject) -> c_int; diff --git a/pyo3-ffi/src/compat/py_3_10.rs b/pyo3-ffi/src/compat/py_3_10.rs index 2d4daa194c6..5c931de4d85 100644 --- a/pyo3-ffi/src/compat/py_3_10.rs +++ b/pyo3-ffi/src/compat/py_3_10.rs @@ -24,9 +24,9 @@ compat_function!( #[inline] pub unsafe fn PyModule_AddObjectRef( module: *mut crate::PyObject, - name: *const std::ffi::c_char, + name: *const core::ffi::c_char, value: *mut crate::PyObject, - ) -> std::ffi::c_int { + ) -> core::ffi::c_int { if value.is_null() && crate::PyErr_Occurred().is_null() { crate::PyErr_SetString( crate::PyExc_SystemError, diff --git a/pyo3-ffi/src/compat/py_3_13.rs b/pyo3-ffi/src/compat/py_3_13.rs index 7c30ea9843a..c2030d98e25 100644 --- a/pyo3-ffi/src/compat/py_3_13.rs +++ b/pyo3-ffi/src/compat/py_3_13.rs @@ -6,7 +6,7 @@ compat_function!( dp: *mut crate::PyObject, key: *mut crate::PyObject, result: *mut *mut crate::PyObject, - ) -> std::ffi::c_int { + ) -> core::ffi::c_int { use crate::{compat::Py_NewRef, PyDict_GetItemWithError, PyErr_Occurred}; let item = PyDict_GetItemWithError(dp, key); @@ -14,7 +14,7 @@ compat_function!( *result = Py_NewRef(item); return 1; // found } - *result = std::ptr::null_mut(); + *result = core::ptr::null_mut(); if PyErr_Occurred().is_null() { return 0; // not found } @@ -43,7 +43,7 @@ compat_function!( #[inline] pub unsafe fn PyImport_AddModuleRef( - name: *const std::ffi::c_char, + name: *const core::ffi::c_char, ) -> *mut crate::PyObject { use crate::{compat::Py_XNewRef, PyImport_AddModule}; @@ -58,25 +58,25 @@ compat_function!( pub unsafe fn PyWeakref_GetRef( reference: *mut crate::PyObject, pobj: *mut *mut crate::PyObject, - ) -> std::ffi::c_int { + ) -> core::ffi::c_int { use crate::{ compat::Py_NewRef, PyErr_SetString, PyExc_TypeError, PyWeakref_Check, PyWeakref_GetObject, Py_None, }; if !reference.is_null() && PyWeakref_Check(reference) == 0 { - *pobj = std::ptr::null_mut(); + *pobj = core::ptr::null_mut(); PyErr_SetString(PyExc_TypeError, c"expected a weakref".as_ptr()); return -1; } let obj = PyWeakref_GetObject(reference); if obj.is_null() { // SystemError if reference is NULL - *pobj = std::ptr::null_mut(); + *pobj = core::ptr::null_mut(); return -1; } if obj == Py_None() { - *pobj = std::ptr::null_mut(); + *pobj = core::ptr::null_mut(); return 0; } *pobj = Py_NewRef(obj); @@ -91,7 +91,7 @@ compat_function!( pub unsafe fn PyList_Extend( list: *mut crate::PyObject, iterable: *mut crate::PyObject, - ) -> std::ffi::c_int { + ) -> core::ffi::c_int { crate::PyList_SetSlice(list, crate::PY_SSIZE_T_MAX, crate::PY_SSIZE_T_MAX, iterable) } ); @@ -100,8 +100,8 @@ compat_function!( originally_defined_for(Py_3_13); #[inline] - pub unsafe fn PyList_Clear(list: *mut crate::PyObject) -> std::ffi::c_int { - crate::PyList_SetSlice(list, 0, crate::PY_SSIZE_T_MAX, std::ptr::null_mut()) + pub unsafe fn PyList_Clear(list: *mut crate::PyObject) -> core::ffi::c_int { + crate::PyList_SetSlice(list, 0, crate::PY_SSIZE_T_MAX, core::ptr::null_mut()) } ); @@ -111,9 +111,9 @@ compat_function!( #[inline] pub unsafe fn PyModule_Add( module: *mut crate::PyObject, - name: *const std::ffi::c_char, + name: *const core::ffi::c_char, value: *mut crate::PyObject, - ) -> std::ffi::c_int { + ) -> core::ffi::c_int { let result = crate::compat::PyModule_AddObjectRef(module, name, value); crate::Py_XDECREF(value); result @@ -140,16 +140,16 @@ compat_function!( key: *mut crate::PyObject, default_value: *mut crate::PyObject, result: *mut *mut crate::PyObject, - ) -> std::ffi::c_int { + ) -> core::ffi::c_int { use crate::{ compat::{PyDict_GetItemRef, Py_NewRef}, PyDict_SetItem, PyObject, Py_DECREF, }; - let mut value: *mut PyObject = std::ptr::null_mut(); + let mut value: *mut PyObject = core::ptr::null_mut(); if PyDict_GetItemRef(mp, key, &mut value) < 0 { // get error if !result.is_null() { - *result = std::ptr::null_mut(); + *result = core::ptr::null_mut(); } return -1; } @@ -167,7 +167,7 @@ compat_function!( if PyDict_SetItem(mp, key, default_value) < 0 { // set error if !result.is_null() { - *result = std::ptr::null_mut(); + *result = core::ptr::null_mut(); } return -1; } @@ -186,7 +186,7 @@ compat_function!( obj: *mut crate::PyObject, name: *mut crate::PyObject, result: *mut *mut crate::PyObject, - ) -> std::ffi::c_int { + ) -> core::ffi::c_int { use crate::{PyErr_Clear, PyErr_ExceptionMatches, PyExc_AttributeError, PyObject_GetAttr}; let attr = PyObject_GetAttr(obj, name); @@ -194,7 +194,7 @@ compat_function!( *result = attr; return 1; // found } - *result = std::ptr::null_mut(); + *result = core::ptr::null_mut(); if PyErr_ExceptionMatches(PyExc_AttributeError) != 0 { PyErr_Clear(); return 0; // not found @@ -207,8 +207,8 @@ compat_function!( originally_defined_for(Py_3_13); #[inline] - pub unsafe fn PyObject_HasAttrWithError(obj: *mut crate::PyObject, attr_name: *mut crate::PyObject) -> std::ffi::c_int { - let mut res: *mut crate::PyObject = std::ptr::null_mut(); + pub unsafe fn PyObject_HasAttrWithError(obj: *mut crate::PyObject, attr_name: *mut crate::PyObject) -> core::ffi::c_int { + let mut res: *mut crate::PyObject = core::ptr::null_mut(); let rc = crate::compat::PyObject_GetOptionalAttr(obj, attr_name, &mut res); crate::Py_XDECREF(res); rc diff --git a/pyo3-ffi/src/compat/py_3_14.rs b/pyo3-ffi/src/compat/py_3_14.rs index 28cef7975c9..879ec93e77e 100644 --- a/pyo3-ffi/src/compat/py_3_14.rs +++ b/pyo3-ffi/src/compat/py_3_14.rs @@ -3,7 +3,7 @@ compat_function!( #[inline] pub unsafe fn Py_HashBuffer( - ptr: *const std::ffi::c_void, + ptr: *const core::ffi::c_void, len: crate::Py_ssize_t, ) -> crate::Py_hash_t { #[cfg(not(any(Py_LIMITED_API, PyPy)))] @@ -13,7 +13,7 @@ compat_function!( #[cfg(any(Py_LIMITED_API, PyPy))] { - let bytes = crate::PyBytes_FromStringAndSize(ptr as *const std::ffi::c_char, len); + let bytes = crate::PyBytes_FromStringAndSize(ptr as *const core::ffi::c_char, len); if bytes.is_null() { -1 } else { @@ -32,7 +32,7 @@ compat_function!( pub unsafe fn PyIter_NextItem( iter: *mut crate::PyObject, item: *mut *mut crate::PyObject, - ) -> std::ffi::c_int { + ) -> core::ffi::c_int { *item = crate::PyIter_Next(iter); if !(*item).is_null() { 1 diff --git a/pyo3-ffi/src/compat/py_3_15.rs b/pyo3-ffi/src/compat/py_3_15.rs index 052fd9fd481..c3efc30e054 100644 --- a/pyo3-ffi/src/compat/py_3_15.rs +++ b/pyo3-ffi/src/compat/py_3_15.rs @@ -12,22 +12,22 @@ compat_function!( if size < 0 { crate::PyErr_SetString(crate::PyExc_ValueError, c"size must be >= 0".as_ptr() as *const _); - return std::ptr::null_mut(); + return core::ptr::null_mut(); } - let writer: *mut PyBytesWriter = crate::PyMem_Malloc(std::mem::size_of::()).cast(); + let writer: *mut PyBytesWriter = crate::PyMem_Malloc(core::mem::size_of::()).cast(); if writer.is_null() { crate::PyErr_NoMemory(); - return std::ptr::null_mut(); + return core::ptr::null_mut(); } - (*writer).obj = std::ptr::null_mut(); + (*writer).obj = core::ptr::null_mut(); (*writer).size = 0; if size >=1 { if _PyBytesWriter_Resize_impl(writer, size, 0) < 0 { PyBytesWriter_Discard(writer); - return std::ptr::null_mut(); + return core::ptr::null_mut(); } (*writer).size = size; @@ -75,9 +75,9 @@ compat_function!( } else { if size != crate::PyBytes_Size((*writer).obj) && crate::_PyBytes_Resize(&mut (*writer).obj, size) < 0 { PyBytesWriter_Discard(writer); - return std::ptr::null_mut(); + return core::ptr::null_mut(); } - std::mem::replace(&mut (*writer).obj, std::ptr::null_mut()) + core::mem::replace(&mut (*writer).obj, core::ptr::null_mut()) }; PyBytesWriter_Discard(writer); @@ -90,7 +90,7 @@ compat_function!( originally_defined_for(all(Py_3_15, not(Py_LIMITED_API))); #[inline] - pub unsafe fn PyBytesWriter_GetData(writer: *mut PyBytesWriter) -> *mut std::ffi::c_void { + pub unsafe fn PyBytesWriter_GetData(writer: *mut PyBytesWriter) -> *mut core::ffi::c_void { if (*writer).obj.is_null() { (*writer).small_buffer.as_ptr() as *mut _ } else { @@ -114,7 +114,7 @@ compat_function!( originally_defined_for(all(Py_3_15, not(Py_LIMITED_API))); #[inline] - pub unsafe fn PyBytesWriter_Resize(writer: *mut PyBytesWriter, size: crate::Py_ssize_t) -> std::ffi::c_int { + pub unsafe fn PyBytesWriter_Resize(writer: *mut PyBytesWriter, size: crate::Py_ssize_t) -> core::ffi::c_int { if size < 0 { crate::PyErr_SetString(crate::PyExc_ValueError, c"size must be >= 0".as_ptr()); return -1; @@ -130,7 +130,7 @@ compat_function!( #[repr(C)] #[cfg(not(any(Py_3_15, Py_LIMITED_API)))] pub struct PyBytesWriter { - small_buffer: [std::ffi::c_char; 256], + small_buffer: [core::ffi::c_char; 256], obj: *mut crate::PyObject, size: crate::Py_ssize_t, } @@ -140,13 +140,13 @@ pub struct PyBytesWriter { unsafe fn _PyBytesWriter_Resize_impl( writer: *mut PyBytesWriter, mut size: crate::Py_ssize_t, - resize: std::ffi::c_int, -) -> std::ffi::c_int { + resize: core::ffi::c_int, +) -> core::ffi::c_int { let overallocate = resize; assert!(size >= 0); let allocated = if (*writer).obj.is_null() { - std::mem::size_of_val(&(*writer).small_buffer) as _ + core::mem::size_of_val(&(*writer).small_buffer) as _ } else { crate::PyBytes_Size((*writer).obj) }; @@ -173,18 +173,18 @@ unsafe fn _PyBytesWriter_Resize_impl( } assert!(!(*writer).obj.is_null()) } else { - (*writer).obj = crate::PyBytes_FromStringAndSize(std::ptr::null_mut(), size); + (*writer).obj = crate::PyBytes_FromStringAndSize(core::ptr::null_mut(), size); if (*writer).obj.is_null() { return -1; } if resize > 0 { - assert!((size as usize) > std::mem::size_of_val(&(*writer).small_buffer)); + assert!((size as usize) > core::mem::size_of_val(&(*writer).small_buffer)); - std::ptr::copy_nonoverlapping( + core::ptr::copy_nonoverlapping( (*writer).small_buffer.as_ptr(), crate::PyBytes_AS_STRING((*writer).obj) as *mut _, - std::mem::size_of_val(&(*writer).small_buffer), + core::mem::size_of_val(&(*writer).small_buffer), ); } } diff --git a/pyo3-ffi/src/compat/py_3_9.rs b/pyo3-ffi/src/compat/py_3_9.rs index 6b3521cc167..fed7e21aaa5 100644 --- a/pyo3-ffi/src/compat/py_3_9.rs +++ b/pyo3-ffi/src/compat/py_3_9.rs @@ -6,7 +6,7 @@ compat_function!( #[inline] pub unsafe fn PyObject_CallNoArgs(obj: *mut crate::PyObject) -> *mut crate::PyObject { - crate::PyObject_CallObject(obj, std::ptr::null_mut()) + crate::PyObject_CallObject(obj, core::ptr::null_mut()) } ); @@ -15,6 +15,6 @@ compat_function!( #[inline] pub unsafe fn PyObject_CallMethodNoArgs(obj: *mut crate::PyObject, name: *mut crate::PyObject) -> *mut crate::PyObject { - crate::PyObject_CallMethodObjArgs(obj, name, std::ptr::null_mut::()) + crate::PyObject_CallMethodObjArgs(obj, name, core::ptr::null_mut::()) } ); diff --git a/pyo3-ffi/src/compile.rs b/pyo3-ffi/src/compile.rs index 988d5b26b0f..6e5f67fb395 100644 --- a/pyo3-ffi/src/compile.rs +++ b/pyo3-ffi/src/compile.rs @@ -1,4 +1,4 @@ -use std::ffi::c_int; +use core::ffi::c_int; pub const Py_single_input: c_int = 256; pub const Py_file_input: c_int = 257; diff --git a/pyo3-ffi/src/complexobject.rs b/pyo3-ffi/src/complexobject.rs index 1e960c5cdb1..7e4b08ac075 100644 --- a/pyo3-ffi/src/complexobject.rs +++ b/pyo3-ffi/src/complexobject.rs @@ -1,5 +1,5 @@ use crate::object::*; -use std::ffi::{c_double, c_int}; +use core::ffi::{c_double, c_int}; #[cfg(not(RustPython))] extern_libpython! { diff --git a/pyo3-ffi/src/context.rs b/pyo3-ffi/src/context.rs index 6eb8bf4f33b..5defd44dbfa 100644 --- a/pyo3-ffi/src/context.rs +++ b/pyo3-ffi/src/context.rs @@ -3,7 +3,7 @@ use crate::object::PyObject; use crate::object::PyTypeObject; #[cfg(not(RustPython))] use crate::Py_IS_TYPE; -use std::ffi::{c_char, c_int}; +use core::ffi::{c_char, c_int}; #[cfg(not(RustPython))] extern_libpython! { diff --git a/pyo3-ffi/src/cpython/abstract_.rs b/pyo3-ffi/src/cpython/abstract_.rs index aea3740ed3c..eb8f0467048 100644 --- a/pyo3-ffi/src/cpython/abstract_.rs +++ b/pyo3-ffi/src/cpython/abstract_.rs @@ -1,8 +1,8 @@ use crate::{vectorcallfunc, PyObject, Py_TYPE, Py_ssize_t}; #[cfg(all(any(not(PyPy), not(Py_3_11)), not(Py_3_12)))] -use std::ffi::c_char; +use core::ffi::c_char; #[cfg(not(Py_3_11))] -use std::ffi::c_int; +use core::ffi::c_int; #[cfg(not(any(PyPy, GraalPy)))] use crate::{ @@ -44,7 +44,7 @@ extern_libpython! { #[cfg(not(Py_3_12))] const PY_VECTORCALL_ARGUMENTS_OFFSET: size_t = (1 as size_t) - .checked_shl((8 * std::mem::size_of::() - 1) as u32) + .checked_shl((8 * core::mem::size_of::() - 1) as u32) .expect("size_t should fit the flag bits"); #[cfg(Py_3_12)] // public API from 3.12 @@ -97,7 +97,7 @@ unsafe fn _PyObject_VectorcallTstate( } Some(func) => { let res = func(callable, args, nargsf, kwnames); - _Py_CheckFunctionResult(tstate, callable, res, std::ptr::null_mut()) + _Py_CheckFunctionResult(tstate, callable, res, core::ptr::null_mut()) } } } @@ -132,11 +132,11 @@ extern_libpython! { #[inline(always)] pub unsafe fn PyObject_CallOneArg(func: *mut PyObject, arg: *mut PyObject) -> *mut PyObject { assert!(!arg.is_null()); - let args_array = [std::ptr::null_mut(), arg]; + let args_array = [core::ptr::null_mut(), arg]; let args = args_array.as_ptr().offset(1); // For PY_VECTORCALL_ARGUMENTS_OFFSET let tstate = PyThreadState_GET(); let nargsf = 1 | PY_VECTORCALL_ARGUMENTS_OFFSET; - _PyObject_VectorcallTstate(tstate, func, args, nargsf, std::ptr::null_mut()) + _PyObject_VectorcallTstate(tstate, func, args, nargsf, core::ptr::null_mut()) } extern_libpython! { @@ -155,7 +155,7 @@ pub unsafe fn PyObject_CallMethodNoArgs( name, &self_, 1 | PY_VECTORCALL_ARGUMENTS_OFFSET, - std::ptr::null_mut(), + core::ptr::null_mut(), ) } @@ -172,7 +172,7 @@ pub unsafe fn PyObject_CallMethodOneArg( name, args.as_ptr(), 2 | PY_VECTORCALL_ARGUMENTS_OFFSET, - std::ptr::null_mut(), + core::ptr::null_mut(), ) } @@ -200,12 +200,12 @@ extern_libpython! { pub fn PyBuffer_GetPointer( view: *mut Py_buffer, indices: *mut Py_ssize_t, - ) -> *mut std::ffi::c_void; + ) -> *mut core::ffi::c_void; #[cfg_attr(PyPy, link_name = "PyPyBuffer_SizeFromFormat")] pub fn PyBuffer_SizeFromFormat(format: *const c_char) -> Py_ssize_t; #[cfg_attr(PyPy, link_name = "PyPyBuffer_ToContiguous")] pub fn PyBuffer_ToContiguous( - buf: *mut std::ffi::c_void, + buf: *mut core::ffi::c_void, view: *mut Py_buffer, len: Py_ssize_t, order: c_char, @@ -213,7 +213,7 @@ extern_libpython! { #[cfg_attr(PyPy, link_name = "PyPyBuffer_FromContiguous")] pub fn PyBuffer_FromContiguous( view: *mut Py_buffer, - buf: *mut std::ffi::c_void, + buf: *mut core::ffi::c_void, len: Py_ssize_t, order: c_char, ) -> c_int; @@ -231,7 +231,7 @@ extern_libpython! { pub fn PyBuffer_FillInfo( view: *mut Py_buffer, o: *mut PyObject, - buf: *mut std::ffi::c_void, + buf: *mut core::ffi::c_void, len: Py_ssize_t, readonly: c_int, flags: c_int, diff --git a/pyo3-ffi/src/cpython/bytearrayobject.rs b/pyo3-ffi/src/cpython/bytearrayobject.rs index a39158bace4..8a922fcb6b5 100644 --- a/pyo3-ffi/src/cpython/bytearrayobject.rs +++ b/pyo3-ffi/src/cpython/bytearrayobject.rs @@ -1,9 +1,9 @@ use crate::object::*; use crate::pyport::Py_ssize_t; #[cfg(not(any(PyPy, GraalPy)))] -use std::ffi::c_char; +use core::ffi::c_char; #[cfg(not(Py_3_9))] -use std::ffi::c_int; +use core::ffi::c_int; #[cfg(not(any(PyPy, GraalPy, Py_LIMITED_API)))] #[repr(C)] diff --git a/pyo3-ffi/src/cpython/bytesobject.rs b/pyo3-ffi/src/cpython/bytesobject.rs index 3cdb46b956b..72e9cfb12f4 100644 --- a/pyo3-ffi/src/cpython/bytesobject.rs +++ b/pyo3-ffi/src/cpython/bytesobject.rs @@ -1,10 +1,10 @@ use crate::object::*; use crate::Py_ssize_t; #[cfg(not(Py_LIMITED_API))] -use std::ffi::c_char; -use std::ffi::c_int; +use core::ffi::c_char; +use core::ffi::c_int; #[cfg(Py_3_15)] -use std::ffi::c_void; +use core::ffi::c_void; #[cfg(not(any(PyPy, GraalPy, Py_LIMITED_API)))] #[repr(C)] diff --git a/pyo3-ffi/src/cpython/cellobject.rs b/pyo3-ffi/src/cpython/cellobject.rs index 474d253aa38..faa6429fe12 100644 --- a/pyo3-ffi/src/cpython/cellobject.rs +++ b/pyo3-ffi/src/cpython/cellobject.rs @@ -1,5 +1,5 @@ use crate::object::*; -use std::ffi::c_int; +use core::ffi::c_int; #[cfg(not(any(PyPy, GraalPy)))] #[repr(C)] diff --git a/pyo3-ffi/src/cpython/ceval.rs b/pyo3-ffi/src/cpython/ceval.rs index 50c5a74480d..682280b6c15 100644 --- a/pyo3-ffi/src/cpython/ceval.rs +++ b/pyo3-ffi/src/cpython/ceval.rs @@ -1,6 +1,6 @@ use crate::cpython::pystate::Py_tracefunc; use crate::object::{freefunc, PyObject}; -use std::ffi::c_int; +use core::ffi::c_int; extern_libpython! { // skipped non-limited _PyEval_CallTracing diff --git a/pyo3-ffi/src/cpython/code.rs b/pyo3-ffi/src/cpython/code.rs index acbfb5c817a..9744256002a 100644 --- a/pyo3-ffi/src/cpython/code.rs +++ b/pyo3-ffi/src/cpython/code.rs @@ -4,8 +4,8 @@ use crate::pyport::Py_ssize_t; #[cfg(not(GraalPy))] use crate::PyCodeObject; #[cfg(not(GraalPy))] -use std::ffi::c_char; -use std::ffi::{c_int, c_void}; +use core::ffi::c_char; +use core::ffi::{c_int, c_void}; // skipped private _PY_MONITORING_LOCAL_EVENTS // skipped private _PY_MONITORING_UNGROUPED_EVENTS diff --git a/pyo3-ffi/src/cpython/compile.rs b/pyo3-ffi/src/cpython/compile.rs index 90df57052d0..c6e8b2554d9 100644 --- a/pyo3-ffi/src/cpython/compile.rs +++ b/pyo3-ffi/src/cpython/compile.rs @@ -8,8 +8,8 @@ use crate::pythonrun::*; use crate::PyCodeObject; use crate::INT_MAX; #[cfg(not(any(PyPy, Py_3_10)))] -use std::ffi::c_char; -use std::ffi::c_int; +use core::ffi::c_char; +use core::ffi::c_int; // skipped PyCF_MASK // skipped PyCF_MASK_OBSOLETE diff --git a/pyo3-ffi/src/cpython/complexobject.rs b/pyo3-ffi/src/cpython/complexobject.rs index d5881feaa7d..d3d29ce0d80 100644 --- a/pyo3-ffi/src/cpython/complexobject.rs +++ b/pyo3-ffi/src/cpython/complexobject.rs @@ -1,5 +1,5 @@ use crate::PyObject; -use std::ffi::c_double; +use core::ffi::c_double; #[repr(C)] #[derive(Copy, Clone)] diff --git a/pyo3-ffi/src/cpython/descrobject.rs b/pyo3-ffi/src/cpython/descrobject.rs index 9d26b870022..e2e40efb7eb 100644 --- a/pyo3-ffi/src/cpython/descrobject.rs +++ b/pyo3-ffi/src/cpython/descrobject.rs @@ -1,5 +1,5 @@ use crate::{PyGetSetDef, PyMethodDef, PyObject, PyTypeObject}; -use std::ffi::{c_char, c_int, c_void}; +use core::ffi::{c_char, c_int, c_void}; #[cfg(Py_3_11)] use crate::PyMemberDef; diff --git a/pyo3-ffi/src/cpython/dictobject.rs b/pyo3-ffi/src/cpython/dictobject.rs index cf5be14f3ee..1bd75d8c6c5 100644 --- a/pyo3-ffi/src/cpython/dictobject.rs +++ b/pyo3-ffi/src/cpython/dictobject.rs @@ -4,9 +4,9 @@ use crate::object::*; use crate::pyport::Py_ssize_t; #[cfg(all(not(PyPy), Py_3_13))] -use std::ffi::c_char; +use core::ffi::c_char; #[cfg(all(not(PyPy), Py_3_12))] -use std::ffi::c_int; +use core::ffi::c_int; #[cfg(not(PyPy))] opaque_struct!(pub PyDictKeysObject); diff --git a/pyo3-ffi/src/cpython/floatobject.rs b/pyo3-ffi/src/cpython/floatobject.rs index 4b9ef1a2484..e3ff9a3371f 100644 --- a/pyo3-ffi/src/cpython/floatobject.rs +++ b/pyo3-ffi/src/cpython/floatobject.rs @@ -1,7 +1,7 @@ #[cfg(GraalPy)] use crate::PyFloat_AsDouble; use crate::{PyFloat_Check, PyObject}; -use std::ffi::c_double; +use core::ffi::c_double; #[repr(C)] pub struct PyFloatObject { diff --git a/pyo3-ffi/src/cpython/frameobject.rs b/pyo3-ffi/src/cpython/frameobject.rs index f1370523a95..c79d688577d 100644 --- a/pyo3-ffi/src/cpython/frameobject.rs +++ b/pyo3-ffi/src/cpython/frameobject.rs @@ -6,8 +6,8 @@ use crate::PyFrameObject; #[cfg(not(GraalPy))] use crate::PyThreadState; #[cfg(not(any(PyPy, GraalPy, Py_3_11)))] -use std::ffi::c_char; -use std::ffi::c_int; +use core::ffi::c_char; +use core::ffi::c_int; #[cfg(not(any(PyPy, GraalPy, Py_3_11)))] pub type PyFrameState = c_char; diff --git a/pyo3-ffi/src/cpython/funcobject.rs b/pyo3-ffi/src/cpython/funcobject.rs index 57a679e5704..b1e4c052a15 100644 --- a/pyo3-ffi/src/cpython/funcobject.rs +++ b/pyo3-ffi/src/cpython/funcobject.rs @@ -1,5 +1,5 @@ use crate::{PyObject, Py_IS_TYPE}; -use std::ffi::c_int; +use core::ffi::c_int; #[cfg(all(not(any(PyPy, GraalPy)), not(Py_3_10)))] #[repr(C)] diff --git a/pyo3-ffi/src/cpython/genobject.rs b/pyo3-ffi/src/cpython/genobject.rs index 52b8e4b4f24..c97de71ff77 100644 --- a/pyo3-ffi/src/cpython/genobject.rs +++ b/pyo3-ffi/src/cpython/genobject.rs @@ -1,8 +1,8 @@ use crate::object::*; use crate::PyFrameObject; #[cfg(all(Py_3_11, not(any(PyPy, GraalPy, Py_3_14))))] -use std::ffi::c_char; -use std::ffi::c_int; +use core::ffi::c_char; +use core::ffi::c_int; #[cfg(not(any(PyPy, GraalPy, Py_3_14)))] #[repr(C)] diff --git a/pyo3-ffi/src/cpython/import.rs b/pyo3-ffi/src/cpython/import.rs index 4655aa0e5af..4b358f01489 100644 --- a/pyo3-ffi/src/cpython/import.rs +++ b/pyo3-ffi/src/cpython/import.rs @@ -1,9 +1,9 @@ #[cfg(any(not(PyPy), Py_3_14))] use crate::PyObject; #[cfg(any(not(PyPy), Py_3_14))] -use std::ffi::c_char; +use core::ffi::c_char; #[cfg(not(PyPy))] -use std::ffi::{c_int, c_uchar}; +use core::ffi::{c_int, c_uchar}; #[cfg(not(PyPy))] #[repr(C)] diff --git a/pyo3-ffi/src/cpython/initconfig.rs b/pyo3-ffi/src/cpython/initconfig.rs index 081774d615a..4d3696ae442 100644 --- a/pyo3-ffi/src/cpython/initconfig.rs +++ b/pyo3-ffi/src/cpython/initconfig.rs @@ -1,8 +1,8 @@ /* --- PyStatus ----------------------------------------------- */ use crate::Py_ssize_t; +use core::ffi::{c_char, c_int, c_ulong}; use libc::wchar_t; -use std::ffi::{c_char, c_int, c_ulong}; #[repr(C)] #[derive(Copy, Clone, Debug, PartialEq, Eq)] diff --git a/pyo3-ffi/src/cpython/lock.rs b/pyo3-ffi/src/cpython/lock.rs index 2565e40534f..f97b049d8e4 100644 --- a/pyo3-ffi/src/cpython/lock.rs +++ b/pyo3-ffi/src/cpython/lock.rs @@ -1,6 +1,6 @@ #[cfg(Py_3_14)] -use std::ffi::c_int; -use std::sync::atomic::AtomicU8; +use core::ffi::c_int; +use core::sync::atomic::AtomicU8; #[repr(transparent)] #[derive(Debug)] diff --git a/pyo3-ffi/src/cpython/longobject.rs b/pyo3-ffi/src/cpython/longobject.rs index 92bb4c6150d..ef0e2c465b1 100644 --- a/pyo3-ffi/src/cpython/longobject.rs +++ b/pyo3-ffi/src/cpython/longobject.rs @@ -2,10 +2,10 @@ use crate::longobject::*; use crate::object::*; #[cfg(Py_3_13)] use crate::pyport::Py_ssize_t; -use libc::size_t; #[cfg(Py_3_13)] -use std::ffi::c_void; -use std::ffi::{c_int, c_uchar}; +use core::ffi::c_void; +use core::ffi::{c_int, c_uchar}; +use libc::size_t; #[cfg(Py_3_13)] extern_libpython! { diff --git a/pyo3-ffi/src/cpython/marshal.rs b/pyo3-ffi/src/cpython/marshal.rs index 089992c3fc6..bd09e37baf2 100644 --- a/pyo3-ffi/src/cpython/marshal.rs +++ b/pyo3-ffi/src/cpython/marshal.rs @@ -1,6 +1,6 @@ use crate::{PyObject, Py_ssize_t}; +use core::ffi::{c_char, c_int, c_long}; use libc::FILE; -use std::ffi::{c_char, c_int, c_long}; #[cfg(Py_3_15)] pub const Py_MARSHAL_VERSION: c_int = 6; diff --git a/pyo3-ffi/src/cpython/methodobject.rs b/pyo3-ffi/src/cpython/methodobject.rs index 582d3766c33..440701ab942 100644 --- a/pyo3-ffi/src/cpython/methodobject.rs +++ b/pyo3-ffi/src/cpython/methodobject.rs @@ -1,7 +1,7 @@ use crate::object::*; #[cfg(not(GraalPy))] use crate::{PyCFunctionObject, PyMethodDefPointer, METH_METHOD, METH_STATIC}; -use std::ffi::c_int; +use core::ffi::c_int; #[cfg(not(GraalPy))] pub struct PyCMethodObject { @@ -39,7 +39,7 @@ pub unsafe fn PyCFunction_GET_SELF(func: *mut PyObject) -> *mut PyObject { let func = func.cast::(); if (*(*func).m_ml).ml_flags & METH_STATIC != 0 { - std::ptr::null_mut() + core::ptr::null_mut() } else { (*func).m_self } @@ -64,6 +64,6 @@ pub unsafe fn PyCFunction_GET_CLASS(func: *mut PyObject) -> *mut PyTypeObject { let func = func.cast::(); (*func).mm_class } else { - std::ptr::null_mut() + core::ptr::null_mut() } } diff --git a/pyo3-ffi/src/cpython/object.rs b/pyo3-ffi/src/cpython/object.rs index dcde54bd90b..47623839f8a 100644 --- a/pyo3-ffi/src/cpython/object.rs +++ b/pyo3-ffi/src/cpython/object.rs @@ -1,7 +1,7 @@ use crate::vectorcallfunc; use crate::{object, PyGetSetDef, PyMemberDef, PyMethodDef, PyObject, Py_ssize_t}; -use std::ffi::{c_char, c_int, c_uint, c_void}; -use std::mem; +use core::ffi::{c_char, c_int, c_uint, c_void}; +use core::mem; // skipped private _Py_NewReference // skipped private _Py_NewReferenceNoTotal @@ -21,8 +21,8 @@ use std::mem; #[cfg(not(Py_3_11))] // moved to src/buffer.rs from Python mod bufferinfo { use crate::Py_ssize_t; - use std::ffi::{c_char, c_int, c_void}; - use std::ptr; + use core::ffi::{c_char, c_int, c_void}; + use core::ptr; #[repr(C)] #[derive(Copy, Clone)] @@ -229,7 +229,7 @@ pub struct PyTypeObject { pub tp_setattro: Option, pub tp_as_buffer: *mut PyBufferProcs, #[cfg(not(Py_GIL_DISABLED))] - pub tp_flags: std::ffi::c_ulong, + pub tp_flags: core::ffi::c_ulong, #[cfg(Py_GIL_DISABLED)] pub tp_flags: crate::impl_::AtomicCULong, pub tp_doc: *const c_char, diff --git a/pyo3-ffi/src/cpython/objimpl.rs b/pyo3-ffi/src/cpython/objimpl.rs index 38d18221b41..b2810bc1660 100644 --- a/pyo3-ffi/src/cpython/objimpl.rs +++ b/pyo3-ffi/src/cpython/objimpl.rs @@ -1,9 +1,9 @@ +use core::ffi::c_int; #[cfg(not(all(Py_3_11, any(PyPy, GraalPy))))] use libc::size_t; -use std::ffi::c_int; #[cfg(not(any(PyPy, GraalPy)))] -use std::ffi::c_void; +use core::ffi::c_void; use crate::object::*; @@ -28,7 +28,7 @@ pub struct PyObjectArenaAllocator { impl Default for PyObjectArenaAllocator { #[inline] fn default() -> Self { - unsafe { std::mem::zeroed() } + unsafe { core::mem::zeroed() } } } diff --git a/pyo3-ffi/src/cpython/pydebug.rs b/pyo3-ffi/src/cpython/pydebug.rs index 3e50bf0cff5..389c4ea9ef3 100644 --- a/pyo3-ffi/src/cpython/pydebug.rs +++ b/pyo3-ffi/src/cpython/pydebug.rs @@ -1,4 +1,4 @@ -use std::ffi::{c_char, c_int}; +use core::ffi::{c_char, c_int}; #[cfg(not(Py_LIMITED_API))] extern_libpython! { @@ -64,7 +64,7 @@ extern_libpython! { pub unsafe fn Py_GETENV(name: *const c_char) -> *mut c_char { #[allow(deprecated)] if Py_IgnoreEnvironmentFlag != 0 { - std::ptr::null_mut() + core::ptr::null_mut() } else { libc::getenv(name) } diff --git a/pyo3-ffi/src/cpython/pyframe.rs b/pyo3-ffi/src/cpython/pyframe.rs index 718eed46d65..b672ad103b9 100644 --- a/pyo3-ffi/src/cpython/pyframe.rs +++ b/pyo3-ffi/src/cpython/pyframe.rs @@ -2,8 +2,8 @@ use crate::PyFrameObject; use crate::{PyObject, PyTypeObject, Py_IS_TYPE}; #[cfg(Py_3_12)] -use std::ffi::c_char; -use std::ffi::c_int; +use core::ffi::c_char; +use core::ffi::c_int; // NB used in `_PyEval_EvalFrameDefault`, maybe we remove this too. #[cfg(all(Py_3_11, not(PyPy)))] diff --git a/pyo3-ffi/src/cpython/pyhash.rs b/pyo3-ffi/src/cpython/pyhash.rs index 057725a205b..6ec53f86587 100644 --- a/pyo3-ffi/src/cpython/pyhash.rs +++ b/pyo3-ffi/src/cpython/pyhash.rs @@ -3,9 +3,9 @@ use crate::Py_ssize_t; #[cfg(Py_3_13)] use crate::{PyObject, Py_hash_t}; #[cfg(any(Py_3_13, not(PyPy)))] -use std::ffi::c_void; +use core::ffi::c_void; #[cfg(not(PyPy))] -use std::ffi::{c_char, c_int}; +use core::ffi::{c_char, c_int}; #[cfg(not(PyPy))] #[repr(C)] @@ -22,7 +22,7 @@ pub struct PyHash_FuncDef { impl Default for PyHash_FuncDef { #[inline] fn default() -> Self { - unsafe { std::mem::zeroed() } + unsafe { core::mem::zeroed() } } } diff --git a/pyo3-ffi/src/cpython/pylifecycle.rs b/pyo3-ffi/src/cpython/pylifecycle.rs index a6828778062..07240d8c28e 100644 --- a/pyo3-ffi/src/cpython/pylifecycle.rs +++ b/pyo3-ffi/src/cpython/pylifecycle.rs @@ -1,6 +1,6 @@ use crate::{PyConfig, PyPreConfig, PyStatus, Py_ssize_t}; +use core::ffi::{c_char, c_int}; use libc::wchar_t; -use std::ffi::{c_char, c_int}; extern_libpython! { diff --git a/pyo3-ffi/src/cpython/pymem.rs b/pyo3-ffi/src/cpython/pymem.rs index 6c0c973842e..808e4a5b5d0 100644 --- a/pyo3-ffi/src/cpython/pymem.rs +++ b/pyo3-ffi/src/cpython/pymem.rs @@ -1,5 +1,5 @@ +use core::ffi::c_void; use libc::size_t; -use std::ffi::c_void; extern_libpython! { #[cfg_attr(PyPy, link_name = "PyPyMem_RawMalloc")] diff --git a/pyo3-ffi/src/cpython/pystate.rs b/pyo3-ffi/src/cpython/pystate.rs index 4f8bd7b3786..52e15224cc2 100644 --- a/pyo3-ffi/src/cpython/pystate.rs +++ b/pyo3-ffi/src/cpython/pystate.rs @@ -1,6 +1,6 @@ use crate::PyThreadState; use crate::{PyFrameObject, PyInterpreterState, PyObject}; -use std::ffi::c_int; +use core::ffi::c_int; // skipped private _PyInterpreterState_RequiresIDRef // skipped private _PyInterpreterState_RequireIDRef diff --git a/pyo3-ffi/src/cpython/pythonrun.rs b/pyo3-ffi/src/cpython/pythonrun.rs index d3a3c9c03ce..697747d05fa 100644 --- a/pyo3-ffi/src/cpython/pythonrun.rs +++ b/pyo3-ffi/src/cpython/pythonrun.rs @@ -4,8 +4,8 @@ use crate::pyarena::PyArena; use crate::PyCompilerFlags; #[cfg(not(any(PyPy, GraalPy, Py_3_10)))] use crate::{_mod, _node}; +use core::ffi::{c_char, c_int}; use libc::FILE; -use std::ffi::{c_char, c_int}; extern_libpython! { pub fn PyRun_SimpleStringFlags(arg1: *const c_char, arg2: *mut PyCompilerFlags) -> c_int; @@ -137,7 +137,7 @@ extern_libpython! { #[inline] #[cfg(not(any(PyPy, GraalPy)))] pub unsafe fn Py_CompileString(string: *const c_char, p: *const c_char, s: c_int) -> *mut PyObject { - Py_CompileStringExFlags(string, p, s, std::ptr::null_mut(), -1) + Py_CompileStringExFlags(string, p, s, core::ptr::null_mut(), -1) } #[inline] diff --git a/pyo3-ffi/src/cpython/traceback.rs b/pyo3-ffi/src/cpython/traceback.rs index 43c7a66b5aa..6542633db28 100644 --- a/pyo3-ffi/src/cpython/traceback.rs +++ b/pyo3-ffi/src/cpython/traceback.rs @@ -1,6 +1,6 @@ use crate::object::PyObject; use crate::PyFrameObject; -use std::ffi::c_int; +use core::ffi::c_int; #[repr(C)] pub struct PyTracebackObject { diff --git a/pyo3-ffi/src/cpython/unicodeobject.rs b/pyo3-ffi/src/cpython/unicodeobject.rs index d6747317a31..9117d4d90e8 100644 --- a/pyo3-ffi/src/cpython/unicodeobject.rs +++ b/pyo3-ffi/src/cpython/unicodeobject.rs @@ -1,8 +1,8 @@ #[cfg(any(Py_3_11, not(PyPy)))] use crate::Py_hash_t; use crate::{PyObject, Py_UCS1, Py_UCS2, Py_UCS4, Py_ssize_t}; +use core::ffi::{c_char, c_int, c_uint, c_void}; use libc::wchar_t; -use std::ffi::{c_char, c_int, c_uint, c_void}; // skipped Py_UNICODE_ISSPACE() // skipped Py_UNICODE_ISLOWER() @@ -174,7 +174,7 @@ struct PyASCIIObjectState { impl PyASCIIObjectState { #[inline] unsafe fn interned(&self) -> c_uint { - std::mem::transmute( + core::mem::transmute( self.bitfield .get(STATE_INTERNED_INDEX, STATE_INTERNED_WIDTH) as u32, ) @@ -182,43 +182,43 @@ impl PyASCIIObjectState { #[inline] unsafe fn set_interned(&mut self, val: c_uint) { - let val: u32 = std::mem::transmute(val); + let val: u32 = core::mem::transmute(val); self.bitfield .set(STATE_INTERNED_INDEX, STATE_INTERNED_WIDTH, val as u64) } #[inline] unsafe fn kind(&self) -> c_uint { - std::mem::transmute(self.bitfield.get(STATE_KIND_INDEX, STATE_KIND_WIDTH) as u32) + core::mem::transmute(self.bitfield.get(STATE_KIND_INDEX, STATE_KIND_WIDTH) as u32) } #[inline] unsafe fn set_kind(&mut self, val: c_uint) { - let val: u32 = std::mem::transmute(val); + let val: u32 = core::mem::transmute(val); self.bitfield .set(STATE_KIND_INDEX, STATE_KIND_WIDTH, val as u64) } #[inline] unsafe fn compact(&self) -> c_uint { - std::mem::transmute(self.bitfield.get(STATE_COMPACT_INDEX, STATE_COMPACT_WIDTH) as u32) + core::mem::transmute(self.bitfield.get(STATE_COMPACT_INDEX, STATE_COMPACT_WIDTH) as u32) } #[inline] unsafe fn set_compact(&mut self, val: c_uint) { - let val: u32 = std::mem::transmute(val); + let val: u32 = core::mem::transmute(val); self.bitfield .set(STATE_COMPACT_INDEX, STATE_COMPACT_WIDTH, val as u64) } #[inline] unsafe fn ascii(&self) -> c_uint { - std::mem::transmute(self.bitfield.get(STATE_ASCII_INDEX, STATE_ASCII_WIDTH) as u32) + core::mem::transmute(self.bitfield.get(STATE_ASCII_INDEX, STATE_ASCII_WIDTH) as u32) } #[inline] unsafe fn set_ascii(&mut self, val: c_uint) { - let val: u32 = std::mem::transmute(val); + let val: u32 = core::mem::transmute(val); self.bitfield .set(STATE_ASCII_INDEX, STATE_ASCII_WIDTH, val as u64) } @@ -226,7 +226,7 @@ impl PyASCIIObjectState { #[cfg(Py_3_12)] #[inline] unsafe fn statically_allocated(&self) -> c_uint { - std::mem::transmute(self.bitfield.get( + core::mem::transmute(self.bitfield.get( STATE_STATICALLY_ALLOCATED_INDEX, STATE_STATICALLY_ALLOCATED_WIDTH, ) as u32) @@ -235,7 +235,7 @@ impl PyASCIIObjectState { #[cfg(Py_3_12)] #[inline] unsafe fn set_statically_allocated(&mut self, val: c_uint) { - let val: u32 = std::mem::transmute(val); + let val: u32 = core::mem::transmute(val); self.bitfield.set( STATE_STATICALLY_ALLOCATED_INDEX, STATE_STATICALLY_ALLOCATED_WIDTH, @@ -246,13 +246,13 @@ impl PyASCIIObjectState { #[cfg(not(Py_3_12))] #[inline] unsafe fn ready(&self) -> c_uint { - std::mem::transmute(self.bitfield.get(STATE_READY_INDEX, STATE_READY_WIDTH) as u32) + core::mem::transmute(self.bitfield.get(STATE_READY_INDEX, STATE_READY_WIDTH) as u32) } #[cfg(not(Py_3_12))] #[inline] unsafe fn set_ready(&mut self, val: c_uint) { - let val: u32 = std::mem::transmute(val); + let val: u32 = core::mem::transmute(val); self.bitfield .set(STATE_READY_INDEX, STATE_READY_WIDTH, val as u64) } diff --git a/pyo3-ffi/src/cpython/warnings.rs b/pyo3-ffi/src/cpython/warnings.rs index fe6f3d3523a..f3330e69ae5 100644 --- a/pyo3-ffi/src/cpython/warnings.rs +++ b/pyo3-ffi/src/cpython/warnings.rs @@ -1,5 +1,5 @@ use crate::object::PyObject; -use std::ffi::c_int; +use core::ffi::c_int; extern_libpython! { pub fn PyErr_WarnExplicitObject( diff --git a/pyo3-ffi/src/datetime.rs b/pyo3-ffi/src/datetime.rs index e967541335e..7ed4e8af9c5 100644 --- a/pyo3-ffi/src/datetime.rs +++ b/pyo3-ffi/src/datetime.rs @@ -9,13 +9,13 @@ use crate::PyCapsule_Import; #[cfg(GraalPy)] use crate::{PyLong_AsLong, PyLong_Check, PyObject_GetAttrString, Py_DecRef}; use crate::{PyObject, PyObject_TypeCheck, PyTypeObject, Py_IS_TYPE, Py_None}; -use std::ffi::c_char; -use std::ffi::c_int; -use std::ffi::CStr; -use std::ptr; -use std::sync::atomic::{AtomicPtr, Ordering}; +use core::ffi::c_char; +use core::ffi::c_int; +use core::ffi::CStr; +use core::ptr; +use core::sync::atomic::{AtomicPtr, Ordering}; #[cfg(not(PyPy))] -use {crate::Py_hash_t, std::ffi::c_uchar}; +use {crate::Py_hash_t, core::ffi::c_uchar}; // Type struct wrappers const _PyDateTime_DATE_DATASIZE: usize = 4; const _PyDateTime_TIME_DATASIZE: usize = 6; @@ -350,7 +350,7 @@ pub unsafe fn PyDateTime_DELTA_GET_MICROSECONDS(o: *mut PyObject) -> c_int { // but copying them seems suboptimal #[inline] #[cfg(GraalPy)] -pub unsafe fn _get_attr(obj: *mut PyObject, field: &std::ffi::CStr) -> c_int { +pub unsafe fn _get_attr(obj: *mut PyObject, field: &core::ffi::CStr) -> c_int { let result = PyObject_GetAttrString(obj, field.as_ptr()); Py_DecRef(result); // the original macros are borrowing if PyLong_Check(result) == 1 { @@ -803,7 +803,7 @@ pub unsafe fn PyDelta_FromDSU(days: c_int, seconds: c_int, microseconds: c_int) } pub unsafe fn PyTimeZone_FromOffset(offset: *mut PyObject) -> *mut PyObject { - ((*PyDateTimeAPI()).TimeZone_FromTimeZone)(offset, std::ptr::null_mut()) + ((*PyDateTimeAPI()).TimeZone_FromTimeZone)(offset, core::ptr::null_mut()) } pub unsafe fn PyTimeZone_FromOffsetAndName( @@ -816,7 +816,7 @@ pub unsafe fn PyTimeZone_FromOffsetAndName( #[cfg(not(PyPy))] pub unsafe fn PyDateTime_FromTimestamp(args: *mut PyObject) -> *mut PyObject { let f = (*PyDateTimeAPI()).DateTime_FromTimestamp; - f((*PyDateTimeAPI()).DateTimeType, args, std::ptr::null_mut()) + f((*PyDateTimeAPI()).DateTimeType, args, core::ptr::null_mut()) } #[cfg(not(PyPy))] diff --git a/pyo3-ffi/src/descrobject.rs b/pyo3-ffi/src/descrobject.rs index 91626733ca2..cd65e7b6a92 100644 --- a/pyo3-ffi/src/descrobject.rs +++ b/pyo3-ffi/src/descrobject.rs @@ -1,8 +1,8 @@ use crate::methodobject::PyMethodDef; use crate::object::{PyObject, PyTypeObject}; use crate::Py_ssize_t; -use std::ffi::{c_char, c_int, c_void}; -use std::ptr; +use core::ffi::{c_char, c_int, c_void}; +use core::ptr; pub type getter = unsafe extern "C" fn(slf: *mut PyObject, closure: *mut c_void) -> *mut PyObject; pub type setter = diff --git a/pyo3-ffi/src/dictobject.rs b/pyo3-ffi/src/dictobject.rs index cf587fb97a3..fec8f459e75 100644 --- a/pyo3-ffi/src/dictobject.rs +++ b/pyo3-ffi/src/dictobject.rs @@ -1,6 +1,6 @@ use crate::object::*; use crate::pyport::Py_ssize_t; -use std::ffi::{c_char, c_int}; +use core::ffi::{c_char, c_int}; #[cfg(not(RustPython))] extern_libpython! { diff --git a/pyo3-ffi/src/fileobject.rs b/pyo3-ffi/src/fileobject.rs index be3492e9192..537e998bafa 100644 --- a/pyo3-ffi/src/fileobject.rs +++ b/pyo3-ffi/src/fileobject.rs @@ -1,5 +1,5 @@ use crate::object::PyObject; -use std::ffi::{c_char, c_int}; +use core::ffi::{c_char, c_int}; pub const PY_STDIOTEXTMODE: &str = "b"; diff --git a/pyo3-ffi/src/fileutils.rs b/pyo3-ffi/src/fileutils.rs index 518e2ed9fd3..c80570c6633 100644 --- a/pyo3-ffi/src/fileutils.rs +++ b/pyo3-ffi/src/fileutils.rs @@ -1,6 +1,6 @@ use crate::pyport::Py_ssize_t; +use core::ffi::c_char; use libc::wchar_t; -use std::ffi::c_char; extern_libpython! { pub fn Py_DecodeLocale(arg1: *const c_char, size: *mut Py_ssize_t) -> *mut wchar_t; diff --git a/pyo3-ffi/src/floatobject.rs b/pyo3-ffi/src/floatobject.rs index fa153a384a5..5597d6d2922 100644 --- a/pyo3-ffi/src/floatobject.rs +++ b/pyo3-ffi/src/floatobject.rs @@ -1,5 +1,5 @@ use crate::object::*; -use std::ffi::{c_double, c_int}; +use core::ffi::{c_double, c_int}; #[cfg(Py_LIMITED_API)] // TODO: remove (see https://github.com/PyO3/pyo3/pull/1341#issuecomment-751515985) diff --git a/pyo3-ffi/src/impl_/mod.rs b/pyo3-ffi/src/impl_/mod.rs index 064df213ba6..df759d25207 100644 --- a/pyo3-ffi/src/impl_/mod.rs +++ b/pyo3-ffi/src/impl_/mod.rs @@ -6,14 +6,14 @@ mod atomic_c_ulong { type Type; } impl AtomicCULongType for GetAtomicCULong<32> { - type Type = std::sync::atomic::AtomicU32; + type Type = core::sync::atomic::AtomicU32; } impl AtomicCULongType for GetAtomicCULong<64> { - type Type = std::sync::atomic::AtomicU64; + type Type = core::sync::atomic::AtomicU64; } pub type TYPE = - () * 8 }> as AtomicCULongType>::Type; + () * 8 }> as AtomicCULongType>::Type; } /// Typedef for an atomic integer to match the platform-dependent c_ulong type. diff --git a/pyo3-ffi/src/import.rs b/pyo3-ffi/src/import.rs index d54a0baed51..9219e31909d 100644 --- a/pyo3-ffi/src/import.rs +++ b/pyo3-ffi/src/import.rs @@ -1,5 +1,5 @@ use crate::object::PyObject; -use std::ffi::{c_char, c_int, c_long}; +use core::ffi::{c_char, c_int, c_long}; extern_libpython! { pub fn PyImport_GetMagicNumber() -> c_long; diff --git a/pyo3-ffi/src/intrcheck.rs b/pyo3-ffi/src/intrcheck.rs index 13dacf59ae9..32702d171a8 100644 --- a/pyo3-ffi/src/intrcheck.rs +++ b/pyo3-ffi/src/intrcheck.rs @@ -1,4 +1,4 @@ -use std::ffi::c_int; +use core::ffi::c_int; extern_libpython! { #[cfg_attr(PyPy, link_name = "PyPyOS_InterruptOccurred")] diff --git a/pyo3-ffi/src/iterobject.rs b/pyo3-ffi/src/iterobject.rs index ed29e4a5b40..4236a6be48f 100644 --- a/pyo3-ffi/src/iterobject.rs +++ b/pyo3-ffi/src/iterobject.rs @@ -1,5 +1,5 @@ use crate::object::*; -use std::ffi::c_int; +use core::ffi::c_int; #[cfg(not(RustPython))] extern_libpython! { diff --git a/pyo3-ffi/src/lib.rs b/pyo3-ffi/src/lib.rs index 823f4e47ddf..95cae0a4d1f 100644 --- a/pyo3-ffi/src/lib.rs +++ b/pyo3-ffi/src/lib.rs @@ -127,9 +127,9 @@ //! **`src/lib.rs`** //! ```rust,no_run //! #[cfg(Py_3_15)] -//! use std::ffi::c_void; -//! use std::ffi::{c_char, c_long}; -//! use std::ptr; +//! use core::ffi::c_void; +//! use core::ffi::{c_char, c_long}; +//! use core::ptr; //! //! use pyo3_ffi::*; //! @@ -256,7 +256,7 @@ //! let mut size = 0; //! let p = PyUnicode_AsUTF8AndSize(obj_repr, &mut size); //! if !p.is_null() { -//! let s = std::str::from_utf8_unchecked(std::slice::from_raw_parts( +//! let s = core::str::from_utf8_unchecked(core::slice::from_raw_parts( //! p.cast::(), //! size as usize, //! )); @@ -278,18 +278,18 @@ //! PyExc_TypeError, //! c"sum_as_string expected 2 positional arguments".as_ptr(), //! ); -//! return std::ptr::null_mut(); +//! return core::ptr::null_mut(); //! } //! //! let (first, second) = (*args, *args.add(1)); //! //! let first = match parse_arg_as_i32(first, 1) { //! Some(x) => x, -//! None => return std::ptr::null_mut(), +//! None => return core::ptr::null_mut(), //! }; //! let second = match parse_arg_as_i32(second, 2) { //! Some(x) => x, -//! None => return std::ptr::null_mut(), +//! None => return core::ptr::null_mut(), //! }; //! //! match first.checked_add(second) { @@ -299,7 +299,7 @@ //! } //! None => { //! PyErr_SetString(PyExc_OverflowError, c"arguments too large to add".as_ptr()); -//! std::ptr::null_mut() +//! core::ptr::null_mut() //! } //! } //! } @@ -399,7 +399,7 @@ macro_rules! opaque_struct { /// Examples: /// /// ```rust,no_run -/// use std::ffi::CStr; +/// use core::ffi::CStr; /// /// const HELLO: &CStr = pyo3_ffi::c_str!("hello"); /// static WORLD: &CStr = pyo3_ffi::c_str!("world"); @@ -414,8 +414,8 @@ macro_rules! c_str { /// Private helper for `c_str!` macro. #[doc(hidden)] -pub const fn _cstr_from_utf8_with_nul_checked(s: &str) -> &std::ffi::CStr { - match std::ffi::CStr::from_bytes_with_nul(s.as_bytes()) { +pub const fn _cstr_from_utf8_with_nul_checked(s: &str) -> &core::ffi::CStr { + match core::ffi::CStr::from_bytes_with_nul(s.as_bytes()) { Ok(cstr) => cstr, Err(_) => panic!("string contains nul bytes"), } diff --git a/pyo3-ffi/src/listobject.rs b/pyo3-ffi/src/listobject.rs index d0250be81b4..ed5f1cd5f7c 100644 --- a/pyo3-ffi/src/listobject.rs +++ b/pyo3-ffi/src/listobject.rs @@ -1,6 +1,6 @@ use crate::object::*; use crate::pyport::Py_ssize_t; -use std::ffi::c_int; +use core::ffi::c_int; #[cfg(not(RustPython))] extern_libpython! { diff --git a/pyo3-ffi/src/longobject.rs b/pyo3-ffi/src/longobject.rs index 5e488076e41..fda262ba0af 100644 --- a/pyo3-ffi/src/longobject.rs +++ b/pyo3-ffi/src/longobject.rs @@ -1,7 +1,7 @@ use crate::object::*; use crate::pyport::Py_ssize_t; +use core::ffi::{c_char, c_double, c_int, c_long, c_longlong, c_ulong, c_ulonglong, c_void}; use libc::size_t; -use std::ffi::{c_char, c_double, c_int, c_long, c_longlong, c_ulong, c_ulonglong, c_void}; opaque_struct!(pub PyLongObject); diff --git a/pyo3-ffi/src/memoryobject.rs b/pyo3-ffi/src/memoryobject.rs index c2829459e3a..7ebc2a211d7 100644 --- a/pyo3-ffi/src/memoryobject.rs +++ b/pyo3-ffi/src/memoryobject.rs @@ -1,6 +1,6 @@ use crate::object::*; use crate::pyport::Py_ssize_t; -use std::ffi::{c_char, c_int}; +use core::ffi::{c_char, c_int}; // skipped _PyManagedBuffer_Type diff --git a/pyo3-ffi/src/methodobject.rs b/pyo3-ffi/src/methodobject.rs index f3b8b898618..77f96903564 100644 --- a/pyo3-ffi/src/methodobject.rs +++ b/pyo3-ffi/src/methodobject.rs @@ -4,8 +4,8 @@ use crate::object::{PyObject, PyTypeObject}; use crate::PyObject_TypeCheck; #[cfg(not(RustPython))] use crate::Py_IS_TYPE; -use std::ffi::{c_char, c_int, c_void}; -use std::{mem, ptr}; +use core::ffi::{c_char, c_int, c_void}; +use core::{mem, ptr}; #[cfg(all(Py_3_9, not(Py_LIMITED_API), not(GraalPy)))] pub struct PyCFunctionObject { @@ -206,10 +206,10 @@ impl PartialEq for PyMethodDefPointer { } } -impl std::fmt::Pointer for PyMethodDefPointer { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { +impl core::fmt::Pointer for PyMethodDefPointer { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { let ptr = unsafe { self.Void }; - std::fmt::Pointer::fmt(&ptr, f) + core::fmt::Pointer::fmt(&ptr, f) } } @@ -232,7 +232,7 @@ extern_libpython! { #[cfg(Py_3_9)] #[inline] pub unsafe fn PyCFunction_New(ml: *mut PyMethodDef, slf: *mut PyObject) -> *mut PyObject { - PyCFunction_NewEx(ml, slf, std::ptr::null_mut()) + PyCFunction_NewEx(ml, slf, core::ptr::null_mut()) } #[cfg(Py_3_9)] @@ -242,7 +242,7 @@ pub unsafe fn PyCFunction_NewEx( slf: *mut PyObject, module: *mut PyObject, ) -> *mut PyObject { - PyCMethod_New(ml, slf, module, std::ptr::null_mut()) + PyCMethod_New(ml, slf, module, core::ptr::null_mut()) } #[cfg(Py_3_9)] diff --git a/pyo3-ffi/src/modsupport.rs b/pyo3-ffi/src/modsupport.rs index 4697be5bb5b..447b705f6fd 100644 --- a/pyo3-ffi/src/modsupport.rs +++ b/pyo3-ffi/src/modsupport.rs @@ -2,7 +2,7 @@ use crate::methodobject::PyMethodDef; use crate::moduleobject::PyModuleDef; use crate::object::PyObject; use crate::pyport::Py_ssize_t; -use std::ffi::{c_char, c_int, c_long}; +use core::ffi::{c_char, c_int, c_long}; extern_libpython! { #[cfg_attr(PyPy, link_name = "PyPyArg_Parse")] diff --git a/pyo3-ffi/src/moduleobject.rs b/pyo3-ffi/src/moduleobject.rs index 94f4e9286f5..6bff9b03719 100644 --- a/pyo3-ffi/src/moduleobject.rs +++ b/pyo3-ffi/src/moduleobject.rs @@ -1,7 +1,7 @@ use crate::methodobject::PyMethodDef; use crate::object::*; use crate::pyport::Py_ssize_t; -use std::ffi::{c_char, c_int, c_void}; +use core::ffi::{c_char, c_int, c_void}; #[cfg(not(RustPython))] extern_libpython! { @@ -73,7 +73,7 @@ pub const PyModuleDef_HEAD_INIT: PyModuleDef_Base = PyModuleDef_Base { ob_base: PyObject_HEAD_INIT, m_init: None, m_index: 0, - m_copy: std::ptr::null_mut(), + m_copy: core::ptr::null_mut(), }; #[repr(C)] @@ -87,7 +87,7 @@ impl Default for PyModuleDef_Slot { fn default() -> PyModuleDef_Slot { PyModuleDef_Slot { slot: 0, - value: std::ptr::null_mut(), + value: core::ptr::null_mut(), } } } diff --git a/pyo3-ffi/src/object.rs b/pyo3-ffi/src/object.rs index 2e4f82e9e28..2a074717215 100644 --- a/pyo3-ffi/src/object.rs +++ b/pyo3-ffi/src/object.rs @@ -3,10 +3,10 @@ use crate::pyport::{Py_hash_t, Py_ssize_t}; use crate::refcount; #[cfg(Py_GIL_DISABLED)] use crate::PyMutex; -use std::ffi::{c_char, c_int, c_uint, c_ulong, c_void}; -use std::mem; +use core::ffi::{c_char, c_int, c_uint, c_ulong, c_void}; +use core::mem; #[cfg(Py_GIL_DISABLED)] -use std::sync::atomic::{AtomicIsize, AtomicU32}; +use core::sync::atomic::{AtomicIsize, AtomicU32}; #[cfg(Py_LIMITED_API)] opaque_struct!(pub PyTypeObject); @@ -73,8 +73,8 @@ pub union PyObjectObRefcnt { } #[cfg(all(Py_3_12, not(Py_GIL_DISABLED)))] -impl std::fmt::Debug for PyObjectObRefcnt { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { +impl core::fmt::Debug for PyObjectObRefcnt { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { write!(f, "{}", unsafe { self.ob_refcnt }) } } @@ -116,7 +116,7 @@ pub struct PyObject { pub ob_type: *mut PyTypeObject, } -const _: () = assert!(std::mem::align_of::() >= _PyObject_MIN_ALIGNMENT); +const _: () = assert!(core::mem::align_of::() >= _PyObject_MIN_ALIGNMENT); #[allow( clippy::declare_interior_mutable_const, @@ -145,7 +145,7 @@ pub const PyObject_HEAD_INIT: PyObject = PyObject { ob_refcnt: 1, #[cfg(PyPy)] ob_pypy_link: 0, - ob_type: std::ptr::null_mut(), + ob_type: core::ptr::null_mut(), }; // skipped _Py_UNOWNED_TID @@ -696,7 +696,7 @@ pub unsafe fn PyType_HasFeature(ty: *mut PyTypeObject, feature: c_ulong) -> c_in let flags = PyType_GetFlags(ty); #[cfg(all(not(Py_LIMITED_API), Py_GIL_DISABLED))] - let flags = (*ty).tp_flags.load(std::sync::atomic::Ordering::Relaxed); + let flags = (*ty).tp_flags.load(core::sync::atomic::Ordering::Relaxed); #[cfg(all(not(Py_LIMITED_API), not(Py_GIL_DISABLED)))] let flags = (*ty).tp_flags; diff --git a/pyo3-ffi/src/objimpl.rs b/pyo3-ffi/src/objimpl.rs index b135d8d2155..bad80a1eae2 100644 --- a/pyo3-ffi/src/objimpl.rs +++ b/pyo3-ffi/src/objimpl.rs @@ -1,5 +1,5 @@ +use core::ffi::{c_int, c_void}; use libc::size_t; -use std::ffi::{c_int, c_void}; use crate::object::*; use crate::pyport::Py_ssize_t; diff --git a/pyo3-ffi/src/pybuffer.rs b/pyo3-ffi/src/pybuffer.rs index ff9fae3100a..83975c744e1 100644 --- a/pyo3-ffi/src/pybuffer.rs +++ b/pyo3-ffi/src/pybuffer.rs @@ -1,7 +1,7 @@ use crate::object::PyObject; use crate::pyport::Py_ssize_t; -use std::ffi::{c_char, c_int, c_void}; -use std::ptr; +use core::ffi::{c_char, c_int, c_void}; +use core::ptr; #[repr(C)] #[derive(Copy, Clone)] diff --git a/pyo3-ffi/src/pycapsule.rs b/pyo3-ffi/src/pycapsule.rs index 3beeb4bfafc..a5a3df91057 100644 --- a/pyo3-ffi/src/pycapsule.rs +++ b/pyo3-ffi/src/pycapsule.rs @@ -1,5 +1,5 @@ use crate::object::*; -use std::ffi::{c_char, c_int, c_void}; +use core::ffi::{c_char, c_int, c_void}; #[cfg(not(RustPython))] extern_libpython! { diff --git a/pyo3-ffi/src/pyerrors.rs b/pyo3-ffi/src/pyerrors.rs index 01b15133971..505c4806a35 100644 --- a/pyo3-ffi/src/pyerrors.rs +++ b/pyo3-ffi/src/pyerrors.rs @@ -1,6 +1,6 @@ use crate::object::*; use crate::pyport::Py_ssize_t; -use std::ffi::{c_char, c_int}; +use core::ffi::{c_char, c_int}; extern_libpython! { #[cfg_attr(PyPy, link_name = "PyPyErr_SetNone")] diff --git a/pyo3-ffi/src/pyframe.rs b/pyo3-ffi/src/pyframe.rs index cce6fe2f17e..fca98ac5cbe 100644 --- a/pyo3-ffi/src/pyframe.rs +++ b/pyo3-ffi/src/pyframe.rs @@ -2,7 +2,7 @@ #[cfg(any(Py_3_10, all(Py_3_9, not(Py_LIMITED_API))))] use crate::PyCodeObject; use crate::PyFrameObject; -use std::ffi::c_int; +use core::ffi::c_int; extern_libpython! { pub fn PyFrame_GetLineNumber(frame: *mut PyFrameObject) -> c_int; diff --git a/pyo3-ffi/src/pyhash.rs b/pyo3-ffi/src/pyhash.rs index b96c40a11e5..ca39071dbbf 100644 --- a/pyo3-ffi/src/pyhash.rs +++ b/pyo3-ffi/src/pyhash.rs @@ -1,9 +1,9 @@ #[cfg(not(any(Py_LIMITED_API, PyPy)))] use crate::pyport::{Py_hash_t, Py_ssize_t}; #[cfg(not(any(Py_LIMITED_API, PyPy)))] -use std::ffi::c_void; +use core::ffi::c_void; -use std::ffi::{c_int, c_ulong}; +use core::ffi::{c_int, c_ulong}; extern_libpython! { // skipped non-limited _Py_HashDouble diff --git a/pyo3-ffi/src/pylifecycle.rs b/pyo3-ffi/src/pylifecycle.rs index 9f1104c4484..abcbdf0b08d 100644 --- a/pyo3-ffi/src/pylifecycle.rs +++ b/pyo3-ffi/src/pylifecycle.rs @@ -1,7 +1,7 @@ use crate::pytypedefs::PyThreadState; +use core::ffi::{c_char, c_int}; use libc::wchar_t; -use std::ffi::{c_char, c_int}; extern_libpython! { pub fn Py_Initialize(); @@ -91,7 +91,7 @@ extern_libpython! { pub fn PyOS_setsig(arg1: c_int, arg2: PyOS_sighandler_t) -> PyOS_sighandler_t; #[cfg(Py_3_11)] - pub static Py_Version: std::ffi::c_ulong; + pub static Py_Version: core::ffi::c_ulong; #[cfg(Py_3_13)] pub fn Py_IsFinalizing() -> c_int; diff --git a/pyo3-ffi/src/pymem.rs b/pyo3-ffi/src/pymem.rs index 9654c7246f0..45e57ef1db6 100644 --- a/pyo3-ffi/src/pymem.rs +++ b/pyo3-ffi/src/pymem.rs @@ -1,5 +1,5 @@ +use core::ffi::c_void; use libc::size_t; -use std::ffi::c_void; extern_libpython! { #[cfg_attr(PyPy, link_name = "PyPyMem_Malloc")] diff --git a/pyo3-ffi/src/pyport.rs b/pyo3-ffi/src/pyport.rs index 3a066353ca4..db102368ecf 100644 --- a/pyo3-ffi/src/pyport.rs +++ b/pyo3-ffi/src/pyport.rs @@ -1,7 +1,7 @@ // NB libc does not define this constant on all platforms, so we hard code it // like CPython does. // https://github.com/python/cpython/blob/d8b9011702443bb57579f8834f3effe58e290dfc/Include/pyport.h#L372 -pub const INT_MAX: std::ffi::c_int = 2147483647; +pub const INT_MAX: core::ffi::c_int = 2147483647; pub type PY_UINT32_T = u32; pub type PY_UINT64_T = u64; diff --git a/pyo3-ffi/src/pystate.rs b/pyo3-ffi/src/pystate.rs index 381862964b5..5bb821db9a5 100644 --- a/pyo3-ffi/src/pystate.rs +++ b/pyo3-ffi/src/pystate.rs @@ -1,14 +1,14 @@ use crate::moduleobject::PyModuleDef; use crate::object::PyObject; use crate::pytypedefs::{PyInterpreterState, PyThreadState}; -use std::ffi::c_int; +use core::ffi::c_int; #[cfg(any(all(Py_3_9, not(Py_LIMITED_API)), Py_3_10))] #[cfg(not(PyPy))] use crate::PyFrameObject; #[cfg(not(PyPy))] -use std::ffi::c_long; +use core::ffi::c_long; pub const MAX_CO_EXTRA_USERS: c_int = 255; @@ -135,7 +135,7 @@ pub unsafe extern "C" fn PyGILState_Ensure() -> PyGILState_STATE { // nothing we can do it other than waiting for Python 3.14 or not using Windows. At least, // if there is nothing pinned on the stack, it won't cause the process to crash. let ret: PyGILState_STATE = raw::PyGILState_Ensure(); - std::mem::forget(guard); + core::mem::forget(guard); ret } diff --git a/pyo3-ffi/src/pystrtod.rs b/pyo3-ffi/src/pystrtod.rs index e890896d41d..43ac27b26cd 100644 --- a/pyo3-ffi/src/pystrtod.rs +++ b/pyo3-ffi/src/pystrtod.rs @@ -1,5 +1,5 @@ use crate::object::PyObject; -use std::ffi::{c_char, c_double, c_int}; +use core::ffi::{c_char, c_double, c_int}; extern_libpython! { #[cfg_attr(PyPy, link_name = "PyPyOS_string_to_double")] diff --git a/pyo3-ffi/src/pythonrun.rs b/pyo3-ffi/src/pythonrun.rs index df9095c670e..91c12a1931c 100644 --- a/pyo3-ffi/src/pythonrun.rs +++ b/pyo3-ffi/src/pythonrun.rs @@ -1,9 +1,9 @@ use crate::object::*; +#[cfg(any(Py_LIMITED_API, not(Py_3_10), PyPy, GraalPy))] +use core::ffi::c_char; +use core::ffi::c_int; #[cfg(not(any(PyPy, Py_LIMITED_API, Py_3_10)))] use libc::FILE; -#[cfg(any(Py_LIMITED_API, not(Py_3_10), PyPy, GraalPy))] -use std::ffi::c_char; -use std::ffi::c_int; extern_libpython! { #[cfg(any(all(Py_LIMITED_API, not(PyPy)), GraalPy))] @@ -33,13 +33,13 @@ pub unsafe fn Py_CompileString(string: *const c_char, p: *const c_char, s: c_int string: *const c_char, p: *const c_char, s: c_int, - f: *mut std::ffi::c_void, // Actually *mut Py_CompilerFlags in the real definition + f: *mut core::ffi::c_void, // Actually *mut Py_CompilerFlags in the real definition ) -> *mut PyObject; } #[cfg(not(Py_LIMITED_API))] use crate::Py_CompileStringFlags; - Py_CompileStringFlags(string, p, s, std::ptr::null_mut()) + Py_CompileStringFlags(string, p, s, core::ptr::null_mut()) } // skipped PyOS_InputHook diff --git a/pyo3-ffi/src/rangeobject.rs b/pyo3-ffi/src/rangeobject.rs index b1e0318a178..ffecd07eb32 100644 --- a/pyo3-ffi/src/rangeobject.rs +++ b/pyo3-ffi/src/rangeobject.rs @@ -1,5 +1,5 @@ use crate::object::*; -use std::ffi::c_int; +use core::ffi::c_int; extern_libpython! { #[cfg(not(RustPython))] diff --git a/pyo3-ffi/src/refcount.rs b/pyo3-ffi/src/refcount.rs index d404660b03a..875e3e5d30d 100644 --- a/pyo3-ffi/src/refcount.rs +++ b/pyo3-ffi/src/refcount.rs @@ -1,18 +1,18 @@ use crate::pyport::Py_ssize_t; use crate::PyObject; #[cfg(all(not(Py_LIMITED_API), py_sys_config = "Py_REF_DEBUG"))] -use std::ffi::c_char; +use core::ffi::c_char; #[cfg(any(Py_3_12, all(py_sys_config = "Py_REF_DEBUG", not(Py_LIMITED_API))))] -use std::ffi::c_int; +use core::ffi::c_int; #[cfg(all(Py_3_14, any(not(Py_GIL_DISABLED), target_pointer_width = "32")))] -use std::ffi::c_long; +use core::ffi::c_long; #[cfg(any(Py_GIL_DISABLED, all(Py_3_12, not(Py_3_14))))] -use std::ffi::c_uint; +use core::ffi::c_uint; #[cfg(all(Py_3_14, not(Py_GIL_DISABLED)))] -use std::ffi::c_ulong; -use std::ptr; +use core::ffi::c_ulong; +use core::ptr; #[cfg(Py_GIL_DISABLED)] -use std::sync::atomic::Ordering::Relaxed; +use core::sync::atomic::Ordering::Relaxed; #[cfg(all(Py_3_14, not(Py_3_15)))] const _Py_STATICALLY_ALLOCATED_FLAG: c_int = 1 << 7; @@ -298,8 +298,8 @@ pub unsafe fn Py_DECREF(op: *mut PyObject) { #[cfg(py_sys_config = "Py_REF_DEBUG")] if (*op).ob_refcnt.ob_refcnt < 0 { - let location = std::panic::Location::caller(); - let filename = std::ffi::CString::new(location.file()).unwrap(); + let location = core::panic::Location::caller(); + let filename = core::ffi::CString::new(location.file()).unwrap(); _Py_NegativeRefcount(filename.as_ptr(), location.line() as i32, op); } diff --git a/pyo3-ffi/src/setobject.rs b/pyo3-ffi/src/setobject.rs index 42f5247791b..8fcb3006fcc 100644 --- a/pyo3-ffi/src/setobject.rs +++ b/pyo3-ffi/src/setobject.rs @@ -2,7 +2,7 @@ use crate::object::*; #[cfg(not(any(Py_LIMITED_API, PyPy, GraalPy)))] use crate::pyport::Py_hash_t; use crate::pyport::Py_ssize_t; -use std::ffi::c_int; +use core::ffi::c_int; pub const PySet_MINSIZE: usize = 8; diff --git a/pyo3-ffi/src/sliceobject.rs b/pyo3-ffi/src/sliceobject.rs index bab7a0a3338..175a65f0622 100644 --- a/pyo3-ffi/src/sliceobject.rs +++ b/pyo3-ffi/src/sliceobject.rs @@ -1,6 +1,6 @@ use crate::object::*; use crate::pyport::Py_ssize_t; -use std::ffi::c_int; +use core::ffi::c_int; extern_libpython! { #[cfg(all(not(GraalPy), not(all(Py_3_13, Py_LIMITED_API))))] diff --git a/pyo3-ffi/src/structmember.rs b/pyo3-ffi/src/structmember.rs index 4aa6c24db4f..7b2948272a6 100644 --- a/pyo3-ffi/src/structmember.rs +++ b/pyo3-ffi/src/structmember.rs @@ -1,4 +1,4 @@ -use std::ffi::c_int; +use core::ffi::c_int; pub use crate::PyMemberDef; diff --git a/pyo3-ffi/src/structseq.rs b/pyo3-ffi/src/structseq.rs index 70a97f5b215..7a1a70015a8 100644 --- a/pyo3-ffi/src/structseq.rs +++ b/pyo3-ffi/src/structseq.rs @@ -1,7 +1,7 @@ use crate::object::{PyObject, PyTypeObject}; #[cfg(not(PyPy))] use crate::pyport::Py_ssize_t; -use std::ffi::{c_char, c_int}; +use core::ffi::{c_char, c_int}; #[repr(C)] #[derive(Copy, Clone)] diff --git a/pyo3-ffi/src/sysmodule.rs b/pyo3-ffi/src/sysmodule.rs index c722cbd543e..46985dc116e 100644 --- a/pyo3-ffi/src/sysmodule.rs +++ b/pyo3-ffi/src/sysmodule.rs @@ -1,6 +1,6 @@ use crate::object::PyObject; +use core::ffi::{c_char, c_int}; use libc::wchar_t; -use std::ffi::{c_char, c_int}; extern_libpython! { #[cfg_attr(PyPy, link_name = "PyPySys_GetObject")] diff --git a/pyo3-ffi/src/traceback.rs b/pyo3-ffi/src/traceback.rs index b286f5520b9..9cfb11dcb9d 100644 --- a/pyo3-ffi/src/traceback.rs +++ b/pyo3-ffi/src/traceback.rs @@ -1,5 +1,5 @@ use crate::object::*; -use std::ffi::c_int; +use core::ffi::c_int; extern_libpython! { #[cfg_attr(PyPy, link_name = "PyPyTraceBack_Here")] diff --git a/pyo3-ffi/src/tupleobject.rs b/pyo3-ffi/src/tupleobject.rs index 253ac91b19a..e415eabfe66 100644 --- a/pyo3-ffi/src/tupleobject.rs +++ b/pyo3-ffi/src/tupleobject.rs @@ -1,6 +1,6 @@ use crate::object::*; use crate::pyport::Py_ssize_t; -use std::ffi::c_int; +use core::ffi::c_int; #[cfg(not(RustPython))] extern_libpython! { diff --git a/pyo3-ffi/src/typeslots.rs b/pyo3-ffi/src/typeslots.rs index fd0c3b77a74..d913a2880b1 100644 --- a/pyo3-ffi/src/typeslots.rs +++ b/pyo3-ffi/src/typeslots.rs @@ -1,4 +1,4 @@ -use std::ffi::c_int; +use core::ffi::c_int; pub const Py_bf_getbuffer: c_int = 1; pub const Py_bf_releasebuffer: c_int = 2; diff --git a/pyo3-ffi/src/unicodeobject.rs b/pyo3-ffi/src/unicodeobject.rs index cbb867759ef..1f48cc5ecfd 100644 --- a/pyo3-ffi/src/unicodeobject.rs +++ b/pyo3-ffi/src/unicodeobject.rs @@ -1,7 +1,7 @@ use crate::object::*; use crate::pyport::Py_ssize_t; +use core::ffi::{c_char, c_int, c_void}; use libc::wchar_t; -use std::ffi::{c_char, c_int, c_void}; #[cfg(not(Py_LIMITED_API))] #[cfg_attr( diff --git a/pyo3-ffi/src/warnings.rs b/pyo3-ffi/src/warnings.rs index 169e3a54819..4277c4daf84 100644 --- a/pyo3-ffi/src/warnings.rs +++ b/pyo3-ffi/src/warnings.rs @@ -1,6 +1,6 @@ use crate::object::PyObject; use crate::pyport::Py_ssize_t; -use std::ffi::{c_char, c_int}; +use core::ffi::{c_char, c_int}; extern_libpython! { #[cfg_attr(PyPy, link_name = "PyPyErr_WarnEx")] diff --git a/pyo3-ffi/src/weakrefobject.rs b/pyo3-ffi/src/weakrefobject.rs index 1583a02511f..04dfec3e07c 100644 --- a/pyo3-ffi/src/weakrefobject.rs +++ b/pyo3-ffi/src/weakrefobject.rs @@ -1,5 +1,5 @@ use crate::object::*; -use std::ffi::c_int; +use core::ffi::c_int; #[cfg(all(not(PyPy), Py_LIMITED_API, not(GraalPy)))] opaque_struct!(pub PyWeakReference); From 82647a0477b1bd271abfcd66b5060558dde0244f Mon Sep 17 00:00:00 2001 From: person93 Date: Fri, 8 May 2026 17:35:52 -0400 Subject: [PATCH 2/7] make ffi crate no_std --- pyo3-ffi/src/lib.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/pyo3-ffi/src/lib.rs b/pyo3-ffi/src/lib.rs index 95cae0a4d1f..f13bc042f65 100644 --- a/pyo3-ffi/src/lib.rs +++ b/pyo3-ffi/src/lib.rs @@ -1,3 +1,4 @@ +#![no_std] #![cfg_attr(docsrs, feature(doc_cfg))] //! Raw FFI declarations for Python's C API. //! From e4677a3071fe13e77608a4ca00b6ea839519b978 Mon Sep 17 00:00:00 2001 From: person93 Date: Fri, 8 May 2026 17:57:34 -0400 Subject: [PATCH 3/7] added newsfragment --- newsfragments/6022.added.md | 1 + 1 file changed, 1 insertion(+) create mode 100644 newsfragments/6022.added.md diff --git a/newsfragments/6022.added.md b/newsfragments/6022.added.md new file mode 100644 index 00000000000..77679e39348 --- /dev/null +++ b/newsfragments/6022.added.md @@ -0,0 +1 @@ +Made `python_ffi` crate `no_std`. From f33c321b760d3a2e06968f2dd3dd6228c2e1b5e5 Mon Sep 17 00:00:00 2001 From: person93 Date: Sat, 9 May 2026 23:18:53 -0400 Subject: [PATCH 4/7] conditionally include `std` in the ffi crate --- pyo3-ffi/src/lib.rs | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/pyo3-ffi/src/lib.rs b/pyo3-ffi/src/lib.rs index f13bc042f65..dadf304922b 100644 --- a/pyo3-ffi/src/lib.rs +++ b/pyo3-ffi/src/lib.rs @@ -371,6 +371,11 @@ clippy::missing_safety_doc, clippy::ptr_eq )] +#![warn( + clippy::alloc_instead_of_core, + clippy::std_instead_of_alloc, + clippy::std_instead_of_core +)] #![warn(elided_lifetimes_in_paths, unused_lifetimes)] // This crate is a hand-maintained translation of CPython's headers, so requiring "unsafe" // blocks within those translations increases maintenance burden without providing any @@ -378,6 +383,9 @@ // original CPython headers #![allow(unsafe_op_in_unsafe_fn)] +#[cfg(not(any(Py_3_14, target_arch = "wasm32")))] +extern crate std; + // Until `extern type` is stabilized, use the recommended approach to // model opaque types: // https://doc.rust-lang.org/nomicon/ffi.html#representing-opaque-structs From 28f84be754908c8ea035f1f58d96cf65697296cc Mon Sep 17 00:00:00 2001 From: person93 Date: Mon, 11 May 2026 10:37:15 -0400 Subject: [PATCH 5/7] Update newsfragments/6022.added.md Co-authored-by: David Hewitt --- newsfragments/6022.added.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/newsfragments/6022.added.md b/newsfragments/6022.added.md index 77679e39348..21682bcec85 100644 --- a/newsfragments/6022.added.md +++ b/newsfragments/6022.added.md @@ -1 +1 @@ -Made `python_ffi` crate `no_std`. +Made `pyo3-ffi` crate `no_std`. From 5768e8f80235ff375961bdbd8f8a289cb100fc1f Mon Sep 17 00:00:00 2001 From: person93 Date: Mon, 11 May 2026 11:14:00 -0400 Subject: [PATCH 6/7] fix bad import from core --- pyo3-ffi/src/refcount.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyo3-ffi/src/refcount.rs b/pyo3-ffi/src/refcount.rs index 875e3e5d30d..9e9efb5f519 100644 --- a/pyo3-ffi/src/refcount.rs +++ b/pyo3-ffi/src/refcount.rs @@ -299,7 +299,7 @@ pub unsafe fn Py_DECREF(op: *mut PyObject) { #[cfg(py_sys_config = "Py_REF_DEBUG")] if (*op).ob_refcnt.ob_refcnt < 0 { let location = core::panic::Location::caller(); - let filename = core::ffi::CString::new(location.file()).unwrap(); + let filename = std::ffi::CString::new(location.file()).unwrap(); _Py_NegativeRefcount(filename.as_ptr(), location.line() as i32, op); } From ee47c67af6d9191117928594e5ad2b76f699b83c Mon Sep 17 00:00:00 2001 From: David Hewitt Date: Tue, 12 May 2026 07:13:10 +0100 Subject: [PATCH 7/7] fix use of `std` in `Py_REF_DEBUG` build --- pyo3-ffi/src/lib.rs | 2 ++ pyo3-ffi/src/refcount.rs | 2 +- 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/pyo3-ffi/src/lib.rs b/pyo3-ffi/src/lib.rs index a790685b0b7..8f63e7f26ed 100644 --- a/pyo3-ffi/src/lib.rs +++ b/pyo3-ffi/src/lib.rs @@ -377,6 +377,8 @@ // original CPython headers #![allow(unsafe_op_in_unsafe_fn)] +#[cfg(all(Py_3_12, py_sys_config = "Py_REF_DEBUG"))] +extern crate alloc; #[cfg(not(any(Py_3_14, target_arch = "wasm32")))] extern crate std; diff --git a/pyo3-ffi/src/refcount.rs b/pyo3-ffi/src/refcount.rs index 9e9efb5f519..232d1d6b2d2 100644 --- a/pyo3-ffi/src/refcount.rs +++ b/pyo3-ffi/src/refcount.rs @@ -299,7 +299,7 @@ pub unsafe fn Py_DECREF(op: *mut PyObject) { #[cfg(py_sys_config = "Py_REF_DEBUG")] if (*op).ob_refcnt.ob_refcnt < 0 { let location = core::panic::Location::caller(); - let filename = std::ffi::CString::new(location.file()).unwrap(); + let filename = alloc::ffi::CString::new(location.file()).unwrap(); _Py_NegativeRefcount(filename.as_ptr(), location.line() as i32, op); }