Reverts

Author: charliermarsh

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

@@ -2569,9 +2569,9 @@ impl<'db> CallableBinding<'db> {
     ) -> Self {
         let overloads = overloads
             .into_iter()
-            .map(|(original_overload_index, signature)| {
+            .map(|(source_overload_index, signature)| {
                 Binding::single(signature_type, signature)
-                    .with_original_overload_index(original_overload_index)
+                    .with_source_overload_index(source_overload_index)
             })
             .collect();
         Self {
@@ -2615,7 +2615,7 @@ impl<'db> CallableBinding<'db> {
     fn diagnostic_overload_indexes(&self) -> SmallVec<[usize; 1]> {
         self.overloads
             .iter()
-            .map(Binding::original_overload_index)
+            .map(Binding::source_overload_index)
             .collect()
     }
 
@@ -3463,8 +3463,7 @@ impl<'db> CallableBinding<'db> {
                         CallableDescription::new(context.db(), self.signature_type);
                     let matching_overload =
                         function_type_and_kind.map(|(kind, function)| MatchingOverloadLiteral {
-                            index: self.overloads[matching_overload_index]
-                                .original_overload_index(),
+                            index: self.overloads[matching_overload_index].source_overload_index(),
                             kind,
                             function,
                             candidate_indexes: self.diagnostic_overload_indexes(),
@@ -3490,8 +3489,7 @@ impl<'db> CallableBinding<'db> {
                         CallableDescription::new(context.db(), self.signature_type);
                     let matching_overload =
                         function_type_and_kind.map(|(kind, function)| MatchingOverloadLiteral {
-                            index: self.overloads[matching_overload_index]
-                                .original_overload_index(),
+                            index: self.overloads[matching_overload_index].source_overload_index(),
                             kind,
                             function,
                             candidate_indexes: self.diagnostic_overload_indexes(),
@@ -5043,8 +5041,8 @@ pub(crate) struct Binding<'db> {
     ///
     /// For example, if a function defines overloads at indexes `0`, `1`, and `2`, and we later
     /// filter a bound method down to only the last two overloads, those bindings still store `1`
-    /// and `2` here so diagnostics can point at the original declarations.
-    original_overload_index: usize,
+    /// and `2` here so diagnostics can point at the source declarations.
+    source_overload_index: usize,
 
     /// The type that is (hopefully) callable.
     pub(crate) callable_type: Type<'db>,
@@ -5087,7 +5085,7 @@ impl<'db> Binding<'db> {
         let return_ty = signature.return_ty;
         Binding {
             signature,
-            original_overload_index: 0,
+            source_overload_index: 0,
             callable_type: signature_type,
             signature_type,
             return_ty,
@@ -5101,15 +5099,15 @@ impl<'db> Binding<'db> {
         }
     }
 
-    /// Records the overload's original definition index for later diagnostics.
-    fn with_original_overload_index(mut self, original_overload_index: usize) -> Self {
-        self.original_overload_index = original_overload_index;
+    /// Records the overload's source definition index for later diagnostics.
+    fn with_source_overload_index(mut self, source_overload_index: usize) -> Self {
+        self.source_overload_index = source_overload_index;
         self
     }
 
-    /// Returns the overload's original position in the defining function's overload list.
-    fn original_overload_index(&self) -> usize {
-        self.original_overload_index
+    /// Returns the overload's source position in the defining function's overload list.
+    fn source_overload_index(&self) -> usize {
+        self.source_overload_index
     }
 
     fn replace_callable_type(&mut self, before: Type<'db>, after: Type<'db>) {
@@ -6418,7 +6416,7 @@ impl CompoundDiagnostic for LayeredDiagnostic<'_, '_> {
 struct MatchingOverloadLiteral<'db> {
     /// The position of the matching overload in the list of overloads.
     index: usize,
-    /// The original overload positions that remained after any callable-specific filtering.
+    /// The source overload positions that remained after any callable-specific filtering.
     candidate_indexes: SmallVec<[usize; 1]>,
     /// The kind of function this overload is for.
     kind: FunctionKind,
@@ -6443,7 +6441,7 @@ impl<'db> MatchingOverloadLiteral<'db> {
     }
 
     /// Iterates the overload literals that remain diagnostic candidates, paired with their
-    /// original overload-definition index.
+    /// source overload-definition index.
     fn candidate_overloads(
         &self,
         db: &'db dyn Db,

crates/ty_python_semantic/src/types/method.rs

@@ -81,38 +81,34 @@ impl<'db> BoundMethodType<'db> {
         let function_signature = self.function(db).signature(db);
         let typing_self_type = self.typing_self_type(db);
 
-        if let Some(applicable_overload_indexes) = self.applicable_overload_indexes(db)
-            && !applicable_overload_indexes.is_empty()
-        {
-            return CallableSignature::from_overloads(applicable_overload_indexes.into_iter().map(
-                |index| function_signature.overloads[index].bind_self(db, Some(typing_self_type)),
-            ));
-        }
-
-        CallableSignature::from_overloads(
-            function_signature
+        let mut applicable_overloads: SmallVec<[Signature<'db>; 1]> = self
+            .applicable_overloads(db)
+            .into_iter()
+            .map(|signature| signature.bind_self(db, Some(typing_self_type)))
+            .collect();
+
+        // If no overload accepts the bound receiver, keep the full overload set so a later call
+        // still reports the existing invalid-`self` diagnostic instead of becoming non-callable.
+        if applicable_overloads.is_empty() {
+            applicable_overloads = function_signature
                 .overloads
                 .iter()
-                .map(|signature| signature.bind_self(db, Some(typing_self_type))),
-        )
-    }
-
-    fn applicable_overload_indexes(self, db: &'db dyn Db) -> Option<SmallVec<[usize; 1]>> {
-        let function_signature = self.function(db).signature(db);
-        if !function_signature.has_receiver_sensitive_overloads() {
-            return None;
+                .map(|signature| signature.bind_self(db, Some(typing_self_type)))
+                .collect();
         }
 
+        CallableSignature::from_overloads(applicable_overloads)
+    }
+
+    fn applicable_overloads(self, db: &'db dyn Db) -> SmallVec<[Signature<'db>; 1]> {
         let self_instance = self.self_instance(db);
-        Some(
-            function_signature
-                .overloads
-                .iter()
-                .enumerate()
-                .filter(|(_, signature)| signature.can_bind_self_to(db, self_instance))
-                .map(|(index, _)| index)
-                .collect(),
-        )
+        self.function(db)
+            .signature(db)
+            .overloads
+            .iter()
+            .filter(|signature| signature.can_bind_self_to(db, self_instance))
+            .cloned()
+            .collect()
     }
 
     pub(super) fn recursive_type_normalized_impl(

crates/ty_python_semantic/src/types/signatures.rs

@@ -29,8 +29,8 @@ use crate::types::relation::{
 use crate::types::{
     ApplyTypeMappingVisitor, BindingContext, BoundTypeVarInstance, CallableType, ErrorContext,
     FindLegacyTypeVarsVisitor, KnownClass, MaterializationKind, ParamSpecAttrKind,
-    ParameterDescription, SelfBinding, SubclassOfInner, TypeContext, TypeMapping, UnionBuilder,
-    VarianceInferable, infer_complete_scope_types, todo_type,
+    ParameterDescription, SelfBinding, TypeContext, TypeMapping, UnionBuilder, VarianceInferable,
+    infer_complete_scope_types, todo_type,
 };
 use crate::{Db, FxOrderSet};
 use ruff_python_ast::{self as ast, name::Name};
@@ -301,20 +301,6 @@ impl<'db> CallableSignature<'db> {
         }
     }
 
-    /// Returns `true` if binding a concrete receiver could change which overloads remain
-    /// applicable.
-    ///
-    /// When every overload has the same receiver annotation (or they are all unannotated),
-    /// receiver-based pruning cannot affect the overload set, so we can skip the more expensive
-    /// relation checks during bound-method conversion.
-    pub(crate) fn has_receiver_sensitive_overloads(&self) -> bool {
-        let mut receiver_annotations = self.overloads.iter().map(Signature::receiver_annotation);
-        let Some(first_annotation) = receiver_annotations.next() else {
-            return false;
-        };
-        receiver_annotations.any(|annotation| annotation != first_annotation)
-    }
-
     /// Replaces any occurrences of `typing.Self` in the parameter and return annotations with the
     /// given type. (Does not bind the `self` parameter; to do that, use
     /// [`bind_self`][Self::bind_self].)
@@ -745,13 +731,6 @@ impl<'db> Signature<'db> {
         }
     }
 
-    fn receiver_annotation(&self) -> Option<Type<'db>> {
-        let first_parameter = self.parameters.get(0)?;
-        first_parameter
-            .is_positional()
-            .then(|| first_parameter.annotated_type())
-    }
-
     /// Returns `true` if this signature's first parameter can accept the bound `self` type.
     ///
     /// This is used to prune impossible overloads when a method is bound to a concrete receiver.
@@ -765,35 +744,23 @@ impl<'db> Signature<'db> {
             return true;
         }
 
-        let annotated_self_ty = first_parameter.annotated_type();
-        let expected_self_ty = if annotated_self_ty.contains_self(db)
-            || annotated_self_ty.has_typevar_or_typevar_instance(db)
-        {
-            annotated_self_ty
-                .bind_self_typevars(db, self_type)
-                .apply_optional_specialization(db, self_type.class_specialization(db))
-        } else {
-            annotated_self_ty
-        };
+        let expected_self_ty = first_parameter
+            .annotated_type()
+            .bind_self_typevars(db, self_type)
+            .apply_optional_specialization(db, self_type.class_specialization(db));
 
         if expected_self_ty.is_unknown() {
             return true;
         }
 
-        if let Some(can_bind) =
-            can_bind_self_to_concrete_receiver_fast_path(db, self_type, expected_self_ty)
-        {
-            return can_bind;
-        }
-
         let constraints = ConstraintSetBuilder::new();
-        let inferable_typevars = if expected_self_ty.has_typevar_or_typevar_instance(db) {
-            self.inferable_typevars(db)
-        } else {
-            InferableTypeVars::None
-        };
         self_type
-            .when_assignable_to(db, expected_self_ty, &constraints, inferable_typevars)
+            .when_assignable_to(
+                db,
+                expected_self_ty,
+                &constraints,
+                self.inferable_typevars(db),
+            )
             .is_always_satisfied(db)
     }
 
@@ -921,58 +888,6 @@ impl<'db> Signature<'db> {
     }
 }
 
-fn can_bind_self_to_concrete_receiver_fast_path<'db>(
-    db: &'db dyn Db,
-    self_type: Type<'db>,
-    expected_self_ty: Type<'db>,
-) -> Option<bool> {
-    if self_type.has_dynamic(db)
-        || self_type.has_typevar_or_typevar_instance(db)
-        || expected_self_ty.has_dynamic(db)
-        || expected_self_ty.has_typevar_or_typevar_instance(db)
-    {
-        return None;
-    }
-
-    if let (Some(actual_class), Some(expected_class)) = (
-        self_type.nominal_class(db),
-        expected_self_ty.nominal_class(db),
-    ) {
-        return Some(actual_class.is_subclass_of(db, expected_class));
-    }
-
-    let actual_subclass = match self_type {
-        Type::ClassLiteral(_) | Type::GenericAlias(_) => {
-            match super::SubclassOfType::try_from_type(db, self_type) {
-                Some(Type::SubclassOf(subclass_of)) => Some(subclass_of),
-                _ => None,
-            }
-        }
-        Type::SubclassOf(subclass_of) => Some(subclass_of),
-        _ => None,
-    }?;
-    let expected_subclass = match expected_self_ty {
-        Type::ClassLiteral(_) | Type::GenericAlias(_) => {
-            match super::SubclassOfType::try_from_type(db, expected_self_ty) {
-                Some(Type::SubclassOf(subclass_of)) => Some(subclass_of),
-                _ => None,
-            }
-        }
-        Type::SubclassOf(subclass_of) => Some(subclass_of),
-        _ => None,
-    }?;
-
-    match (
-        actual_subclass.subclass_of(),
-        expected_subclass.subclass_of(),
-    ) {
-        (SubclassOfInner::Class(actual_class), SubclassOfInner::Class(expected_class)) => {
-            Some(actual_class.is_subclass_of(db, expected_class))
-        }
-        _ => None,
-    }
-}
-
 impl<'db> VarianceInferable<'db> for &Signature<'db> {
     fn variance_of(self, db: &'db dyn Db, typevar: BoundTypeVarInstance<'db>) -> TypeVarVariance {
         tracing::trace!(