Warn for incorrect TypeVar usage (with Generics)

[Dreamsorcerer]

Feature

Sometimes a user less familiar with more advanced typing concepts will use a TypeVar in a way that doesn't add any typing information.

As an example: def foo() -> T:

I think, basically, anytime a TypeVar appears only 1 time in a function (or class) definition, this should be treated as an error.

Pitch

Code like this seems like an obvious sign the user has misunderstood TypeVar, and a warning should probably be emitted. They either want a normal type, or they missed an annotation somewhere.

[A5rocks]

I remember hitting cases like this more generally, but just for the record this currently fails:

import typing

T = typing.TypeVar("T")

def f() -> T:
    ...

with this output:

main.py:5: error: Missing return statement  [empty-body]
main.py:5: error: A function returning TypeVar should receive at least one argument containing the same TypeVar  [type-var]
Found 2 errors in 1 file (checked 1 source file)

... to try to demonstrate that "more general" case, this doesn't fail:

import typing

T = typing.TypeVar("T")

def f() -> list[T]:
    ...

[hauntsaninja]

Yup, this is a check we added in 0.981

For list[T], I believe it was intentional to not have the warning trigger for it, see #13061 (comment). I'm not sure I agree with that, but would be curious to know what @Dreamsorcerer 's real world code looks like.

[Dreamsorcerer]

Ah, OK. The case I just saw was a custom user object of -> Task[T]:
pyinvoke/invoke#956 (comment)

[Dreamsorcerer]

OK, so I think it's all Generic types that don't trigger the warning. I'm not sure I understand the comment from @JukkaL, as that use case appears to be exactly the same as doing Bucket[Any], so why use a TypeVar?

Minimal reproducer:

from typing import Generic, TypeVar

T = TypeVar("T")

class Foo(Generic[T]):
    ...

def foo() -> Foo[T]:
    ...

[clo-vis]

Comparison between mypy and pyright:

from typing import AnyStr, TypeVar

T = TypeVar("T")

def fun0() -> T: raise ValueError()
def fun1() -> AnyStr: raise ValueError()
def fun2() -> list[T]: raise ValueError()
def fun3() -> list[AnyStr]: raise ValueError()
def fun4() -> AnyStr | None: raise ValueError()

reveal_type(fun0())
reveal_type(fun1())
reveal_type(fun2())
reveal_type(fun3())
reveal_type(fun4())

Line	mypy	pyright
def fun0() -> T:	A function returning TypeVar should receive at least one argument containing the same TypeVar	TypeVar "T" appears only once in generic function signature. Use "object" instead
def fun1() -> AnyStr:	A function returning TypeVar should receive at least one argument containing the same TypeVar	-
def fun2() -> list[T]:	-	TypeVar "T" appears only once in generic function signature. Use "object" instead
def fun3() -> list[AnyStr]:	-	-
def fun4() -> AnyStr | None:	-	-
reveal_type(fun0())	Never	Unknown
reveal_type(fun1())	builtins.str	Unknown
reveal_type(fun2())	builtin.list[Never]	list[Unknown]
reveal_type(fun3())	builtin.list[str]	list[Unknown]
reveal_type(fun4())	Union[builtin.str | None]	None