Explicitly raise an error if field names clashes with types (#8243)

Co-authored-by: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>

docs/errors/usage_errors.md

@@ -1018,5 +1018,32 @@ except PydanticUserError as exc_info:
     assert exc_info.code == 'root-model-extra'
 ```
 
+## Cannot evaluate type annotation {#unevaluable-type-annotation}
+
+Because type annotations are evaluated *after* assignments, you might get unexpected results when using a type annotation name
+that clashes with one of your fields. We raise an error in the following case:
+
+```py test="skip"
+from datetime import date
+
+from pydantic import BaseModel, Field
+
+
+class Model(BaseModel):
+    date: date = Field(description='A date')
+```
+
+As a workaround, you can either use an alias or change your import:
+
+```py lint="skip"
+import datetime
+# Or `from datetime import date as _date`
+
+from pydantic import BaseModel, Field
+
+
+class Model(BaseModel):
+    date: datetime.date = Field(description='A date')
+```
 
 {% endraw %}

pydantic/errors.py

@@ -58,6 +58,7 @@
     'invalid_annotated_type',
     'type-adapter-config-unused',
     'root-model-extra',
+    'unevaluable-type-annotation',
 ]
 
 

pydantic/fields.py

@@ -321,6 +321,13 @@ class MyModel(pydantic.BaseModel):
         Returns:
             A field object with the passed values.
         """
+        if annotation is default:
+            raise PydanticUserError(
+                'Error when building FieldInfo from annotated attribute. '
+                "Make sure you don't have any field name clashing with a type annotation ",
+                code='unevaluable-type-annotation',
+            )
+
         final = False
         if _typing_extra.is_finalvar(annotation):
             final = True

tests/test_edge_cases.py

@@ -1375,19 +1375,17 @@ class FooBar:
         pass
 
     class Model(BaseModel):
-        a: int = int
-        b: Type[int]
-        c: Type[int] = int
-        d: FooBar = FooBar
-        e: Type[FooBar]
-        f: Type[FooBar] = FooBar
-        g: Sequence[Type[FooBar]] = [FooBar]
-        h: Union[Type[FooBar], Sequence[Type[FooBar]]] = FooBar
-        i: Union[Type[FooBar], Sequence[Type[FooBar]]] = [FooBar]
+        a: Type[int]
+        b: Type[int] = int
+        c: Type[FooBar]
+        d: Type[FooBar] = FooBar
+        e: Sequence[Type[FooBar]] = [FooBar]
+        f: Union[Type[FooBar], Sequence[Type[FooBar]]] = FooBar
+        g: Union[Type[FooBar], Sequence[Type[FooBar]]] = [FooBar]
 
         model_config = dict(arbitrary_types_allowed=True)
 
-    assert Model.model_fields.keys() == set('abcdefghi')
+    assert Model.model_fields.keys() == set('abcdefg')
 
 
 def test_assign_type():
@@ -2436,15 +2434,11 @@ def test_invalid_forward_ref_model():
     """
     # The problem:
     if sys.version_info >= (3, 11):
-        error = RecursionError
-        kwargs = {}
+        # See PR #8243, this was a RecursionError raised by Python, but is now caught on the Pydantic side
+        error = errors.PydanticUserError
     else:
         error = TypeError
-        kwargs = {
-            'match': r'Forward references must evaluate to types\.'
-            r' Got FieldInfo\(annotation=NoneType, required=False\)\.'
-        }
-    with pytest.raises(error, **kwargs):
+    with pytest.raises(error):
 
         class M(BaseModel):
             B: ForwardRef('B') = Field(default=None)

tests/test_fields.py

@@ -1,7 +1,7 @@
 import pytest
 
 import pydantic.dataclasses
-from pydantic import BaseModel, Field, RootModel, ValidationError, fields
+from pydantic import BaseModel, Field, PydanticUserError, RootModel, ValidationError, fields
 
 
 def test_field_info_annotation_keyword_argument():
@@ -17,6 +17,20 @@ def test_field_info_annotation_keyword_argument():
     assert e.value.args == ('"annotation" is not permitted as a Field keyword argument',)
 
 
+def test_field_info_annotated_attribute_name_clashing():
+    """This tests that `FieldInfo.from_annotated_attribute` will raise a `PydanticUserError` if attribute names clashes
+    with a type.
+    """
+
+    with pytest.raises(PydanticUserError):
+
+        class SubModel(BaseModel):
+            a: int = 1
+
+        class Model(BaseModel):
+            SubModel: SubModel = Field()
+
+
 def test_init_var_field():
     @pydantic.dataclasses.dataclass
     class Foo: