Rebuild dataclass fields before schema generation

Backport of: #11949

Author: Viicos

pydantic/_internal/_dataclasses.py

@@ -55,6 +55,9 @@ class PydanticDataclass(StandardDataclass, typing.Protocol):
         __pydantic_serializer__: ClassVar[SchemaSerializer]
         __pydantic_validator__: ClassVar[SchemaValidator | PluggableSchemaValidator]
 
+        @classmethod
+        def __pydantic_fields_complete__(cls) -> bool: ...
+
 else:
     # See PyCharm issues https://youtrack.jetbrains.com/issue/PY-21915
     # and https://youtrack.jetbrains.com/issue/PY-51428

pydantic/_internal/_fields.py

@@ -32,7 +32,7 @@
 
     from ..fields import FieldInfo
     from ..main import BaseModel
-    from ._dataclasses import StandardDataclass
+    from ._dataclasses import PydanticDataclass, StandardDataclass
     from ._decorators import DecoratorInfos
 
 
@@ -380,7 +380,7 @@ def collect_dataclass_fields(
                     continue
 
                 globalns, localns = ns_resolver.types_namespace
-                ann_type, _ = _typing_extra.try_eval_type(dataclass_field.type, globalns, localns)
+                ann_type, evaluated = _typing_extra.try_eval_type(dataclass_field.type, globalns, localns)
 
                 if _typing_extra.is_classvar_annotation(ann_type):
                     continue
@@ -407,10 +407,16 @@ def collect_dataclass_fields(
                     field_info = FieldInfo_.from_annotated_attribute(
                         ann_type, dataclass_field.default, _source=AnnotationSource.DATACLASS
                     )
+                    field_info._original_assignment = dataclass_field.default
                 else:
                     field_info = FieldInfo_.from_annotated_attribute(
                         ann_type, dataclass_field, _source=AnnotationSource.DATACLASS
                     )
+                    field_info._original_assignment = dataclass_field
+
+                if not evaluated:
+                    field_info._complete = False
+                    field_info._original_annotation = ann_type
 
                 fields[ann_name] = field_info
 
@@ -439,6 +445,51 @@ def collect_dataclass_fields(
     return fields
 
 
+def rebuild_dataclass_fields(
+    cls: type[PydanticDataclass],
+    *,
+    config_wrapper: ConfigWrapper,
+    ns_resolver: NsResolver,
+    typevars_map: Mapping[TypeVar, Any],
+) -> dict[str, FieldInfo]:
+    """Rebuild the (already present) dataclass fields by trying to reevaluate annotations.
+
+    This function should be called whenever a dataclass with incomplete fields is encountered.
+
+    Raises:
+        NameError: If one of the annotations failed to evaluate.
+
+    Note:
+        This function *doesn't* mutate the dataclass fields in place, as it can be called during
+        schema generation, where you don't want to mutate other dataclass's fields.
+    """
+    FieldInfo_ = import_cached_field_info()
+
+    rebuilt_fields: dict[str, FieldInfo] = {}
+    with ns_resolver.push(cls):
+        for f_name, field_info in cls.__pydantic_fields__.items():
+            if field_info._complete:
+                rebuilt_fields[f_name] = field_info
+            else:
+                existing_desc = field_info.description
+                ann = _typing_extra.eval_type(
+                    field_info._original_annotation,
+                    *ns_resolver.types_namespace,
+                )
+                ann = _generics.replace_types(ann, typevars_map)
+                new_field = FieldInfo_.from_annotated_attribute(
+                    ann,
+                    field_info._original_assignment,
+                    _source=AnnotationSource.DATACLASS,
+                )
+
+                # The description might come from the docstring if `use_attribute_docstrings` was `True`:
+                new_field.description = new_field.description if new_field.description is not None else existing_desc
+                rebuilt_fields[f_name] = new_field
+
+    return rebuilt_fields
+
+
 def is_valid_field_name(name: str) -> bool:
     return not name.startswith('_')
 

pydantic/_internal/_generate_schema.py

@@ -87,7 +87,12 @@
     inspect_validator,
 )
 from ._docs_extraction import extract_docstrings_from_cls
-from ._fields import collect_dataclass_fields, rebuild_model_fields, takes_validated_data_argument
+from ._fields import (
+    collect_dataclass_fields,
+    rebuild_dataclass_fields,
+    rebuild_model_fields,
+    takes_validated_data_argument,
+)
 from ._forward_ref import PydanticRecursiveRef
 from ._generics import get_standard_typevars_map, replace_types
 from ._import_utils import import_cached_base_model, import_cached_field_info
@@ -1912,14 +1917,27 @@ def _dataclass_schema(
 
             with self._ns_resolver.push(dataclass), self._config_wrapper_stack.push(config):
                 if is_pydantic_dataclass(dataclass):
-                    # Copy the field info instances to avoid mutating the `FieldInfo` instances
-                    # of the generic dataclass generic origin (e.g. `apply_typevars_map` below).
-                    # Note that we don't apply `deepcopy` on `__pydantic_fields__` because we
-                    # don't want to copy the `FieldInfo` attributes:
-                    fields = {f_name: copy(field_info) for f_name, field_info in dataclass.__pydantic_fields__.items()}
-                    if typevars_map:
-                        for field in fields.values():
-                            field.apply_typevars_map(typevars_map, *self._types_namespace)
+                    if dataclass.__pydantic_fields_complete__():
+                        # Copy the field info instances to avoid mutating the `FieldInfo` instances
+                        # of the generic dataclass generic origin (e.g. `apply_typevars_map` below).
+                        # Note that we don't apply `deepcopy` on `__pydantic_fields__` because we
+                        # don't want to copy the `FieldInfo` attributes:
+                        fields = {
+                            f_name: copy(field_info) for f_name, field_info in dataclass.__pydantic_fields__.items()
+                        }
+                        if typevars_map:
+                            for field in fields.values():
+                                field.apply_typevars_map(typevars_map, *self._types_namespace)
+                    else:
+                        try:
+                            fields = rebuild_dataclass_fields(
+                                dataclass,
+                                config_wrapper=self._config_wrapper,
+                                ns_resolver=self._ns_resolver,
+                                typevars_map=typevars_map or {},
+                            )
+                        except NameError as e:
+                            raise PydanticUndefinedAnnotation.from_name_error(e) from e
                 else:
                     fields = collect_dataclass_fields(
                         dataclass,

pydantic/dataclasses.py

@@ -272,6 +272,7 @@ def create_dataclass(cls: type[Any]) -> type[PydanticDataclass]:
         cls.__doc__ = original_doc
         cls.__module__ = original_cls.__module__
         cls.__qualname__ = original_cls.__qualname__
+        cls.__pydantic_fields_complete__ = classmethod(_pydantic_fields_complete)
         cls.__pydantic_complete__ = False  # `complete_dataclass` will set it to `True` if successful.
         # TODO `parent_namespace` is currently None, but we could do the same thing as Pydantic models:
         # fetch the parent ns using `parent_frame_namespace` (if the dataclass was defined in a function),
@@ -282,6 +283,14 @@ def create_dataclass(cls: type[Any]) -> type[PydanticDataclass]:
     return create_dataclass if _cls is None else create_dataclass(_cls)
 
 
+def _pydantic_fields_complete(cls: type[PydanticDataclass]) -> bool:
+    """Return whether the fields where successfully collected (i.e. type hints were successfully resolves).
+
+    This is a private property, not meant to be used outside Pydantic.
+    """
+    return all(field_info._complete for field_info in cls.__pydantic_fields__.values())
+
+
 __getattr__ = getattr_migration(__name__)
 
 if sys.version_info < (3, 11):

tests/test_dataclasses.py

@@ -3086,3 +3086,23 @@ class A:
         a: int
 
     assert 'a' in A.__pydantic_fields__  # pyright: ignore[reportAttributeAccessIssue]
+
+
+def test_dataclass_fields_rebuilt_before_schema_generation() -> None:
+    """https://github.com/pydantic/pydantic/issues/11947"""
+
+    def update_schema(schema: dict[str, Any]) -> None:
+        schema['test'] = schema['title']
+
+    @pydantic.dataclasses.dataclass
+    class A:
+        a: """Annotated[
+            Forward,
+            Field(field_title_generator=lambda name, _: name, json_schema_extra=update_schema)
+        ]""" = True
+
+    Forward = bool
+
+    ta = TypeAdapter(A)
+
+    assert ta.json_schema()['properties']['a']['test'] == 'a'