Ensure ValidationInfo.field_name is correct on validator reuse

src/validators/dataclass.rs

@@ -24,7 +24,7 @@ use super::{build_validator, BuildValidator, CombinedValidator, DefinitionsBuild
 struct Field {
     kw_only: bool,
     name: String,
-    py_name: Py<PyString>,
+    name_py: Py<PyString>,
     init: bool,
     init_only: bool,
     lookup_key_collection: LookupKeyCollection,
@@ -72,8 +72,8 @@ impl BuildValidator for DataclassArgsValidator {
         for field in fields_schema {
             let field = field.downcast::<PyDict>()?;
 
-            let py_name: Bound<'_, PyString> = field.get_as_req(intern!(py, "name"))?;
-            let name: String = py_name.extract()?;
+            let name_py: Bound<'_, PyString> = field.get_as_req(intern!(py, "name"))?;
+            let name: String = name_py.extract()?;
 
             let schema = field.get_as_req(intern!(py, "schema"))?;
 
@@ -99,7 +99,7 @@ impl BuildValidator for DataclassArgsValidator {
             fields.push(Field {
                 kw_only,
                 name,
-                py_name: py_name.into(),
+                name_py: name_py.into(),
                 lookup_key_collection,
                 validator,
                 init: field.get_as(intern!(py, "init"))?.unwrap_or(true),
@@ -163,13 +163,13 @@ impl Validator for DataclassArgsValidator {
 
         macro_rules! set_item {
             ($field:ident, $value:expr) => {{
-                let py_name = $field.py_name.bind(py);
+                let name_py = $field.name_py.bind(py);
                 if $field.init_only {
                     if let Some(ref mut init_only_args) = init_only_args {
                         init_only_args.push($value);
                     }
                 } else {
-                    output_dict.set_item(py_name, $value)?;
+                    output_dict.set_item(name_py, $value)?;
                 }
             }};
         }
@@ -214,6 +214,8 @@ impl Validator for DataclassArgsValidator {
             }
             let kw_value = kw_value.as_ref().map(|(path, value)| (path, value.borrow_input()));
 
+            let state = &mut state.rebind_extra(|extra| extra.field_name = Some(field.name_py.bind(py).clone()));
+
             match (pos_value, kw_value) {
                 // found both positional and keyword arguments, error
                 (Some(_), Some((_, kw_value))) => {
@@ -404,11 +406,12 @@ impl Validator for DataclassArgsValidator {
                 }
             }
 
-            match field.validator.validate(
-                py,
-                field_value,
-                &mut state.rebind_extra(|extra| extra.data = Some(data_dict.clone())),
-            ) {
+            let state = &mut state.rebind_extra(|extra| {
+                extra.data = Some(data_dict.clone());
+                extra.field_name = Some(field.name_py.bind(py).clone());
+            });
+
+            match field.validator.validate(py, field_value, state) {
                 Ok(output) => ok(output),
                 Err(ValError::LineErrors(line_errors)) => {
                     let errors = line_errors

src/validators/function.rs

@@ -100,7 +100,13 @@ impl FunctionBeforeValidator {
         state: &'s mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         let r = if self.info_arg {
-            let info = ValidationInfo::new(py, state.extra(), &self.config, self.field_name.clone());
+            let field_name = state
+                .extra()
+                .field_name
+                .clone()
+                .map(Bound::unbind)
+                .or(self.field_name.clone());
+            let info = ValidationInfo::new(py, state.extra(), &self.config, field_name);
             self.func.call1(py, (input.to_object(py)?, info))
         } else {
             self.func.call1(py, (input.to_object(py)?,))
@@ -169,7 +175,13 @@ impl FunctionAfterValidator {
     ) -> ValResult<PyObject> {
         let v = call(input, state)?;
         let r = if self.info_arg {
-            let info = ValidationInfo::new(py, state.extra(), &self.config, self.field_name.clone());
+            let field_name = state
+                .extra()
+                .field_name
+                .clone()
+                .map(Bound::unbind)
+                .or(self.field_name.clone());
+            let info = ValidationInfo::new(py, state.extra(), &self.config, field_name);
             self.func.call1(py, (v, info))
         } else {
             self.func.call1(py, (v,))
@@ -258,7 +270,13 @@ impl Validator for FunctionPlainValidator {
         state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         let r = if self.info_arg {
-            let info = ValidationInfo::new(py, state.extra(), &self.config, self.field_name.clone());
+            let field_name = state
+                .extra()
+                .field_name
+                .clone()
+                .map(Bound::unbind)
+                .or(self.field_name.clone());
+            let info = ValidationInfo::new(py, state.extra(), &self.config, field_name);
             self.func.call1(py, (input.to_object(py)?, info))
         } else {
             self.func.call1(py, (input.to_object(py)?,))
@@ -322,7 +340,13 @@ impl FunctionWrapValidator {
         state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         let r = if self.info_arg {
-            let info = ValidationInfo::new(py, state.extra(), &self.config, self.field_name.clone());
+            let field_name = state
+                .extra()
+                .field_name
+                .clone()
+                .map(Bound::unbind)
+                .or(self.field_name.clone());
+            let info = ValidationInfo::new(py, state.extra(), &self.config, field_name);
             self.func.call1(py, (input.to_object(py)?, handler, info))
         } else {
             self.func.call1(py, (input.to_object(py)?, handler))

src/validators/generator.rs

@@ -276,6 +276,7 @@ impl InternalValidator {
             data: self.data.as_ref().map(|data| data.bind(py).clone()),
             strict: self.strict,
             from_attributes: self.from_attributes,
+            field_name: Some(PyString::new(py, field_name)),
             context: self.context.as_ref().map(|data| data.bind(py)),
             self_instance: self.self_instance.as_ref().map(|data| data.bind(py)),
             cache_str: self.cache_str,
@@ -313,6 +314,7 @@ impl InternalValidator {
             data: self.data.as_ref().map(|data| data.bind(py).clone()),
             strict: self.strict,
             from_attributes: self.from_attributes,
+            field_name: None,
             context: self.context.as_ref().map(|data| data.bind(py)),
             self_instance: self.self_instance.as_ref().map(|data| data.bind(py)),
             cache_str: self.cache_str,

src/validators/mod.rs

@@ -311,6 +311,7 @@ impl SchemaValidator {
             data: None,
             strict,
             from_attributes,
+            field_name: Some(PyString::new(py, field_name)),
             context,
             self_instance: None,
             cache_str: self.cache_str,
@@ -337,6 +338,7 @@ impl SchemaValidator {
             data: None,
             strict,
             from_attributes: None,
+            field_name: None,
             context,
             self_instance: None,
             cache_str: self.cache_str,
@@ -678,6 +680,8 @@ pub struct Extra<'a, 'py> {
     pub from_attributes: Option<bool>,
     /// context used in validator functions
     pub context: Option<&'a Bound<'py, PyAny>>,
+    /// The name of the field being validated, if applicable
+    pub field_name: Option<Bound<'py, PyString>>,
     /// This is an instance of the model or dataclass being validated, when validation is performed from `__init__`
     self_instance: Option<&'a Bound<'py, PyAny>>,
     /// Whether to use a cache of short strings to accelerate python string construction
@@ -705,6 +709,7 @@ impl<'a, 'py> Extra<'a, 'py> {
             data: None,
             strict,
             from_attributes,
+            field_name: None,
             context,
             self_instance,
             cache_str,
@@ -721,6 +726,7 @@ impl Extra<'_, '_> {
             data: self.data.clone(),
             strict: Some(true),
             from_attributes: self.from_attributes,
+            field_name: self.field_name.clone(),
             context: self.context,
             self_instance: self.self_instance,
             cache_str: self.cache_str,

src/validators/model_fields.rs

@@ -197,6 +197,10 @@ impl Validator for ModelFieldsValidator {
                         // extra logic either way
                         used_keys.insert(lookup_path.first_key());
                     }
+
+                    let state =
+                        &mut state.rebind_extra(|extra| extra.field_name = Some(field.name_py.bind(py).clone()));
+
                     match field.validator.validate(py, value.borrow_input(), state) {
                         Ok(value) => {
                             model_dict.set_item(&field.name_py, value)?;
@@ -422,6 +426,8 @@ impl Validator for ModelFieldsValidator {
                     ));
                 }
 
+                let state = &mut state.rebind_extra(|extra| extra.field_name = Some(field.name_py.bind(py).clone()));
+
                 prepare_result(field.validator.validate(py, field_value, state))?
             } else {
                 // Handle extra (unknown) field

src/validators/typed_dict.rs

@@ -218,6 +218,9 @@ impl Validator for TypedDictValidator {
                         true => allow_partial,
                         false => false.into(),
                     };
+                    let state =
+                        &mut state.rebind_extra(|extra| extra.field_name = Some(field.name_py.bind(py).clone()));
+
                     match field.validator.validate(py, value.borrow_input(), state) {
                         Ok(value) => {
                             output_dict.set_item(&field.name_py, value)?;

tests/validators/test_function.py

@@ -2,6 +2,7 @@
 import platform
 import re
 from copy import deepcopy
+from dataclasses import dataclass
 from typing import Any
 
 import pytest
@@ -662,6 +663,36 @@ def f(input_value: Any, info: core_schema.ValidationInfo) -> Any:
     assert v.validate_python({'x': b'foo'}).x == 'input: foo'
 
 
+def test_model_field_validator_reuse() -> None:
+    class Model:
+        x: str
+        y: str
+
+    def f(input_value: Any, info: core_schema.ValidationInfo) -> Any:
+        return f'{info.field_name}: {input_value}'
+
+    # When a type alias with a validator function is used on multiple fields,
+    # its core schema is only generated once (with the first field_name) and reused.
+    # See https://github.com/pydantic/pydantic/issues/11737
+    validator = core_schema.with_info_plain_validator_function(f, field_name='x')
+
+    v = SchemaValidator(
+        core_schema.model_schema(
+            Model,
+            core_schema.model_fields_schema(
+                {
+                    'x': core_schema.model_field(validator),
+                    'y': core_schema.model_field(validator),
+                }
+            ),
+        )
+    )
+
+    m = v.validate_python({'x': 'foo', 'y': 'bar'})
+    assert m.x == 'x: foo'
+    assert m.y == 'y: bar'
+
+
 def test_model_field_wrap_validator() -> None:
     class Model:
         x: str
@@ -688,17 +719,13 @@ def f(input_value: Any, val: core_schema.ValidatorFunctionWrapHandler, info: cor
     assert v.validate_python({'x': b'foo'}).x == 'input: foo'
 
 
-def check_info_field_name_none(info: core_schema.ValidationInfo) -> None:
-    assert info.field_name is None
-    assert info.data == {}
-
-
-def test_non_model_field_before_validator_tries_to_access_field_info() -> None:
+def test_non_model_field_before_validator_field_info() -> None:
     class Model:
         x: str
 
     def f(input_value: Any, info: core_schema.ValidationInfo) -> Any:
-        check_info_field_name_none(info)
+        assert info.field_name == 'x'
+        assert info.data == {}
         assert isinstance(input_value, bytes)
         return f'input: {input_value.decode()}'
 
@@ -718,12 +745,13 @@ def f(input_value: Any, info: core_schema.ValidationInfo) -> Any:
     assert v.validate_python({'x': b'foo'}).x == 'input: foo'
 
 
-def test_non_model_field_after_validator_tries_to_access_field_info() -> None:
+def test_non_model_field_after_validator_field_info() -> None:
     class Model:
         x: str
 
     def f(input_value: Any, info: core_schema.ValidationInfo) -> Any:
-        check_info_field_name_none(info)
+        assert info.field_name == 'x'
+        assert info.data == {}
         return f'input: {input_value}'
 
     v = SchemaValidator(
@@ -742,12 +770,13 @@ def f(input_value: Any, info: core_schema.ValidationInfo) -> Any:
     assert v.validate_python({'x': b'foo'}).x == 'input: foo'
 
 
-def test_non_model_field_plain_validator_tries_to_access_field_info() -> None:
+def test_non_model_field_plain_validator_field_info() -> None:
     class Model:
         x: str
 
     def f(input_value: Any, info: core_schema.ValidationInfo) -> Any:
-        check_info_field_name_none(info)
+        assert info.field_name == 'x'
+        assert info.data == {}
         assert isinstance(input_value, bytes)
         return f'input: {input_value.decode()}'
 
@@ -763,13 +792,14 @@ def f(input_value: Any, info: core_schema.ValidationInfo) -> Any:
     assert v.validate_python({'x': b'foo'}).x == 'input: foo'
 
 
-def test_non_model_field_wrap_validator_tries_to_access_field_info() -> None:
+def test_non_model_field_wrap_validator_field_info() -> None:
     class Model:
         __slots__ = '__dict__', '__pydantic_fields_set__', '__pydantic_extra__', '__pydantic_private__'
         x: str
 
     def f(input_value: Any, val: core_schema.ValidatorFunctionWrapHandler, info: core_schema.ValidationInfo) -> Any:
-        check_info_field_name_none(info)
+        assert info.field_name == 'x'
+        assert info.data == {}
         return f'input: {val(input_value)}'
 
     v = SchemaValidator(
@@ -821,6 +851,62 @@ def f(input_value: Any, info: core_schema.ValidationInfo) -> Any:
     assert info_stuff == {'field_name': 'c', 'data': {'a': 1}}
 
 
+def test_typed_dict_validator_reuse() -> None:
+    def f(input_value: Any, info: core_schema.ValidationInfo) -> Any:
+        return f'{info.field_name}: {input_value}'
+
+    # When a type alias with a validator function is used on multiple fields,
+    # its core schema is only generated once (with the first field_name) and reused.
+    # See https://github.com/pydantic/pydantic/issues/11737
+    validator = core_schema.with_info_plain_validator_function(f, field_name='x')
+
+    v = SchemaValidator(
+        core_schema.typed_dict_schema(
+            {
+                'x': core_schema.model_field(validator),
+                'y': core_schema.model_field(validator),
+            }
+        )
+    )
+
+    data = v.validate_python({'x': 'foo', 'y': 'bar'})
+    assert data['x'] == 'x: foo'
+    assert data['y'] == 'y: bar'
+
+
+def test_dataclass_validator_reuse() -> None:
+    @dataclass
+    class Model:
+        x: str
+        y: str
+
+    def f(input_value: Any, info: core_schema.ValidationInfo) -> Any:
+        return f'{info.field_name}: {input_value}'
+
+    # When a type alias with a validator function is used on multiple fields,
+    # its core schema is only generated once (with the first field_name) and reused.
+    # See https://github.com/pydantic/pydantic/issues/11737
+    validator = core_schema.with_info_plain_validator_function(f, field_name='x')
+
+    v = SchemaValidator(
+        core_schema.dataclass_schema(
+            Model,
+            core_schema.dataclass_args_schema(
+                'Model',
+                [
+                    core_schema.dataclass_field(name='x', schema=validator),
+                    core_schema.dataclass_field(name='y', schema=validator),
+                ],
+            ),
+            ['x', 'y'],
+        )
+    )
+
+    m = v.validate_python({'x': 'foo', 'y': 'bar'})
+    assert m.x == 'x: foo'
+    assert m.y == 'y: bar'
+
+
 @pytest.mark.parametrize(
     'mode,calls1,calls2',
     [