(🐞) Locally narrowed value used in a lambda parameter from an overloaded higher order function is analyzed twice with different types

from typing import overload, Callable

@overload
def f() -> None: ...
@overload
def f(fn: Callable[[], object]) -> None: ...

def f(fn: object=1) -> None: ...

x: object
assert isinstance(x, str)
y = x
f(lambda: reveal_type(x))  # Revealed type is "str", Revealed type is "object"
f(lambda: reveal_type(y))  # Revealed type is "str"

The lambda is analyzed twice, once with the local type of the variable, and once with the global type of the variable, duplicating all notes and error messages.

The second usage with y is only analyzed once because it does not have a narrowed type.

• Related #11953

playground

Credit to @septatrix for unearthing this.

Start by running the provided overload and lambda reproduction, either locally or in the linked playground, and compare the diagnostics for x and y. Trace how the overloaded higher-order call analyzes the lambda and verify that the narrowed x case produces one set of revealed types and messages, while the y case remains unchanged.