[phase 2] use solutions hook to promote literals

Author: dcreager

crates/ty_python_semantic/src/types/call/bind.rs

@@ -3791,55 +3791,56 @@ impl<'a, 'db> ArgumentTypeChecker<'a, 'db> {
         self.errors.extend(specialization_errors);
 
         // Attempt to promote any promotable types assigned to the specialization.
-        let maybe_promote = |typevar: BoundTypeVarInstance<'db>, ty: Type<'db>| {
-            let bound_or_constraints = typevar.typevar(self.db).bound_or_constraints(self.db);
-
-            // For constrained TypeVars, the inferred type is already one of the
-            // constraints. Promoting literals would produce a type that doesn't
-            // match any constraint.
-            if matches!(
-                bound_or_constraints,
-                Some(TypeVarBoundOrConstraints::Constraints(_))
-            ) {
-                return ty;
-            }
+        // The hook receives (typevar, lower_bound, upper_bound) and returns Some(ty) to
+        // override the default solution, or None to keep it.
+        let maybe_promote =
+            |typevar: BoundTypeVarInstance<'db>, lower: Type<'db>, _upper: Type<'db>| {
+                let bound_or_constraints = typevar.typevar(self.db).bound_or_constraints(self.db);
+
+                // For constrained TypeVars, the inferred type is already one of the
+                // constraints. Promoting literals would produce a type that doesn't
+                // match any constraint.
+                if matches!(
+                    bound_or_constraints,
+                    Some(TypeVarBoundOrConstraints::Constraints(_))
+                ) {
+                    return None;
+                }
 
-            let return_ty = self.constructor_instance_type.unwrap_or(self.return_ty);
-            let mut variance_in_return = TypeVarVariance::Bivariant;
+                let return_ty = self.constructor_instance_type.unwrap_or(self.return_ty);
+                let mut variance_in_return = TypeVarVariance::Bivariant;
 
-            // Find all occurrences of the type variable in the return type.
-            let visit_return_ty = |_, ty, variance, _| {
-                if ty != Type::TypeVar(typevar) {
-                    return;
-                }
+                // Find all occurrences of the type variable in the return type.
+                let visit_return_ty = |_, ty, variance, _| {
+                    if ty != Type::TypeVar(typevar) {
+                        return;
+                    }
 
-                variance_in_return = variance_in_return.join(variance);
-            };
+                    variance_in_return = variance_in_return.join(variance);
+                };
 
-            return_ty.visit_specialization(self.db, self.call_expression_tcx, visit_return_ty);
+                return_ty.visit_specialization(self.db, self.call_expression_tcx, visit_return_ty);
 
-            // Promotion is only useful if the type variable is in invariant or contravariant
-            // position in the return type.
-            if variance_in_return.is_covariant() {
-                return ty;
-            }
+                // Promotion is only useful if the type variable is in invariant or contravariant
+                // position in the return type.
+                if variance_in_return.is_covariant() {
+                    return None;
+                }
 
-            let promoted = ty.promote(self.db);
+                let promoted = lower.promote(self.db);
 
-            // If the TypeVar has an upper bound, only use the promoted type if it
-            // still satisfies the bound.
-            if let Some(TypeVarBoundOrConstraints::UpperBound(bound)) = bound_or_constraints {
-                if !promoted.is_assignable_to(self.db, bound) {
-                    return ty;
+                // If the TypeVar has an upper bound, only use the promoted type if it
+                // still satisfies the bound.
+                if let Some(TypeVarBoundOrConstraints::UpperBound(bound)) = bound_or_constraints {
+                    if !promoted.is_assignable_to(self.db, bound) {
+                        return None;
+                    }
                 }
-            }
 
-            promoted
-        };
+                Some(promoted)
+            };
 
-        let specialization = builder
-            .mapped(generic_context, maybe_promote)
-            .build(generic_context);
+        let specialization = builder.build_with(generic_context, maybe_promote);
 
         self.return_ty = self.return_ty.apply_specialization(self.db, specialization);
         self.specialization = Some(specialization);

crates/ty_python_semantic/src/types/generics.rs

@@ -1751,27 +1751,6 @@ impl<'db, 'c> SpecializationBuilder<'db, 'c> {
         self.types
     }
 
-    /// Map the types that have been assigned in this specialization.
-    pub(crate) fn mapped(
-        &self,
-        generic_context: GenericContext<'db>,
-        f: impl Fn(BoundTypeVarInstance<'db>, Type<'db>) -> Type<'db>,
-    ) -> Self {
-        let mut types = self.types.clone();
-        for (identity, variable) in generic_context.variables_inner(self.db) {
-            if let Some(ty) = types.get_mut(identity) {
-                *ty = f(*variable, *ty);
-            }
-        }
-
-        Self {
-            db: self.db,
-            constraints: self.constraints,
-            inferable: self.inferable,
-            types,
-        }
-    }
-
     pub(crate) fn with_default(
         &self,
         generic_context: GenericContext<'db>,
@@ -1805,24 +1784,20 @@ impl<'db, 'c> SpecializationBuilder<'db, 'c> {
     /// Build a specialization, using a caller-provided hook to select the solution for each
     /// typevar.
     ///
-    /// The `choose` hook is called for each typevar in the generic context with the typevar's
-    /// materialized lower and upper bounds:
-    /// - For typevars that were inferred (present in the type mappings), both bounds are set to
-    ///   the inferred type (representing an equality constraint).
-    /// - For typevars that were not inferred, `lower` is `Never` and `upper` is `object`
-    ///   (representing an unconstrained typevar).
+    /// The `choose` hook is called for each *inferred* typevar (those with entries in the type
+    /// mappings) with the typevar's materialized lower and upper bounds. Currently, both bounds
+    /// are set to the inferred type (representing an equality constraint). Unmapped typevars
+    /// are left to `specialize_recursive` to fill in with defaults.
     ///
     /// The hook returns:
     /// - `Some(ty)` to use `ty` as the specialization for this typevar
-    /// - `None` to use the default (the inferred type for mapped typevars, or the typevar's
-    ///   default for unmapped typevars)
+    /// - `None` to use the inferred type unchanged
     ///
     /// This method replaces the pattern of `mapped(...).build(...)`, allowing callers to
     /// transform inferred types (e.g., literal promotion) in a single step. In the future,
     /// when the builder's internal representation switches from a `HashMap` to a `ConstraintSet`,
     /// the hook will receive actual lower/upper bounds from the constraint set instead of
     /// synthetic equality bounds.
-    #[expect(dead_code)] // Will be used in Phase 2 of the constraint set migration
     pub(crate) fn build_with(
         &mut self,
         generic_context: GenericContext<'db>,
@@ -1832,14 +1807,10 @@ impl<'db, 'c> SpecializationBuilder<'db, 'c> {
             .variables_inner(self.db)
             .iter()
             .map(|(identity, variable)| {
-                if let Some(&mapped_ty) = self.types.get(identity) {
-                    // The typevar was inferred — present both bounds as the inferred type.
-                    let chosen = choose(*variable, mapped_ty, mapped_ty);
-                    Some(chosen.unwrap_or(mapped_ty))
-                } else {
-                    // The typevar was not inferred — present open bounds.
-                    choose(*variable, Type::Never, Type::object())
-                }
+                let mapped_ty = self.types.get(identity).copied()?;
+                // The typevar was inferred — present both bounds as the inferred type.
+                let chosen = choose(*variable, mapped_ty, mapped_ty);
+                Some(chosen.unwrap_or(mapped_ty))
             });
 
         generic_context.specialize_recursive(self.db, types)