"Cannot determine type of ..." when using decorators

[orsinium]

Bug Report

To Reproduce

Content of tmp.py

from typing import Callable, TypeVar

C = TypeVar('C', bound=Callable)

def dec(val: None) -> Callable[[C], C]:
    def wrapper(f):
        return f
    return wrapper

# E: Cannot determine type of "foo"  [has-type]
lambda: foo() == 2

@dec(None)
def foo() -> int:
    return 2

foo() == 2  # this one is fine

Running mypy:

$ mypy --config-file='' tmp.py 
tmp.py:13: error: Cannot determine type of "foo"

Your Environment

• Mypy version used: 0.910
• Mypy command-line flags: --
• Mypy configuration options from mypy.ini (and other config files): --
• Python version used: Python 3.9.0
• Operating system and version: 5.4.0-81-generic #91-Ubuntu SMP Thu Jul 15 19:09:17 UTC 2021 x86_64 x86_64 x86_64 GNU/Linux

[orsinium]

Surprisingly, with a regular identity as a decorator it works fine:

from typing import Callable, TypeVar

C = TypeVar('C', bound=Callable)

def dec(f: C) -> C:
    return f

lambda: foo() == 2

@dec
def foo() -> int:
    return 2

Another surprising discovery: it also works fine when both the function and the lambda are enclosed:

from typing import Callable, TypeVar

C = TypeVar('C', bound=Callable)

def dec(val: None) -> Callable[[C], C]:
    def wrapper(f):
        return f
    return wrapper

def f() -> None:
    lambda: foo() == 2

    @dec(None)
    def foo() -> int:
        return 2

If you're wondering what can be a use case, I'm making a decorator for providing function usage examples for deal:

@deal.example(lambda: double1(2) == 4)
def double1(x: int) -> int:
    return x * 2

Here, lambda is passed as an argument into the decorator and it produces the same error as in the issue description.

[sobolevn]

@orsinium Hi 👋 😊 Glad to see you here (but, I am sorry that something does not work for you!)

I will try to solve this, I have some ideas about the possible cause, but no promises here: inference is always quite hard and any changes there can have massive influence on other features.

[orsinium]

I'm glad to see you there too :) When you mentioned inference, I made another surprising discovery: it also works well when I use a function instead of a lambda:

from typing import Callable, TypeVar

C = TypeVar('C', bound=Callable)

def dec(val: None) -> Callable[[C], C]:
    def wrapper(f):
        return f
    return wrapper

def f() -> None:
    foo() == 2

@dec(None)
def foo() -> int:
    return 2

What an interesting case! Something very specific to lambdas in a global namespace, hmm.