Type inferred from assertion somehow gets lost in lambda expression

[Wiezzel]

This works:

class A:
    pass

class B(A):
    foo: str

def bar(a: A):
    assert isinstance(a, B)
    return a.foo

This gives an error:

class A:
    pass

class B(A):
    foo: str

def bar(a: A):
    assert isinstance(a, B)
    return map(lambda _: a.foo, [])

Error message:

11: error: "A" has no attribute "foo"

Mypy version: 0.590
Python version: 3.6.3

I believe the second example should not raise any errors when checked by mypy.
The code obviously makes no sense. I prepared the examples in order to explain the issue.

[ilevkivskyi]

Type restrictions in mypy don't propagate to nested functions, see e.g. #2608, and lambda is a nested function. I think however this is not a duplicate since this use case is unrelated to None (also since lambdas are constrained to a single expression and a typically for immediate use, it feels safer to propagate the type restrictions).

[ikelos]

I have a similar test case, that uses None, but I believe it's actually the type restriction propagation through the lambda that's the issue here:

Mypy version: 0.620
Python version: 3.6.6

import typing

def method_good(children: typing.Optional[typing.List[int]], 
                sort_key: typing.Optional[typing.Callable] = None):
    if children is not None:
        if sort_key is not None:
            key_func = lambda x: sort_key(x)
            children = sorted(children, key = key_func)
    return children

def method_bad(children: typing.Optional[typing.List[int]], 
               sort_key: typing.Optional[typing.Callable] = None):
    if children is not None:
        if sort_key is not None:
            children = sorted(children, key = lambda x: sort_key(x))
    return children

Only method_bad raises an error. The workaround is easy, but confusing that it's necessary. If this belongs in #2608 or is a new issue, let me know and I can post this there instead...

[alcides]

This is something that is happening a lot with me, in which I am writing interpreters for tree-like structures and need lambdas to create laziness in its evaluation. Having to access fields outside lambdas triples the number of lines of the files, and becomes more unreadable.

[hauntsaninja]

This will usually be fixed by the same heuristics that were good enough for #2608