Do it the crude way to see real implications

Author: sterliakov

mypy/checkexpr.py

@@ -2892,33 +2892,31 @@ def infer_overload_return_type(
         Assumes all of the given targets have argument counts compatible with the caller.
         """
 
-        matches: list[CallableType] = []
-        return_types: list[Type] = []
-        inferred_types: list[Type] = []
         args_contain_any = any(map(has_any_type, arg_types))
-        type_maps: list[dict[Expression, Type]] = []
 
+        # First do a pass without external context and find all overloads that
+        # can be possibly matched. If no Any is present among args, bail out early
+        # on the first match.
+        candidates = []
         for typ in plausible_targets:
             assert self.msg is self.chk.msg
-            with self.msg.filter_errors() as w:
-                with self.chk.local_type_map as m:
-                    # Overload selection should not depend on the context.
-                    # During this step pretend that we do not have any external information.
-                    self.type_context.append(None)
-                    ret_type, infer_type = self.check_call(
-                        callee=typ,
-                        args=args,
-                        arg_kinds=arg_kinds,
-                        arg_names=arg_names,
-                        context=context,
-                        callable_name=callable_name,
-                        object_type=object_type,
-                    )
-                    self.type_context.pop()
+            with self.msg.filter_errors() as w, self.chk.local_type_map as m:
+                # Overload selection should not depend on the context.
+                # During this step pretend that we do not have any external information.
+                self.type_context.append(None)
+                ret_type, infer_type = self.check_call(
+                    callee=typ,
+                    args=args,
+                    arg_kinds=arg_kinds,
+                    arg_names=arg_names,
+                    context=context,
+                    callable_name=callable_name,
+                    object_type=object_type,
+                )
+                self.type_context.pop()
             is_match = not w.has_new_errors()
             if is_match:
-                # Return early if possible; otherwise record info, so we can
-                # check for ambiguity due to 'Any' below.
+                # Return early if possible
                 if not args_contain_any:
                     # Yes, just again
                     # FIXME: find a way to avoid doing this
@@ -2931,6 +2929,31 @@ def infer_overload_return_type(
                         callable_name=callable_name,
                         object_type=object_type,
                     )
+                candidates.append(typ)
+
+        # Repeat the same with outer context, but only for the select candidates.
+        matches: list[CallableType] = []
+        return_types: list[Type] = []
+        inferred_types: list[Type] = []
+        type_maps: list[dict[Expression, Type]] = []
+
+        for typ in candidates:
+            assert self.msg is self.chk.msg
+            with self.msg.filter_errors() as w, self.chk.local_type_map as m:
+                # Overload selection should not depend on the context.
+                # During this step pretend that we do not have any external information.
+                ret_type, infer_type = self.check_call(
+                    callee=typ,
+                    args=args,
+                    arg_kinds=arg_kinds,
+                    arg_names=arg_names,
+                    context=context,
+                    callable_name=callable_name,
+                    object_type=object_type,
+                )
+            is_match = not w.has_new_errors()
+            if is_match:
+                # Record info, so we can check for ambiguity due to 'Any' below.
                 p_infer_type = get_proper_type(infer_type)
                 if isinstance(p_infer_type, CallableType):
                     # Prefer inferred types if possible, this will avoid false triggers for

test-data/unit/check-overloading.test

@@ -6865,5 +6865,5 @@ def gather(*fns: object) -> int: ...
 
 def crash() -> None:
     foo: str
-    (foo,) = gather(0)  # E: Incompatible types in assignment (expression has type "int", variable has type "str")
+    (foo,) = gather(0)  # E: Argument 1 to "gather" has incompatible type "int"; expected "str"
 [builtins fixtures/tuple.pyi]