From caed80df5e5e755ce4e89ccb6cbcb755f1dc7758 Mon Sep 17 00:00:00 2001
From: Ibraheem Ahmed <ibraheem@ibraheem.ca>
Date: Wed, 10 Dec 2025 18:33:00 -0500
Subject: [PATCH] avoid dataclass field regression

---
 .../resources/mdtest/dataclasses/fields.md        |  2 +-
 crates/ty_python_semantic/src/types/call/bind.rs  | 15 ++++++++++-----
 2 files changed, 11 insertions(+), 6 deletions(-)

diff --git a/crates/ty_python_semantic/resources/mdtest/dataclasses/fields.md b/crates/ty_python_semantic/resources/mdtest/dataclasses/fields.md
index 1727439778..28a69081e5 100644
--- a/crates/ty_python_semantic/resources/mdtest/dataclasses/fields.md
+++ b/crates/ty_python_semantic/resources/mdtest/dataclasses/fields.md
@@ -37,7 +37,7 @@ class Data:
     content: list[int] = field(default_factory=list)
     timestamp: datetime = field(default_factory=datetime.now, init=False)
 
-# revealed: (self: Data, content: list[int] = Unknown) -> None
+# revealed: (self: Data, content: list[int] = list[int]) -> None
 reveal_type(Data.__init__)
 
 data = Data([1, 2, 3])
diff --git a/crates/ty_python_semantic/src/types/call/bind.rs b/crates/ty_python_semantic/src/types/call/bind.rs
index bf7be4917a..c05186a13e 100644
--- a/crates/ty_python_semantic/src/types/call/bind.rs
+++ b/crates/ty_python_semantic/src/types/call/bind.rs
@@ -2819,13 +2819,16 @@ impl<'a, 'db> ArgumentTypeChecker<'a, 'db> {
         // Prefer the declared type of generic classes.
         let preferred_type_mappings = return_with_tcx.and_then(|(return_ty, tcx)| {
             let tcx = tcx.filter_union(self.db, |ty| ty.class_specialization(self.db).is_some());
-            let return_ty =
-                return_ty.filter_union(self.db, |ty| ty.class_specialization(self.db).is_some());
+            tcx.class_specialization(self.db)?;
+
+            let return_specialization = return_ty
+                .filter_union(self.db, |ty| ty.class_specialization(self.db).is_some())
+                .class_specialization(self.db);
 
             // TODO: We should use the constraint solver here to determine the type mappings for more
-            // complex subtyping relationships, e.g., `type[C[T]]` to `Callable[..., T]`, or unions
-            // containing multiple generic elements.
-            if let Some((class_literal, _)) = return_ty.class_specialization(self.db)
+            // complex subtyping relationships, e.g., callables, protocols, or unions containing multiple
+            // generic elements.
+            if let Some((class_literal, _)) = return_specialization
                 && let Some(generic_alias) = class_literal.into_generic_alias()
             {
                 let specialization = generic_alias.specialization(self.db);
@@ -2842,6 +2845,8 @@ impl<'a, 'db> ArgumentTypeChecker<'a, 'db> {
                         builder.infer(*return_ty, ty).ok()?;
                     }
                 }
+            } else {
+                builder.infer(return_ty, tcx).ok()?;
             }
 
             Some(builder.type_mappings().clone())