avoid duplicated diagnostics during function argument inference

Author: ibraheemdev

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

@@ -1663,7 +1663,12 @@ def _(arg: tuple[A | B, Any]):
     reveal_type(f(*(arg,)))  # revealed: Unknown
 ```
 
-## Bi-directional Type Inference
+## Bidirectional Type Inference
+
+```toml
+[environment]
+python-version = "3.12"
+```
 
 Type inference accounts for parameter type annotations across all overloads.
 
@@ -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

@@ -252,7 +252,12 @@ def _(x: Union[Intersection[Any, Not[int]], Intersection[Any, Not[int]]]):
     reveal_type(x)  # revealed: Any & ~int
 ```
 
-## Bi-directional Type Inference
+## Bidirectional Type Inference
+
+```toml
+[environment]
+python-version = "3.12"
+```
 
 Type inference accounts for parameter type annotations across all signatures in a union.
 
@@ -272,7 +277,33 @@ 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})
 ```
+
+Diagnostics unrelated to the type-context are only reported once:
+
+```py
+def f[T](x: T) -> list[T]:
+    return [x]
+
+def a(x: list[bool], y: list[bool]): ...
+def b(x: list[int], y: list[int]): ...
+def c(x: list[int], y: list[int]): ...
+def _(x: int):
+    if x == 0:
+        y = a
+    elif x == 1:
+        y = b
+    else:
+        y = c
+
+    if x == 0:
+        z = True
+
+    y(f(True), [True])
+
+    # error: [possibly-unresolved-reference] "Name `z` used when possibly not defined"
+    y(f(True), [z])
+```

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

@@ -40,6 +40,7 @@ pub(crate) struct InferContext<'db, 'ast> {
     module: &'ast ParsedModuleRef,
     diagnostics: std::cell::RefCell<TypeCheckDiagnostics>,
     no_type_check: InNoTypeCheck,
+    multi_inference: bool,
     bomb: DebugDropBomb,
 }
 
@@ -50,6 +51,7 @@ impl<'db, 'ast> InferContext<'db, 'ast> {
             scope,
             module,
             file: scope.file(db),
+            multi_inference: false,
             diagnostics: std::cell::RefCell::new(TypeCheckDiagnostics::default()),
             no_type_check: InNoTypeCheck::default(),
             bomb: DebugDropBomb::new(
@@ -156,6 +158,18 @@ impl<'db, 'ast> InferContext<'db, 'ast> {
         DiagnosticGuardBuilder::new(self, id, severity)
     }
 
+    /// Returns `true` if the current expression is being inferred for a second
+    /// (or subsequent) time, with a potentially different bidirectional type
+    /// context.
+    pub(super) fn is_in_multi_inference(&self) -> bool {
+        self.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) {
         self.no_type_check = no_type_check;
     }
@@ -410,6 +424,11 @@ impl<'db, 'ctx> LintDiagnosticGuardBuilder<'db, 'ctx> {
         if ctx.is_in_no_type_check() {
             return None;
         }
+        // If this lint is being reported as part of multi-inference of a given expression,
+        // silence it to avoid duplicated diagnostics.
+        if ctx.is_in_multi_inference() {
+            return None;
+        }
         let id = DiagnosticId::Lint(lint.name());
 
         let suppressions = suppressions(ctx.db(), ctx.file());