avoid type errors on first non-matching overload

Author: ibraheemdev

crates/ty_python_semantic/resources/mdtest/call/overloads.md

@@ -1665,6 +1665,11 @@ def _(arg: tuple[A | B, Any]):
 
 ## Bidirectional Type Inference
 
+```toml
+[environment]
+python-version = "3.12"
+```
+
 Type inference accounts for parameter type annotations across all overloads.
 
 ```py
@@ -1709,3 +1714,15 @@ def f(a: T | dict[str, int], b: int | str) -> int | str:
 x = f({"y": 1}, "a")
 reveal_type(x)  # revealed: str
 ```
+
+```py
+from typing import SupportsRound, overload
+
+@overload
+def takes_str_or_float(x: str): ...
+@overload
+def takes_str_or_float(x: float): ...
+def takes_str_or_float(x: float | str): ...
+
+takes_str_or_float(round(1.0))
+```

crates/ty_python_semantic/resources/mdtest/call/union.md

@@ -277,8 +277,8 @@ def _(flag: bool):
     x = f({"x": 1})
     reveal_type(x)  # revealed: int
 
-    # error: [missing-typed-dict-key] "Missing required key 'x' in TypedDict `T` constructor"
-    # error: [invalid-key] "Invalid key access on TypedDict `T`: Unknown key "y""
+    # TODO: error: [invalid-argument-type] "Argument to function `f` is incorrect: Expected `T`, found `dict[str, int]`"
+    # we currently consider `TypedDict` instances to be subtypes of `dict`
     f({"y": 1})
 ```
 

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

@@ -2048,16 +2048,6 @@ pub(crate) enum MatchingOverloadIndex {
     Multiple(Vec<usize>),
 }
 
-impl MatchingOverloadIndex {
-    pub(crate) fn count(self) -> usize {
-        match self {
-            MatchingOverloadIndex::None => 0,
-            MatchingOverloadIndex::Single(_) => 1,
-            MatchingOverloadIndex::Multiple(items) => items.len(),
-        }
-    }
-}
-
 #[derive(Default, Debug)]
 struct ArgumentForms {
     values: Vec<Option<ParameterForm>>,
@@ -2535,8 +2525,8 @@ impl<'a, 'db> ArgumentTypeChecker<'a, 'db> {
                 Type::TypeVar(_) => {}
 
                 _ => {
-                    // Ignore any specialization errors here, because the type context is only used to
-                    // optionally widen the return type.
+                    // Ignore any specialization errors here, because the type context is only used as a hint
+                    // to infer a more assignable return type.
                     let _ = builder.infer(return_ty, call_expression_tcx);
                 }
             }

crates/ty_python_semantic/src/types/context.rs

@@ -133,21 +133,7 @@ impl<'db, 'ast> InferContext<'db, 'ast> {
         lint: &'static LintMetadata,
         ranged: T,
     ) -> Option<LintDiagnosticGuardBuilder<'ctx, 'db>> {
-        LintDiagnosticGuardBuilder::new(self, lint, ranged.range(), false)
-    }
-
-    /// Similar to `report_lint`, except forces the diagnostic to be
-    /// reported even when inferring an expression multiple times.
-    ///
-    /// This should be used for diagnostics that are affected by bidirectional
-    /// type context, which may change across multiple inferences of a function
-    /// argument expression.
-    pub(super) fn report_bidirectional_lint<'ctx, T: Ranged>(
-        &'ctx self,
-        lint: &'static LintMetadata,
-        ranged: T,
-    ) -> Option<LintDiagnosticGuardBuilder<'ctx, 'db>> {
-        LintDiagnosticGuardBuilder::new(self, lint, ranged.range(), true)
+        LintDiagnosticGuardBuilder::new(self, lint, ranged.range())
     }
 
     /// Optionally return a builder for a diagnostic guard.
@@ -179,8 +165,9 @@ impl<'db, 'ast> InferContext<'db, 'ast> {
         self.multi_inference
     }
 
-    pub(super) fn set_multi_inference(&mut self, multi_inference: bool) {
-        self.multi_inference = multi_inference;
+    /// Set the multi-inference state, returning the previous value.
+    pub(super) fn set_multi_inference(&mut self, multi_inference: bool) -> bool {
+        std::mem::replace(&mut self.multi_inference, multi_inference)
     }
 
     pub(super) fn set_in_no_type_check(&mut self, no_type_check: InNoTypeCheck) {
@@ -413,7 +400,6 @@ impl<'db, 'ctx> LintDiagnosticGuardBuilder<'db, 'ctx> {
         ctx: &'ctx InferContext<'db, 'ctx>,
         lint: &'static LintMetadata,
         range: TextRange,
-        bidirectional: bool,
     ) -> Option<LintDiagnosticGuardBuilder<'db, 'ctx>> {
         // The comment below was copied from the original
         // implementation of diagnostic reporting. The code
@@ -439,9 +425,8 @@ impl<'db, 'ctx> LintDiagnosticGuardBuilder<'db, 'ctx> {
             return None;
         }
         // If this lint is being reported as part of multi-inference of a given expression,
-        // silence it to avoid duplicated diagnostics, unless it may have been affected by
-        // the bidirectional type context.
-        if ctx.is_in_multi_inference() && !bidirectional {
+        // silence it to avoid duplicated diagnostics.
+        if ctx.is_in_multi_inference() {
             return None;
         }
         let id = DiagnosticId::Lint(lint.name());