Hack: attempt to fix regression

Author: charliermarsh

crates/ty_python_semantic/resources/mdtest/overloads.md

@@ -159,7 +159,7 @@ python-version = "3.12"
 ```
 
 ```py
-from typing import overload
+from typing import Generic, TypeVar, overload
 
 class Box[T]:
     # Use the class type parameter so specializations remain meaningful.
@@ -174,6 +174,19 @@ class Box[T]:
 
 reveal_type(Box[int]().specialized)  # revealed: bound method Box[int].specialized(x: int) -> int
 reveal_type(Box[str]().specialized)  # revealed: Overload[(x: str) -> str, (x: int) -> int]
+
+T_co = TypeVar("T_co", covariant=True)
+
+class Reader(Generic[T_co]):
+    @overload
+    def get(self: "Reader[int]", default: int) -> int: ...
+    @overload
+    def get(self: "Reader[str]", default: str) -> str: ...
+    def get(self, default: object) -> object:
+        return default
+
+def union_receiver(reader: Reader[int | str]):
+    reveal_type(reader.get)  # revealed: Overload[(default: int) -> int, (default: str) -> str]
 ```
 
 ## Constructor

crates/ty_python_semantic/resources/mdtest/regression/2799_constraint_correlation.md

@@ -26,9 +26,9 @@ S2 = TypeVar("S2")
 
 class ElementOpsMixin(Generic[S2]):
     @overload
-    def _proto_mul(self: "ElementOpsMixin[bool]", other: bool) -> "ElementOpsMixin[bool]": ...
+    def _proto_mul(self, other: bool) -> "ElementOpsMixin[bool]": ...
     @overload
-    def _proto_mul(self: "ElementOpsMixin[str]", other: str) -> "ElementOpsMixin[str]": ...
+    def _proto_mul(self, other: str) -> "ElementOpsMixin[str]": ...
     def _proto_mul(self, other):
         raise NotImplementedError
 

crates/ty_python_semantic/src/types/method.rs

@@ -76,32 +76,45 @@ impl<'db> BoundMethodType<'db> {
         )
     }
 
+    #[salsa::tracked(cycle_initial=|_, _, _| CallableSignature::bottom(), heap_size=ruff_memory_usage::heap_size)]
     pub(crate) fn bound_signatures(self, db: &'db dyn Db) -> CallableSignature<'db> {
-        let self_instance = self.self_instance(db);
+        let function_signature = self.function(db).signature(db);
         let typing_self_type = self.typing_self_type(db);
 
-        let mut applicable_overloads = self
-            .function(db)
-            .signature(db)
-            .overloads
-            .iter()
-            .filter(|signature| signature.can_bind_self_to(db, self_instance))
-            .map(|signature| signature.bind_self(db, Some(typing_self_type)))
-            .peekable();
-
-        // 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.peek().is_none() {
-            let function_signature = self.function(db).signature(db);
-            CallableSignature::from_overloads(
-                function_signature
-                    .overloads
-                    .iter()
-                    .map(|signature| signature.bind_self(db, Some(typing_self_type))),
-            )
-        } else {
-            CallableSignature::from_overloads(applicable_overloads)
-        }
+        let [signature] = function_signature.overloads.as_slice() else {
+            let self_instance = self.self_instance(db);
+            let bind_all_overloads = || {
+                CallableSignature::from_overloads(
+                    function_signature
+                        .overloads
+                        .iter()
+                        .map(|signature| signature.bind_self(db, Some(typing_self_type))),
+                )
+            };
+
+            // A gradual receiver can satisfy any receiver-specific overload, so filtering cannot
+            // safely discard candidates.
+            if self_instance.has_dynamic(db) {
+                return bind_all_overloads();
+            }
+
+            let mut applicable_overloads = function_signature
+                .overloads
+                .iter()
+                .filter(|signature| signature.can_bind_self_to(db, self_instance))
+                .map(|signature| signature.bind_self(db, Some(typing_self_type)))
+                .peekable();
+
+            // 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.
+            return if applicable_overloads.peek().is_none() {
+                bind_all_overloads()
+            } else {
+                CallableSignature::from_overloads(applicable_overloads)
+            };
+        };
+
+        CallableSignature::single(signature.bind_self(db, Some(typing_self_type)))
     }
 
     pub(super) fn recursive_type_normalized_impl(

crates/ty_python_semantic/src/types/signatures.rs

@@ -26,6 +26,7 @@ use crate::types::infer::infer_deferred_types;
 use crate::types::relation::{
     HasRelationToVisitor, IsDisjointVisitor, TypeRelation, TypeRelationChecker,
 };
+use crate::types::visitor::any_over_type;
 use crate::types::{
     ApplyTypeMappingVisitor, BindingContext, BoundTypeVarInstance, CallableType, ErrorContext,
     FindLegacyTypeVarsVisitor, KnownClass, MaterializationKind, ParamSpecAttrKind,
@@ -744,30 +745,58 @@ impl<'db> Signature<'db> {
             return true;
         };
 
+        // If there is no positional receiver, this signature cannot be pruned based on `self`.
         if !first_parameter.is_positional() {
             return true;
         }
 
-        let expected_self_ty = first_parameter
-            .annotated_type()
-            .bind_self_typevars(db, self_type)
-            .apply_optional_specialization(db, self_type.class_specialization(db));
+        let mut expected_self_ty = first_parameter.annotated_type();
 
+        // Avoid the more expensive normalization below for receiver annotations that already
+        // accept all values, or already exactly match the bound receiver.
         if expected_self_ty.is_dynamic()
             || expected_self_ty.is_object()
             || expected_self_ty == self_type
         {
             return true;
         }
 
+        // `Self`-like typevars in the receiver annotation are bound using the concrete receiver.
+        expected_self_ty = expected_self_ty.bind_self_typevars(db, self_type);
+
+        if expected_self_ty.is_dynamic()
+            || expected_self_ty.is_object()
+            || expected_self_ty == self_type
+        {
+            return true;
+        }
+
+        // A specialized receiver can make generic receiver annotations concrete enough to compare.
+        if let Some(self_specialization) = self_type.class_specialization(db) {
+            expected_self_ty =
+                expected_self_ty.apply_optional_specialization(db, Some(self_specialization));
+
+            if expected_self_ty.is_dynamic()
+                || expected_self_ty.is_object()
+                || expected_self_ty == self_type
+            {
+                return true;
+            }
+        }
+
+        let inferable = self.inferable_typevars(db);
         let constraints = ConstraintSetBuilder::new();
+        if any_over_type(db, self_type, false, Type::is_union) {
+            // A union receiver can bind an overload that accepts any possible receiver
+            // alternative; whole-type assignability would only keep overloads that accept all of
+            // them.
+            return !self_type
+                .when_disjoint_from(db, expected_self_ty, &constraints, inferable)
+                .is_always_satisfied(db);
+        }
+
         self_type
-            .when_assignable_to(
-                db,
-                expected_self_ty,
-                &constraints,
-                self.inferable_typevars(db),
-            )
+            .when_assignable_to(db, expected_self_ty, &constraints, inferable)
             .is_always_satisfied(db)
     }