Explicitly raise an error if field names clashes with types

docs/errors/usage_errors.md

@@ -1018,5 +1018,31 @@ 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
+from datetime import date
+
+from pydantic import BaseModel
+
+class Model(BaseModel):
+    date: date = Field(description="A date")
+```
+
+As a workaround, you can either use an alias or change your import:
+
+```py
+import datetime
+# Or `from datetime import date as _date`
+
+from pydantic import BaseModel
+
+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():

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: