Reject bound covariant type variable in an argument type

[JukkaL]

We should reject a bound covariant type variable in an argument type (i.e., in a contravariant position). For example, this should be rejected:

T = TypeVar('T', covariant=True)
class A(Generic[T]):
    def foo(self, x: T) -> None: ...  # Can't use as argument type! Return type is okay.

Similarly, a contravariant type variable should not be used in a return type.

The actual rule is probably a bit more involved than what I gave above, but this would probably cover most cases.

[jhance]

Likely we don't want to be able to take Sequence[T] as an argument either. My initial PR doesn't address this, and I'm currently working on other covariance/contravariance which needs the same type of recursion, so I think it makes sense to address that (more complicated) issue later.

I'm actually not sure whether we would reject List[T] as an argument or not.

[JukkaL]

I think that List[T] as an argument should be rejected. Consider this example:

CV = TypeVar('CV', covariant=True)
IV = TypeVar('IV')

class A(Generic[CV]):
    def get(self) -> CV: ...
    def f(self, a: List[CV]) -> None: ...

class B(A[IV], Generic[IV]):
    def __init__(self, x: IV) -> None:
        self.x = x

    def get(self) -> IV:
        return self.x

    def f(self, a: List[IV]) -> None:
        self.x = a[0]

b = B(1)
a = b # type: A[object]
a.f([object()])
b.get() # ouch, object(), but should be int

[JukkaL]

Reopening because the List[T] case is still open.