move extra inside of state (#1863)

Author: davidhewitt

src/errors/validation_exception.rs

@@ -339,7 +339,6 @@ impl ValidationError {
         include_input: bool,
     ) -> PyResult<Bound<'py, PyString>> {
         let config = SerializationConfig::from_args("iso8601", "iso8601", "utf8", "constants")?;
-        let mut state = SerializationState::new(config, WarningsMode::None, None, None)?;
         let extra = Extra::new(
             py,
             &SerMode::Json,
@@ -354,13 +353,13 @@ impl ValidationError {
             false,
             None,
         );
+        let mut state = SerializationState::new(config, WarningsMode::None, None, None, extra)?;
         let mut serializer = ValidationErrorSerializer {
             py,
             line_errors: &self.line_errors,
             url_prefix: get_url_prefix(py, include_url),
             include_context,
             include_input,
-            extra: &extra,
             state: &mut state,
             input_type: &self.input_type,
         };
@@ -584,18 +583,17 @@ where
     S::Error::custom(error.to_string())
 }
 
-struct ValidationErrorSerializer<'slf, 'py> {
+struct ValidationErrorSerializer<'slf, 'a, 'py> {
     py: Python<'py>,
     line_errors: &'py [PyLineError],
     url_prefix: Option<&'py str>,
     include_context: bool,
     include_input: bool,
-    state: &'slf mut SerializationState<'py>,
-    extra: &'slf Extra<'slf, 'py>,
+    state: &'slf mut SerializationState<'a, 'py>,
     input_type: &'py InputType,
 }
 
-impl ValidationErrorSerializer<'_, '_> {
+impl ValidationErrorSerializer<'_, '_, '_> {
     fn serialize<S>(&mut self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
@@ -609,7 +607,6 @@ impl ValidationErrorSerializer<'_, '_> {
                 include_context: self.include_context,
                 include_input: self.include_input,
                 state: RefCell::new(self.state),
-                extra: self.extra,
                 input_type: self.input_type,
             };
             seq.serialize_element(&line_s)?;
@@ -618,18 +615,17 @@ impl ValidationErrorSerializer<'_, '_> {
     }
 }
 
-struct PyLineErrorSerializer<'slf, 'py> {
+struct PyLineErrorSerializer<'slf, 'a, 'py> {
     py: Python<'py>,
     line_error: &'py PyLineError,
     url_prefix: Option<&'py str>,
     include_context: bool,
     include_input: bool,
-    extra: &'slf Extra<'slf, 'py>,
-    state: RefCell<&'slf mut SerializationState<'py>>,
+    state: RefCell<&'slf mut SerializationState<'a, 'py>>,
     input_type: &'py InputType,
 }
 
-impl Serialize for PyLineErrorSerializer<'_, '_> {
+impl Serialize for PyLineErrorSerializer<'_, '_, '_> {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
@@ -654,17 +650,12 @@ impl Serialize for PyLineErrorSerializer<'_, '_> {
         map.serialize_entry("msg", &msg)?;
 
         if self.include_input {
-            map.serialize_entry(
-                "input",
-                &self
-                    .extra
-                    .serialize_infer(self.line_error.input_value.bind(py), &mut state),
-            )?;
+            map.serialize_entry("input", &state.serialize_infer(self.line_error.input_value.bind(py)))?;
         }
 
         if self.include_context {
             if let Some(context) = self.line_error.error_type.py_dict(py).map_err(py_err_json::<S>)? {
-                map.serialize_entry("ctx", &self.extra.serialize_infer(context.bind(py), &mut state))?;
+                map.serialize_entry("ctx", &state.serialize_infer(context.bind(py)))?;
             }
         }
         if let Some(url_prefix) = self.url_prefix {

src/serializers/computed_fields.rs

@@ -16,7 +16,6 @@ use crate::serializers::SerializationState;
 use crate::tools::SchemaDict;
 
 use super::errors::py_err_se_err;
-use super::Extra;
 
 #[derive(Debug)]
 pub(super) struct ComputedFields(Vec<ComputedField>);
@@ -48,26 +47,23 @@ impl ComputedFields {
         model: &Bound<'py, PyAny>,
         output_dict: &Bound<'py, PyDict>,
         filter: &SchemaFilter<isize>,
-        state: &mut SerializationState<'py>,
-        extra: &Extra<'_, 'py>,
+        state: &mut SerializationState<'_, 'py>,
     ) -> PyResult<()> {
         self.serialize_fields(
             model,
             filter,
             state,
-            extra,
             |e| e,
             |ComputedFieldToSerialize {
                  computed_field,
                  value,
                  state,
-                 field_extra,
              }| {
-                let key = match field_extra.serialize_by_alias_or(computed_field.serialize_by_alias) {
+                let key = match state.extra.serialize_by_alias_or(computed_field.serialize_by_alias) {
                     true => computed_field.alias_py.bind(model.py()),
                     false => computed_field.property_name_py.bind(model.py()),
                 };
-                let value = computed_field.serializer.to_python(&value, state, field_extra)?;
+                let value = computed_field.serializer.to_python(&value, state)?;
                 output_dict.set_item(key, value)
             },
         )
@@ -78,44 +74,40 @@ impl ComputedFields {
         model: &Bound<'py, PyAny>,
         map: &mut S::SerializeMap,
         filter: &SchemaFilter<isize>,
-        state: &mut SerializationState<'py>,
-        extra: &Extra<'_, 'py>,
+        state: &mut SerializationState<'_, 'py>,
     ) -> Result<(), S::Error> {
         self.serialize_fields(
             model,
             filter,
             state,
-            extra,
             py_err_se_err,
             |ComputedFieldToSerialize {
                  computed_field,
                  value,
                  state,
-                 field_extra,
              }| {
-                let key = match field_extra.serialize_by_alias_or(computed_field.serialize_by_alias) {
+                let key = match state.extra.serialize_by_alias_or(computed_field.serialize_by_alias) {
                     true => &computed_field.alias,
                     false => &computed_field.property_name,
                 };
-                let s = PydanticSerializer::new(&value, &computed_field.serializer, state, field_extra);
+                let s = PydanticSerializer::new(&value, &computed_field.serializer, state);
                 map.serialize_entry(key, &s)
             },
         )
     }
 
     /// Iterate each field for serialization, filtering on
     /// `include` and `exclude` if provided.
-    fn serialize_fields<'a, 'py, E>(
-        &'a self,
-        model: &'a Bound<'py, PyAny>,
-        filter: &'a SchemaFilter<isize>,
-        state: &mut SerializationState<'py>,
-        extra: &'a Extra<'_, 'py>,
+    fn serialize_fields<'py, E>(
+        &self,
+        model: &Bound<'py, PyAny>,
+        filter: &SchemaFilter<isize>,
+        state: &mut SerializationState<'_, 'py>,
         convert_error: impl FnOnce(PyErr) -> E,
-        mut serialize: impl for<'slf> FnMut(ComputedFieldToSerialize<'a, 'slf, 'py>) -> Result<(), E>,
+        mut serialize: impl for<'slf, 'a> FnMut(ComputedFieldToSerialize<'slf, 'a, 'py>) -> Result<(), E>,
     ) -> Result<(), E> {
         // In round trip mode, exclude computed fields:
-        if extra.round_trip || extra.exclude_computed_fields {
+        if state.extra.round_trip || state.extra.exclude_computed_fields {
             return Ok(());
         }
 
@@ -133,7 +125,7 @@ impl ComputedFields {
                     return Err(convert_error(e));
                 }
             };
-            if extra.exclude_none && value.is_none() {
+            if state.extra.exclude_none && value.is_none() {
                 continue;
             }
             let missing_sentinel = get_missing_sentinel_object(model.py());
@@ -148,18 +140,16 @@ impl ComputedFields {
                 computed_field,
                 value,
                 state,
-                field_extra: extra,
             })?;
         }
         Ok(())
     }
 }
 
-struct ComputedFieldToSerialize<'a, 'slf, 'py> {
-    computed_field: &'a ComputedField,
+struct ComputedFieldToSerialize<'slf, 'a, 'py> {
+    computed_field: &'slf ComputedField,
     value: Bound<'py, PyAny>,
-    state: &'slf mut SerializationState<'py>,
-    field_extra: &'slf Extra<'a, 'py>,
+    state: &'slf mut SerializationState<'a, 'py>,
 }
 
 #[derive(Debug)]