Make compatible with abi3

Author: bschoenmaeckers

pyo3-ffi/src/compat/py_3_14.rs

@@ -28,6 +28,7 @@ compat_function!(
 compat_function!(
     originally_defined_for(all(Py_3_14, not(Py_LIMITED_API)));
 
+    #[cfg(not(Py_LIMITED_API))]
     pub unsafe fn PyUnicodeWriter_Create(length: crate::Py_ssize_t) -> *mut crate::PyUnicodeWriter {
         if length < 0 {
             crate::PyErr_SetString(
@@ -52,6 +53,7 @@ compat_function!(
 compat_function!(
     originally_defined_for(all(Py_3_14, not(Py_LIMITED_API)));
 
+    #[cfg(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());
@@ -62,6 +64,7 @@ compat_function!(
 compat_function!(
     originally_defined_for(all(Py_3_14, not(Py_LIMITED_API)));
 
+    #[cfg(not(Py_LIMITED_API))]
     pub unsafe fn PyUnicodeWriter_Discard(writer: *mut crate::PyUnicodeWriter) -> () {
         crate::_PyUnicodeWriter_Dealloc(writer.cast());
         crate::PyMem_Free(writer.cast())
@@ -71,6 +74,7 @@ compat_function!(
 compat_function!(
     originally_defined_for(all(Py_3_14, not(Py_LIMITED_API)));
 
+    #[cfg(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(
@@ -87,6 +91,7 @@ compat_function!(
 compat_function!(
     originally_defined_for(all(Py_3_14, not(Py_LIMITED_API)));
 
+    #[cfg(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

src/fmt.rs

@@ -2,23 +2,36 @@
 //! 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.
-use crate::ffi::compat::{
-    PyUnicodeWriter_Create, PyUnicodeWriter_Discard, PyUnicodeWriter_Finish,
-    PyUnicodeWriter_WriteChar, PyUnicodeWriter_WriteUTF8,
+#[cfg(not(Py_LIMITED_API))]
+use {
+    crate::ffi::compat::{
+        PyUnicodeWriter_Create, PyUnicodeWriter_Discard, PyUnicodeWriter_Finish,
+        PyUnicodeWriter_WriteChar, PyUnicodeWriter_WriteUTF8,
+    },
+    crate::ffi_ptr_ext::FfiPtrExt,
+    crate::impl_::callback::WrappingCastTo,
+    crate::types::{PyAnyMethods, PyString},
+    crate::{ffi, Bound, PyErr, PyResult, Python},
+    std::ptr::NonNull,
+    std::{fmt, mem},
 };
-use crate::ffi_ptr_ext::FfiPtrExt;
-use crate::impl_::callback::WrappingCastTo;
-use crate::types::{PyAnyMethods, PyString};
-use crate::{ffi, Bound, PyErr, PyResult, Python};
-use std::ptr::NonNull;
-use std::{fmt, mem};
 
+/// This is like the `format!` macro, but it returns a `PyString` instead of a `String`.
+#[macro_export]
+macro_rules! py_format {
+    ($py: expr, $($arg:tt)*) => {
+        $crate::types::PyString::from_fmt($py, format_args!($($arg)*))
+    }
+}
+
+#[cfg(not(Py_LIMITED_API))]
 /// The `PyUnicodeWriter` is a utility for efficiently constructing Python strings
 pub struct PyUnicodeWriter {
     writer: NonNull<ffi::PyUnicodeWriter>,
     last_error: Option<PyErr>,
 }
 
+#[cfg(not(Py_LIMITED_API))]
 impl PyUnicodeWriter {
     /// Creates a new `PyUnicodeWriter`.
     pub fn new(py: Python<'_>) -> PyResult<Self> {
@@ -63,6 +76,7 @@ impl PyUnicodeWriter {
     }
 }
 
+#[cfg(not(Py_LIMITED_API))]
 impl fmt::Write for PyUnicodeWriter {
     fn write_str(&mut self, s: &str) -> fmt::Result {
         let result = unsafe {
@@ -87,6 +101,7 @@ impl fmt::Write for PyUnicodeWriter {
     }
 }
 
+#[cfg(not(Py_LIMITED_API))]
 impl Drop for PyUnicodeWriter {
     fn drop(&mut self) {
         unsafe {
@@ -97,13 +112,15 @@ impl Drop for PyUnicodeWriter {
 
 #[cfg(test)]
 mod tests {
+    #[cfg(not(Py_LIMITED_API))]
     use super::*;
     use crate::types::PyStringMethods;
     use crate::{IntoPyObject, Python};
-    use std::fmt::Write;
 
     #[test]
+    #[cfg(not(Py_LIMITED_API))]
     fn unicode_writer_test() {
+        use std::fmt::Write;
         Python::with_gil(|py| {
             let mut writer = PyUnicodeWriter::new(py).unwrap();
             write!(writer, "Hello {}!", "world").unwrap();
@@ -116,19 +133,15 @@ mod tests {
     #[test]
     fn test_pystring_from_fmt() {
         Python::with_gil(|py| {
-            PyString::from_fmt(py, format_args!("Hello {}!", "world")).unwrap();
+            py_format!(py, "Hello {}!", "world").unwrap();
         });
     }
 
     #[test]
     fn test_complex_format() {
         Python::with_gil(|py| {
             let complex_value = (42, "foo", 3.14).into_pyobject(py).unwrap();
-            let py_string = PyString::from_fmt(
-                py,
-                format_args!("This is some complex value: {complex_value}"),
-            )
-            .unwrap();
+            let py_string = py_format!(py, "This is some complex value: {complex_value}").unwrap();
             let actual = py_string.to_cow().unwrap();
             let expected = "This is some complex value: (42, 'foo', 3.14)";
             assert_eq!(actual, expected);

src/types/string.rs

@@ -1,6 +1,7 @@
 #[cfg(not(Py_LIMITED_API))]
 use crate::exceptions::PyUnicodeDecodeError;
 use crate::ffi_ptr_ext::FfiPtrExt;
+#[cfg(not(Py_LIMITED_API))]
 use crate::fmt::PyUnicodeWriter;
 use crate::instance::Borrowed;
 use crate::py_result_ext::PyResultExt;
@@ -10,6 +11,7 @@ use crate::types::PyBytes;
 use crate::{ffi, Bound, Py, PyAny, PyResult, Python};
 use std::borrow::Cow;
 use std::ffi::CString;
+#[cfg(not(Py_LIMITED_API))]
 use std::fmt::Write as _;
 use std::{fmt, str};
 
@@ -223,11 +225,19 @@ impl PyString {
             return Ok(PyString::new(py, static_string));
         };
 
-        let mut writer = PyUnicodeWriter::new(py)?;
-        writer
-            .write_fmt(args)
-            .map_err(|_| writer.take_error().expect("expected error"))?;
-        writer.into_py_string(py)
+        #[cfg(not(Py_LIMITED_API))]
+        {
+            let mut writer = PyUnicodeWriter::new(py)?;
+            writer
+                .write_fmt(args)
+                .map_err(|_| writer.take_error().expect("expected error"))?;
+            writer.into_py_string(py)
+        }
+
+        #[cfg(Py_LIMITED_API)]
+        {
+            Ok(PyString::new(py, &format!("{args}")))
+        }
     }
 }