Remove PyUnicodeWriter compat shim

Author: bschoenmaeckers

pyo3-ffi/src/compat/py_3_14.rs

@@ -24,88 +24,3 @@ compat_function!(
         }
     }
 );
-
-#[cfg(not(any(Py_LIMITED_API, PyPy)))]
-compat_function!(
-    originally_defined_for(all(Py_3_14, not(Py_LIMITED_API)));
-
-    pub unsafe fn PyUnicodeWriter_Create(length: crate::Py_ssize_t) -> *mut crate::PyUnicodeWriter {
-        if length < 0 {
-            crate::PyErr_SetString(
-                crate::PyExc_ValueError,
-                c_str!("length must be positive").as_ptr(),
-            );
-            return std::ptr::null_mut();
-        }
-
-        let size = std::mem::size_of::<crate::_PyUnicodeWriter>();
-        let writer: *mut crate::_PyUnicodeWriter = crate::PyMem_Malloc(size).cast();
-        crate::_PyUnicodeWriter_Init(writer);
-        if crate::_PyUnicodeWriter_Prepare(writer, length, 127) < 0 {
-            PyUnicodeWriter_Discard(writer.cast());
-            return std::ptr::null_mut();
-        }
-        (*writer).overallocate = 1;
-        writer.cast()
-    }
-);
-
-#[cfg(not(any(Py_LIMITED_API, PyPy)))]
-compat_function!(
-    originally_defined_for(all(Py_3_14, not(Py_LIMITED_API)));
-
-    pub unsafe fn PyUnicodeWriter_Finish(writer: *mut crate::PyUnicodeWriter) -> *mut crate::PyObject {
-        let str = crate::_PyUnicodeWriter_Finish(writer.cast());
-        crate::PyMem_Free(writer.cast());
-        str
-    }
-);
-
-#[cfg(not(any(Py_LIMITED_API, PyPy)))]
-compat_function!(
-    originally_defined_for(all(Py_3_14, not(Py_LIMITED_API)));
-
-    pub unsafe fn PyUnicodeWriter_Discard(writer: *mut crate::PyUnicodeWriter) -> () {
-        crate::_PyUnicodeWriter_Dealloc(writer.cast());
-        crate::PyMem_Free(writer.cast())
-    }
-);
-
-#[cfg(not(any(Py_LIMITED_API, PyPy)))]
-compat_function!(
-    originally_defined_for(all(Py_3_14, not(Py_LIMITED_API)));
-
-    pub unsafe fn PyUnicodeWriter_WriteChar(writer: *mut crate::PyUnicodeWriter, ch: crate::Py_UCS4) -> std::os::raw::c_int {
-        if ch > 0x10ffff {
-            crate::PyErr_SetString(
-                crate::PyExc_ValueError,
-                c_str!("character must be in range(0x110000)").as_ptr(),
-            );
-            return -1;
-        }
-
-        crate::_PyUnicodeWriter_WriteChar(writer.cast(), ch)
-    }
-);
-
-#[cfg(not(any(Py_LIMITED_API, PyPy)))]
-compat_function!(
-    originally_defined_for(all(Py_3_14, not(Py_LIMITED_API)));
-
-    pub unsafe fn PyUnicodeWriter_WriteUTF8(writer: *mut crate::PyUnicodeWriter,str: *const std::os::raw::c_char, size: crate::Py_ssize_t) -> std::os::raw::c_int {
-        let size = if size < 0 {
-            libc::strlen(str) as isize
-        } else {
-            size
-        };
-
-        let py_str = crate::PyUnicode_FromStringAndSize(str, size);
-        if py_str.is_null() {
-            return -1;
-        }
-
-        let result = crate::_PyUnicodeWriter_WriteStr(writer.cast(), py_str);
-        crate::Py_DECREF(py_str);
-        result
-    }
-);

pyo3-ffi/src/cpython/unicodeobject.rs

@@ -689,53 +689,15 @@ extern "C" {
 #[cfg(Py_3_14)]
 opaque_struct!(pub PyUnicodeWriter);
 
-#[cfg(not(Py_3_14))]
-pub type PyUnicodeWriter = _PyUnicodeWriter;
-
-#[cfg(not(Py_3_14))]
-#[doc(hidden)]
-#[repr(C)]
-pub struct _PyUnicodeWriter {
-    buffer: *mut PyObject,
-    data: *mut c_void,
-    kind: c_int,
-    pub(crate) maxchar: Py_UCS4,
-    pub(crate) size: Py_ssize_t,
-    pub(crate) pos: Py_ssize_t,
-    min_length: Py_ssize_t,
-    min_char: Py_UCS4,
-    pub(crate) overallocate: c_char,
-    readonly: c_char,
-}
-
 extern "C" {
     #[cfg(Py_3_14)]
     pub fn PyUnicodeWriter_Create(length: Py_ssize_t) -> *mut PyUnicodeWriter;
     #[cfg(Py_3_14)]
     pub fn PyUnicodeWriter_Finish(writer: *mut PyUnicodeWriter) -> *mut PyObject;
-    #[cfg(not(Py_3_14))]
-    pub(crate) fn _PyUnicodeWriter_Finish(writer: *mut _PyUnicodeWriter) -> *mut PyObject;
     #[cfg(Py_3_14)]
     pub fn PyUnicodeWriter_Discard(writer: *mut PyUnicodeWriter);
-    #[cfg(not(Py_3_14))]
-    pub(crate) fn _PyUnicodeWriter_Dealloc(writer: *mut _PyUnicodeWriter);
-    #[cfg(not(Py_3_14))]
-    pub(crate) fn _PyUnicodeWriter_Init(writer: *mut _PyUnicodeWriter);
-    #[cfg(not(Py_3_14))]
-    pub(crate) fn _PyUnicodeWriter_PrepareInternal(
-        writer: *mut _PyUnicodeWriter,
-        length: Py_ssize_t,
-        maxchars: Py_UCS4,
-    ) -> c_int;
     #[cfg(Py_3_14)]
     pub fn PyUnicodeWriter_WriteChar(writer: *mut PyUnicodeWriter, ch: Py_UCS4) -> c_int;
-    #[cfg(not(Py_3_14))]
-    pub(crate) fn _PyUnicodeWriter_WriteChar(writer: *mut _PyUnicodeWriter, ch: Py_UCS4) -> c_int;
-    #[cfg(not(Py_3_14))]
-    pub(crate) fn _PyUnicodeWriter_WriteStr(
-        writer: *mut _PyUnicodeWriter,
-        str: *mut PyObject,
-    ) -> c_int;
     #[cfg(Py_3_14)]
     pub fn PyUnicodeWriter_WriteUTF8(
         writer: *mut PyUnicodeWriter,
@@ -744,24 +706,6 @@ extern "C" {
     ) -> c_int;
 }
 
-#[cfg(not(Py_3_14))]
-#[inline(always)]
-pub(crate) unsafe fn _PyUnicodeWriter_Prepare(
-    writer: *mut _PyUnicodeWriter,
-    length: Py_ssize_t,
-    maxchars: Py_UCS4,
-) -> c_int {
-    if maxchars <= (*writer).maxchar && length <= (*writer).size - (*writer).pos {
-        return 0;
-    }
-
-    if length == 0 {
-        return 0;
-    }
-
-    _PyUnicodeWriter_PrepareInternal(writer, length, maxchars)
-}
-
 // skipped _PyUnicodeWriter
 // skipped _PyUnicodeWriter_Init
 // skipped _PyUnicodeWriter_Prepare

src/fmt.rs

@@ -2,9 +2,9 @@
 //! constructing Python strings using Rust's `fmt::Write` trait.
 //! It allows for incremental string construction, without the need for repeated allocations, and
 //! is particularly useful for building strings in a performance-sensitive context.
-#[cfg(not(any(Py_LIMITED_API, PyPy)))]
+#[cfg(Py_3_14)]
 use {
-    crate::ffi::compat::{
+    crate::ffi::{
         PyUnicodeWriter_Create, PyUnicodeWriter_Discard, PyUnicodeWriter_Finish,
         PyUnicodeWriter_WriteChar, PyUnicodeWriter_WriteUTF8,
     },
@@ -23,8 +23,7 @@ use {
 #[macro_export]
 macro_rules! py_format {
     ($py: expr, $($arg:tt)*) => {{
-        let format_args = format_args!($($arg)*);
-        if let Some(static_string) = format_args.as_str() {
+        if let Some(static_string) = format_args!($($arg)*).as_str() {
             static INTERNED: $crate::sync::PyOnceLock<$crate::Py<$crate::types::PyString>> = $crate::sync::PyOnceLock::new();
             Ok(
                 INTERNED
@@ -33,20 +32,20 @@ macro_rules! py_format {
                 .to_owned()
             )
         } else {
-            $crate::types::PyString::from_fmt($py, format_args)
+            $crate::types::PyString::from_fmt($py, format_args!($($arg)*))
         }
     }}
 }
 
-#[cfg(not(any(Py_LIMITED_API, PyPy)))]
+#[cfg(Py_3_14)]
 /// The `PyUnicodeWriter` is a utility for efficiently constructing Python strings
 pub struct PyUnicodeWriter<'py> {
     python: Python<'py>,
     writer: NonNull<ffi::PyUnicodeWriter>,
     last_error: Option<PyErr>,
 }
 
-#[cfg(not(any(Py_LIMITED_API, PyPy)))]
+#[cfg(Py_3_14)]
 impl<'py> PyUnicodeWriter<'py> {
     /// Creates a new `PyUnicodeWriter`.
     pub fn new(py: Python<'py>) -> PyResult<Self> {
@@ -93,7 +92,7 @@ impl<'py> PyUnicodeWriter<'py> {
     }
 }
 
-#[cfg(not(any(Py_LIMITED_API, PyPy)))]
+#[cfg(Py_3_14)]
 impl fmt::Write for PyUnicodeWriter<'_> {
     fn write_str(&mut self, s: &str) -> fmt::Result {
         let result = unsafe {
@@ -118,7 +117,7 @@ impl fmt::Write for PyUnicodeWriter<'_> {
     }
 }
 
-#[cfg(not(any(Py_LIMITED_API, PyPy)))]
+#[cfg(Py_3_14)]
 impl Drop for PyUnicodeWriter<'_> {
     fn drop(&mut self) {
         unsafe {
@@ -127,7 +126,7 @@ impl Drop for PyUnicodeWriter<'_> {
     }
 }
 
-#[cfg(not(any(Py_LIMITED_API, PyPy)))]
+#[cfg(Py_3_14)]
 impl<'py> IntoPyObject<'py> for PyUnicodeWriter<'py> {
     type Target = PyString;
     type Output = Bound<'py, Self::Target>;
@@ -140,14 +139,14 @@ impl<'py> IntoPyObject<'py> for PyUnicodeWriter<'py> {
 
 #[cfg(test)]
 mod tests {
-    #[cfg(not(any(Py_LIMITED_API, PyPy)))]
+    #[cfg(Py_3_14)]
     use super::*;
     use crate::types::PyStringMethods;
     use crate::{IntoPyObject, Python};
 
     #[test]
     #[allow(clippy::write_literal)]
-    #[cfg(not(any(Py_LIMITED_API, PyPy)))]
+    #[cfg(Py_3_14)]
     fn unicode_writer_test() {
         use std::fmt::Write;
         Python::attach(|py| {

src/types/string.rs

@@ -1,17 +1,13 @@
 #[cfg(not(Py_LIMITED_API))]
 use crate::exceptions::PyUnicodeDecodeError;
 use crate::ffi_ptr_ext::FfiPtrExt;
-#[cfg(not(any(Py_LIMITED_API, PyPy)))]
-use crate::fmt::PyUnicodeWriter;
 use crate::instance::Borrowed;
 use crate::py_result_ext::PyResultExt;
 use crate::types::bytes::PyBytesMethods;
 use crate::types::PyBytes;
 use crate::{ffi, Bound, Py, PyAny, PyResult, Python};
 use std::borrow::Cow;
 use std::ffi::{CStr, CString};
-#[cfg(not(any(Py_LIMITED_API, PyPy)))]
-use std::fmt::Write as _;
 use std::{fmt, str};
 
 /// Represents raw data backing a Python `str`.
@@ -264,16 +260,19 @@ impl PyString {
             return Ok(PyString::new(py, static_string));
         };
 
-        #[cfg(not(any(Py_LIMITED_API, PyPy)))]
+        #[cfg(Py_3_14)]
         {
+            use crate::fmt::PyUnicodeWriter;
+            use std::fmt::Write as _;
+
             let mut writer = PyUnicodeWriter::new(py)?;
             writer
                 .write_fmt(args)
                 .map_err(|_| writer.take_error().expect("expected error"))?;
             writer.into_py_string()
         }
 
-        #[cfg(any(Py_LIMITED_API, PyPy))]
+        #[cfg(not(Py_3_14))]
         {
             Ok(PyString::new(py, &format!("{args}")))
         }