weird typeguard behavior in inspect.getmembers when disallow-any-expr is enabled

[DetachHead]

import inspect

class Foo:
    pass


def foo(value: bool) -> None:
    for _, method in inspect.getmembers(
        Foo, predicate=lambda method: method in vars(Foo) # type:ignore[misc,arg-type]
    ):
        reveal_type(method)  # bool???

playground

if i disable disallow-any-expr, the arg-type error goes away and the type of method changes from bool to Any

i don't think disallow-any-expr should change how types are inferred, or cause any new errors other than Expression type contains "Any"

[ikonst]

Oh wow, this is quite tricky.

The first realization to understand is that lambda a: a is basically incompatible with --disallow-any-expr since a is an Any and there's no way to annotate it.

For example, mypy --disallow-any-expr will error on:

lst: list[int] = [1, 2, 3]
lst.sort(key=lambda a: a)

I think it's basically issue #5879.

Now, inspect.getmembers is an overloaded function, and the mechanism to determine which overload to use is by trying to check the call and seeing if there are no "new errors" (see code). Apparently "new errors" include not just the inspect.getmembers call expr, but also the nested lambda expr. If you change the lambda to a function, this no longer happens (mypy-play).

The weird bool is due to the first signature being arbitrarily picked in this fallback code. Basically it's the lambda's retval (bool) becomes the expression's.

There's many things to tackle here but maybe start with

1. Fix how unrelated expr's errors end up rolling into the error watcher
2. Maybe this kind of error try-catch should happen with some kind of "standard environment" rather than be dependent on options like --disallow-any-expr?

[KotlinIsland]

I think #12729 would fix this

[KotlinIsland]

Minified - (🐞) Incorrect overload matching with lambda expression and disallow-any-expr

# mypy: disallow_any_expr
from typing import overload, Any, Callable

@overload
def f(fn: Callable[[object], bool]) -> str: ...
@overload
def f(fn: Callable[[Any], None]) -> int: ...
def f(fn: object = 1) -> object: ...

x = f(lambda _: None)
reveal_type(x)  # `str`, with `allow_any_expr` we get `int`

[KotlinIsland]

• I've raised (🐞) Overload matching fails when sub expression contains an unrelated error #16186 as a super issue of this issue

[DetachHead]

closing in favor of #16186