fix borrow error when serializing recursive models

src/serializers/infer.rs

@@ -101,7 +101,7 @@ pub(crate) fn infer_to_python_known(
 
     let serialize_with_serializer = || {
         let py_serializer = value.getattr(intern!(py, "__pydantic_serializer__"))?;
-        let serializer: SchemaSerializer = py_serializer.extract()?;
+        let serializer: PyRef<SchemaSerializer> = py_serializer.extract()?;
         let extra = serializer.build_extra(
             py,
             extra.mode,
@@ -464,7 +464,7 @@ pub(crate) fn infer_serialize_known<S: Serializer>(
             let py_serializer = value
                 .getattr(intern!(py, "__pydantic_serializer__"))
                 .map_err(py_err_se_err)?;
-            let extracted_serializer: SchemaSerializer = py_serializer.extract().map_err(py_err_se_err)?;
+            let extracted_serializer: PyRef<SchemaSerializer> = py_serializer.extract().map_err(py_err_se_err)?;
             let extra = extracted_serializer.build_extra(
                 py,
                 extra.mode,

src/serializers/mod.rs

@@ -1,4 +1,5 @@
 use std::fmt::Debug;
+use std::sync::atomic::{AtomicUsize, Ordering};
 
 use pyo3::prelude::*;
 use pyo3::types::{PyBytes, PyDict};
@@ -26,11 +27,11 @@ mod shared;
 mod type_serializers;
 
 #[pyclass(module = "pydantic_core._pydantic_core")]
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct SchemaSerializer {
     serializer: CombinedSerializer,
     definitions: Vec<CombinedSerializer>,
-    json_size: usize,
+    expected_json_size: AtomicUsize,
     config: SerializationConfig,
 }
 
@@ -80,7 +81,7 @@ impl SchemaSerializer {
         Ok(Self {
             serializer,
             definitions: definitions_builder.finish()?,
-            json_size: 1024,
+            expected_json_size: AtomicUsize::new(1024),
             config: SerializationConfig::from_config(config)?,
         })
     }
@@ -130,7 +131,7 @@ impl SchemaSerializer {
         exclude_unset = false, exclude_defaults = false, exclude_none = false, round_trip = false, warnings = true,
         fallback = None))]
     pub fn to_json(
-        &mut self,
+        &self,
         py: Python,
         value: &PyAny,
         indent: Option<usize>,
@@ -166,12 +167,12 @@ impl SchemaSerializer {
             exclude,
             &extra,
             indent,
-            self.json_size,
+            self.expected_json_size.load(Ordering::Relaxed),
         )?;
 
         warnings.final_check(py)?;
 
-        self.json_size = bytes.len();
+        self.expected_json_size.store(bytes.len(), Ordering::Relaxed);
         let py_bytes = PyBytes::new(py, &bytes);
         Ok(py_bytes.into())
     }

src/serializers/shared.rs

@@ -308,11 +308,11 @@ pub(crate) fn to_json_bytes(
     exclude: Option<&PyAny>,
     extra: &Extra,
     indent: Option<usize>,
-    json_size: usize,
+    expected_json_size: usize,
 ) -> PyResult<Vec<u8>> {
     let serializer = PydanticSerializer::new(value, serializer, include, exclude, extra);
 
-    let writer: Vec<u8> = Vec::with_capacity(json_size);
+    let writer: Vec<u8> = Vec::with_capacity(expected_json_size);
     let bytes = match indent {
         Some(indent) => {
             let indent = vec![b' '; indent];

tests/serializers/test_model.py

@@ -141,6 +141,22 @@ def test_model_allow_extra():
         assert j == b'{"bar":"more","foo":1,"c":3}'
 
 
+def test_model_recursive_in_extra():
+    # See https://github.com/pydantic/pydantic/issues/6571
+
+    class Model(BasicModel):
+        __slots__ = '__pydantic_extra__'
+
+    s = SchemaSerializer(
+        core_schema.model_schema(
+            Model, core_schema.model_fields_schema({}, extra_behavior='allow'), extra_behavior='allow'
+        )
+    )
+    Model.__pydantic_serializer__ = s
+
+    assert s.to_json(Model(__pydantic_extra__=dict(other=Model(__pydantic_extra__={})))) == b'{"other":{}}'
+
+
 @pytest.mark.parametrize(
     'params',
     [