--disallow-any-generics should be included in --strict

[TV4Fun]

If I create an alias for a generic type using a TypeVar, Mypy seems to infer the TypeVar as Any and lose the typing information. For example, this works:

from typing import TypeVar, Callable

T = TypeVar('T')


def wrapper(func: Callable[[], T]) -> T:
    reveal_type(func)
    reveal_type(func())
    return func()

and gives these types:

mypy --strict generic_callable.py 
generic_callable.py:7: error: Revealed type is 'def () -> T`-1'
generic_callable.py:8: error: Revealed type is 'T`-1'

I would expect this

from typing import TypeVar, Callable

T = TypeVar('T')
C = Callable[[], T]


def wrapper(func: C) -> T:
    reveal_type(func)
    reveal_type(func())
    return func()

to behave in the same way, but it doesn't:

mypy --strict generic_callable.py 
generic_callable.py:8: error: Revealed type is 'def () -> Any'
generic_callable.py:9: error: Revealed type is 'Any'
generic_callable.py:10: warning: Returning Any from function declared to return "T"

This can be a problem if I am using the same complex generic type multiple times, as in this real-world example:

import functools
import warnings
from typing import Callable, TypeVar

_ReturnType = TypeVar('_ReturnType')
_CallableType = Callable[..., _ReturnType]


def deprecated(msg: str) -> Callable[[_CallableType], _CallableType]:
    def outer_wrapper(func: _CallableType) -> _CallableType:
        @functools.wraps(func)
        def inner_wrapper(*args: object, **kwargs: object) -> _ReturnType:
            warnings.simplefilter('always', DeprecationWarning)
            warnings.warn(f"{func.__name__} is deprecated: {msg}.",
                          category=DeprecationWarning,
                          stacklevel=2)
            warnings.simplefilter('default', DeprecationWarning)  # reset filter
            return func(*args, **kwargs)

        return inner_wrapper

    return outer_wrapper

which gives:

mypy --strict test_deprecated.py 
test_deprecated.py:18: warning: Returning Any from function declared to return "_ReturnType"

Having to explicitly type out Callable[..., _ReturnType] everywhere I use _CallableType would be a little cumbersome in this case.

[ilevkivskyi]

When you write C = Callable[[], T] you create a generic alias. You need to write C[T], bare C is equivalent to C[Any] as with any other generic, please read the docs https://mypy.readthedocs.io/en/latest/kinds_of_types.html#type-aliases

What actually surprises me is that --disallow-any-generics is not in --strict, I think we should add it there. Do you want to make a PR?

[ilevkivskyi]

Also unrelated suggestion, decorators like this are better typed using:

F = TypeVar('F', bound=Callable[..., Any])

def deco(msg: str) -> Callable[[F], F]: ...

which will give you more precise types, read https://mypy.readthedocs.io/en/latest/generics.html#declaring-decorators

[TV4Fun]

Thank you! Made a PR.

[TV4Fun]

Also, your suggestion doesn't actually work with --strict, as inner_wrapper still needs to specify a return type. I could specify inner_wrapper to return Any, but that also seems imprecise. The ideal solution would be if I could specify:

R = TypeVar('R')
F = TypeVar('F', bound=Callable[..., R])

def deco(msg: str) -> Callable[[F[R]], F[R]]:
    def outer_wrapper(func: F[R]) -> F[R]:
        @functools.wraps(func)
        def inner_wrapper(*args: object, **kwargs: object) -> R:
            return func(*args, **kwargs)
        return cast(F, inner_wrapper)
    return outer_wrapper

but I can't specify a generic type as a bound to a TypeVar.

[TV4Fun]

Alternatively, how hard would it be to give types type members? That way I could do something like this:

F = TypeVar('F', bound=Callable[..., Any])

def deco(msg: str) -> Callable[[F], F]:
    def outer_wrapper(func: F) -> F:
        @functools.wraps(func)
        def inner_wrapper(*args: object, **kwargs: object) -> F.ReturnType:
            return func(*args, **kwargs)
        return cast(F, inner_wrapper)
    return outer_wrapper