temporary fix for typevar identity with mark_inferable

Author: carljm

crates/ty_python_semantic/resources/mdtest/generics/legacy/variables.md

@@ -411,4 +411,27 @@ class D(Generic[V]):
 reveal_type(D().x)  # revealed: V@D
 ```
 
+## Regression
+
+### Use of typevar with default inside a function body that binds it
+
+```toml
+[environment]
+python-version = "3.13"
+```
+
+```py
+from typing import Generic, TypeVar
+
+_DataT = TypeVar("_DataT", bound=int, default=int)
+
+class Event(Generic[_DataT]):
+    def __init__(self, data: _DataT) -> None:
+        self.data = data
+
+def async_fire_internal(event_data: _DataT):
+    event: Event[_DataT] | None = None
+    event = Event(event_data)
+```
+
 [generics]: https://typing.python.org/en/latest/spec/generics.html

crates/ty_python_semantic/src/types.rs

@@ -1600,7 +1600,9 @@ impl<'db> Type<'db> {
             (
                 Type::NonInferableTypeVar(lhs_bound_typevar),
                 Type::NonInferableTypeVar(rhs_bound_typevar),
-            ) if lhs_bound_typevar == rhs_bound_typevar => ConstraintSet::from(true),
+            ) if lhs_bound_typevar.is_identical_to(db, rhs_bound_typevar) => {
+                ConstraintSet::from(true)
+            }
 
             // A fully static typevar is a subtype of its upper bound, and to something similar to
             // the union of its constraints. An unbound, unconstrained, fully static typevar has an
@@ -7686,6 +7688,12 @@ pub struct TypeVarInstance<'db> {
     _default: Option<TypeVarDefaultEvaluation<'db>>,
 
     pub kind: TypeVarKind,
+
+    /// If this typevar was transformed from another typevar via `mark_typevars_inferable`, this
+    /// records the identity of the "original" typevar, so we can recognize them as the same
+    /// typevar in `bind_typevar`. TODO: this (and the `is_identical_to` methods) should be
+    /// removable once we remove `mark_typevars_inferable`.
+    pub(crate) original: Option<TypeVarInstance<'db>>,
 }
 
 // The Salsa heap is tracked separately.
@@ -7796,6 +7804,7 @@ impl<'db> TypeVarInstance<'db> {
                     .map(|ty| ty.normalized_impl(db, visitor).into()),
             }),
             self.kind(db),
+            self.original(db),
         )
     }
 
@@ -7841,6 +7850,7 @@ impl<'db> TypeVarInstance<'db> {
                     .map(|ty| ty.materialize(db, materialization_kind, visitor).into()),
             }),
             self.kind(db),
+            self.original(db),
         )
     }
 
@@ -7854,10 +7864,7 @@ impl<'db> TypeVarInstance<'db> {
         // inferable, so we set the parameter to `None` here.
         let type_mapping = &TypeMapping::MarkTypeVarsInferable(None);
 
-        Self::new(
-            db,
-            self.name(db),
-            self.definition(db),
+        let new_bound_or_constraints =
             self._bound_or_constraints(db)
                 .map(|bound_or_constraints| match bound_or_constraints {
                     TypeVarBoundOrConstraintsEvaluation::Eager(bound_or_constraints) => {
@@ -7867,20 +7874,44 @@ impl<'db> TypeVarInstance<'db> {
                     }
                     TypeVarBoundOrConstraintsEvaluation::LazyUpperBound
                     | TypeVarBoundOrConstraintsEvaluation::LazyConstraints => bound_or_constraints,
-                }),
+                });
+
+        let new_default = self._default(db).and_then(|default| match default {
+            TypeVarDefaultEvaluation::Eager(ty) => {
+                Some(ty.apply_type_mapping_impl(db, type_mapping, visitor).into())
+            }
+            TypeVarDefaultEvaluation::Lazy => self
+                .lazy_default(db)
+                .map(|ty| ty.apply_type_mapping_impl(db, type_mapping, visitor).into()),
+        });
+
+        // Ensure that we only modify the `original` field if we are going to modify one or both of
+        // `_bound_or_constraints` and `_default`; don't trigger creation of a new
+        // `TypeVarInstance` unnecessarily.
+        let new_original = if new_bound_or_constraints == self._bound_or_constraints(db)
+            && new_default == self._default(db)
+        {
+            self.original(db)
+        } else {
+            Some(self)
+        };
+
+        Self::new(
+            db,
+            self.name(db),
+            self.definition(db),
+            new_bound_or_constraints,
             self.explicit_variance(db),
-            self._default(db).and_then(|default| match default {
-                TypeVarDefaultEvaluation::Eager(ty) => {
-                    Some(ty.apply_type_mapping_impl(db, type_mapping, visitor).into())
-                }
-                TypeVarDefaultEvaluation::Lazy => self
-                    .lazy_default(db)
-                    .map(|ty| ty.apply_type_mapping_impl(db, type_mapping, visitor).into()),
-            }),
+            new_default,
             self.kind(db),
+            new_original,
         )
     }
 
+    fn is_identical_to(self, db: &'db dyn Db, other: Self) -> bool {
+        self == other || (self.original(db) == Some(other) || other.original(db) == Some(self))
+    }
+
     fn to_instance(self, db: &'db dyn Db) -> Option<Self> {
         let bound_or_constraints = match self.bound_or_constraints(db)? {
             TypeVarBoundOrConstraints::UpperBound(upper_bound) => {
@@ -7898,6 +7929,7 @@ impl<'db> TypeVarInstance<'db> {
             self.explicit_variance(db),
             None,
             self.kind(db),
+            self.original(db),
         ))
     }
 
@@ -8062,6 +8094,7 @@ impl<'db> BoundTypeVarInstance<'db> {
                 Some(variance),
                 None, // _default
                 TypeVarKind::Pep695,
+                None,
             ),
             BindingContext::Synthetic,
         )
@@ -8083,11 +8116,24 @@ impl<'db> BoundTypeVarInstance<'db> {
                 Some(TypeVarVariance::Invariant),
                 None,
                 TypeVarKind::TypingSelf,
+                None,
             ),
             binding_context,
         )
     }
 
+    pub(crate) fn is_identical_to(self, db: &'db dyn Db, other: Self) -> bool {
+        if self == other {
+            return true;
+        }
+
+        if self.binding_context(db) != other.binding_context(db) {
+            return false;
+        }
+
+        self.typevar(db).is_identical_to(db, other.typevar(db))
+    }
+
     pub(crate) fn variance_with_polarity(
         self,
         db: &'db dyn Db,

crates/ty_python_semantic/src/types/generics.rs

@@ -126,6 +126,7 @@ pub(crate) fn typing_self<'db>(
         Some(TypeVarVariance::Invariant),
         None,
         TypeVarKind::TypingSelf,
+        None,
     );
 
     bind_typevar(
@@ -396,7 +397,7 @@ impl<'db> GenericContext<'db> {
         typevar: TypeVarInstance<'db>,
     ) -> Option<BoundTypeVarInstance<'db>> {
         self.variables(db)
-            .find(|self_bound_typevar| self_bound_typevar.typevar(db) == typevar)
+            .find(|self_bound_typevar| self_bound_typevar.typevar(db).is_identical_to(db, typevar))
     }
 
     /// Creates a specialization of this generic context. Panics if the length of `types` does not

crates/ty_python_semantic/src/types/infer/builder.rs

@@ -2964,6 +2964,7 @@ impl<'db, 'ast> TypeInferenceBuilder<'db, 'ast> {
             None,
             default.as_deref().map(|_| TypeVarDefaultEvaluation::Lazy),
             TypeVarKind::Pep695,
+            None,
         )));
         self.add_declaration_with_binding(
             node.into(),
@@ -4255,6 +4256,7 @@ impl<'db, 'ast> TypeInferenceBuilder<'db, 'ast> {
             Some(variance),
             default,
             TypeVarKind::Legacy,
+            None,
         )))
     }