diff --git a/test-data/unit/fixtures/typing-async.pyi b/test-data/unit/fixtures/typing-async.pyi
index 7ce2821d2916..66509a91b82b 100644
--- a/test-data/unit/fixtures/typing-async.pyi
+++ b/test-data/unit/fixtures/typing-async.pyi
@@ -123,13 +123,13 @@ class Mapping(Iterable[T], Generic[T, T_co], metaclass=ABCMeta):
     @overload
     def get(self, k: T, default: Union[T_co, V]) -> Union[T_co, V]: pass
 
-class ContextManager(Generic[T]):
-    def __enter__(self) -> T: pass
+class ContextManager(Generic[T_co]):
+    def __enter__(self) -> T_co: pass
     # Use Any because not all the precise types are in the fixtures.
     def __exit__(self, exc_type: Any, exc_value: Any, traceback: Any) -> Any: pass
 
-class AsyncContextManager(Generic[T]):
-    def __aenter__(self) -> Awaitable[T]: pass
+class AsyncContextManager(Generic[T_co]):
+    def __aenter__(self) -> Awaitable[T_co]: pass
     # Use Any because not all the precise types are in the fixtures.
     def __aexit__(self, exc_type: Any, exc_value: Any, traceback: Any) -> Awaitable[Any]: pass
 
diff --git a/test-data/unit/fixtures/typing-full.pyi b/test-data/unit/fixtures/typing-full.pyi
index 8e0116aab1c2..3757e868552e 100644
--- a/test-data/unit/fixtures/typing-full.pyi
+++ b/test-data/unit/fixtures/typing-full.pyi
@@ -44,7 +44,8 @@ Literal: _SpecialForm
 
 T = TypeVar('T')
 T_co = TypeVar('T_co', covariant=True)
-T_contra = TypeVar('T_contra', contravariant=True)
+R_co = TypeVar('R_co', covariant=True)
+S_contra = TypeVar('S_contra', contravariant=True)
 U = TypeVar('U')
 V = TypeVar('V')
 S = TypeVar('S')
@@ -82,9 +83,9 @@ class Iterator(Iterable[T_co], Protocol):
     @abstractmethod
     def __next__(self) -> T_co: pass
 
-class Generator(Iterator[T], Generic[T, U, V]):
+class Generator(Iterator[T_co], Generic[T_co, S_contra, R_co]):
     @abstractmethod
-    def send(self, value: U) -> T: pass
+    def send(self, value: S_contra) -> T_co: pass
 
     @abstractmethod
     def throw(self, typ: Any, val: Any=None, tb: Any=None) -> None: pass
@@ -93,35 +94,40 @@ class Generator(Iterator[T], Generic[T, U, V]):
     def close(self) -> None: pass
 
     @abstractmethod
-    def __iter__(self) -> 'Generator[T, U, V]': pass
+    def __iter__(self) -> 'Generator[T_co, S_contra, R_co]': pass
 
-class AsyncGenerator(AsyncIterator[T], Generic[T, U]):
+class AsyncGenerator(AsyncIterator[T_co], Generic[T_co, S_contra]):
     @abstractmethod
-    def __anext__(self) -> Awaitable[T]: pass
+    def __anext__(self) -> Awaitable[T_co]: pass
 
     @abstractmethod
-    def asend(self, value: U) -> Awaitable[T]: pass
+    def asend(self, value: S_contra) -> Awaitable[T_co]: pass
 
     @abstractmethod
-    def athrow(self, typ: Any, val: Any=None, tb: Any=None) -> Awaitable[T]: pass
+    def athrow(self, typ: Any, val: Any=None, tb: Any=None) -> Awaitable[T_co]: pass
 
     @abstractmethod
-    def aclose(self) -> Awaitable[T]: pass
+    def aclose(self) -> Awaitable[T_co]: pass
 
     @abstractmethod
-    def __aiter__(self) -> 'AsyncGenerator[T, U]': pass
+    def __aiter__(self) -> 'AsyncGenerator[T_co, S_contra]': pass
 
 @runtime_checkable
-class Awaitable(Protocol[T]):
+class Awaitable(Protocol[T_co]):
     @abstractmethod
-    def __await__(self) -> Generator[Any, Any, T]: pass
+    def __await__(self) -> Generator[Any, Any, T_co]: pass
 
-class AwaitableGenerator(Generator[T, U, V], Awaitable[V], Generic[T, U, V, S], metaclass=ABCMeta):
+class AwaitableGenerator(
+    Awaitable[R_co],
+    Generator[T_co, S_contra, R_co],
+    Generic[T_co, S_contra, R_co, S],
+    metaclass=ABCMeta
+):
     pass
 
-class Coroutine(Awaitable[V], Generic[T, U, V]):
+class Coroutine(Awaitable[R_co], Generic[T_co, S_contra, R_co]):
     @abstractmethod
-    def send(self, value: U) -> T: pass
+    def send(self, value: S_contra) -> T_co: pass
 
     @abstractmethod
     def throw(self, typ: Any, val: Any=None, tb: Any=None) -> None: pass
@@ -130,15 +136,15 @@ class Coroutine(Awaitable[V], Generic[T, U, V]):
     def close(self) -> None: pass
 
 @runtime_checkable
-class AsyncIterable(Protocol[T]):
+class AsyncIterable(Protocol[T_co]):
     @abstractmethod
-    def __aiter__(self) -> 'AsyncIterator[T]': pass
+    def __aiter__(self) -> 'AsyncIterator[T_co]': pass
 
 @runtime_checkable
-class AsyncIterator(AsyncIterable[T], Protocol):
-    def __aiter__(self) -> 'AsyncIterator[T]': return self
+class AsyncIterator(AsyncIterable[T_co], Protocol):
+    def __aiter__(self) -> 'AsyncIterator[T_co]': return self
     @abstractmethod
-    def __anext__(self) -> Awaitable[T]: pass
+    def __anext__(self) -> Awaitable[T_co]: pass
 
 class Sequence(Iterable[T_co], Container[T_co]):
     @abstractmethod
diff --git a/test-data/unit/fixtures/typing-medium.pyi b/test-data/unit/fixtures/typing-medium.pyi
index c722a9ddb12c..077d4eebf7d3 100644
--- a/test-data/unit/fixtures/typing-medium.pyi
+++ b/test-data/unit/fixtures/typing-medium.pyi
@@ -32,10 +32,8 @@ Self = 0
 
 T = TypeVar('T')
 T_co = TypeVar('T_co', covariant=True)
-T_contra = TypeVar('T_contra', contravariant=True)
-U = TypeVar('U')
-V = TypeVar('V')
-S = TypeVar('S')
+R_co = TypeVar('R_co', covariant=True)
+S_contra = TypeVar('S_contra', contravariant=True)
 
 # Note: definitions below are different from typeshed, variances are declared
 # to silence the protocol variance checks. Maybe it is better to use type: ignore?
@@ -49,8 +47,8 @@ class Iterable(Protocol[T_co]):
 class Iterator(Iterable[T_co], Protocol):
     def __next__(self) -> T_co: pass
 
-class Generator(Iterator[T], Generic[T, U, V]):
-    def __iter__(self) -> 'Generator[T, U, V]': pass
+class Generator(Iterator[T_co], Generic[T_co, S_contra, R_co]):
+    def __iter__(self) -> 'Generator[T_co, S_contra, R_co]': pass
 
 class Sequence(Iterable[T_co]):
     def __getitem__(self, n: Any) -> T_co: pass
@@ -65,8 +63,8 @@ class SupportsInt(Protocol):
 class SupportsFloat(Protocol):
     def __float__(self) -> float: pass
 
-class ContextManager(Generic[T]):
-    def __enter__(self) -> T: pass
+class ContextManager(Generic[T_co]):
+    def __enter__(self) -> T_co: pass
     # Use Any because not all the precise types are in the fixtures.
     def __exit__(self, exc_type: Any, exc_value: Any, traceback: Any) -> Any: pass
 
diff --git a/test-data/unit/fixtures/typing-namedtuple.pyi b/test-data/unit/fixtures/typing-namedtuple.pyi
index fbb4e43b62e6..5b0ef0845dad 100644
--- a/test-data/unit/fixtures/typing-namedtuple.pyi
+++ b/test-data/unit/fixtures/typing-namedtuple.pyi
@@ -18,8 +18,8 @@ class Iterable(Generic[T_co]): pass
 class Iterator(Iterable[T_co]): pass
 class Sequence(Iterable[T_co]): pass
 class Mapping(Iterable[KT], Generic[KT, T_co]):
-    def keys(self) -> Iterable[T]: pass  # Approximate return type
-    def __getitem__(self, key: T) -> T_co: pass
+    def keys(self) -> Iterable[KT]: pass  # Approximate return type
+    def __getitem__(self, key: KT) -> T_co: pass
 
 class NamedTuple(tuple[Any, ...]):
     _fields: ClassVar[tuple[str, ...]]
diff --git a/test-data/unit/fixtures/typing-override.pyi b/test-data/unit/fixtures/typing-override.pyi
index e9d2dfcf55c4..a0287524c84a 100644
--- a/test-data/unit/fixtures/typing-override.pyi
+++ b/test-data/unit/fixtures/typing-override.pyi
@@ -18,8 +18,8 @@ class Iterable(Generic[T_co]): pass
 class Iterator(Iterable[T_co]): pass
 class Sequence(Iterable[T_co]): pass
 class Mapping(Iterable[KT], Generic[KT, T_co]):
-    def keys(self) -> Iterable[T]: pass  # Approximate return type
-    def __getitem__(self, key: T) -> T_co: pass
+    def keys(self) -> Iterable[KT]: pass  # Approximate return type
+    def __getitem__(self, key: KT) -> T_co: pass
 
 def override(__arg: T) -> T: ...
 
diff --git a/test-data/unit/fixtures/typing-typeddict.pyi b/test-data/unit/fixtures/typing-typeddict.pyi
index f841a9aae6e7..16658c82528b 100644
--- a/test-data/unit/fixtures/typing-typeddict.pyi
+++ b/test-data/unit/fixtures/typing-typeddict.pyi
@@ -61,7 +61,7 @@ class Mapping(Iterable[T], Generic[T, T_co], metaclass=ABCMeta):
     def __len__(self) -> int: ...
     def __contains__(self, arg: object) -> int: pass
 
-class MutableMapping(Mapping[T, T_co], Generic[T, T_co], metaclass=ABCMeta):
+class MutableMapping(Mapping[T, V], Generic[T, V], metaclass=ABCMeta):
     # Other methods are not used in tests.
     def clear(self) -> None: ...
 
diff --git a/test-data/unit/lib-stub/typing.pyi b/test-data/unit/lib-stub/typing.pyi
index 86d542a918ee..00fce56920b7 100644
--- a/test-data/unit/lib-stub/typing.pyi
+++ b/test-data/unit/lib-stub/typing.pyi
@@ -35,8 +35,8 @@ TYPE_CHECKING = 0
 
 T = TypeVar('T')
 T_co = TypeVar('T_co', covariant=True)
-U = TypeVar('U')
-V = TypeVar('V')
+S_contra = TypeVar('S_contra', contravariant=True)
+R_co = TypeVar('R_co', covariant=True)
 
 class Iterable(Protocol[T_co]):
     def __iter__(self) -> Iterator[T_co]: pass
@@ -44,8 +44,8 @@ class Iterable(Protocol[T_co]):
 class Iterator(Iterable[T_co], Protocol):
     def __next__(self) -> T_co: pass
 
-class Generator(Iterator[T], Generic[T, U, V]):
-    def __iter__(self) -> Generator[T, U, V]: pass
+class Generator(Iterator[T_co], Generic[T_co, S_contra, R_co]):
+    def __iter__(self) -> Generator[T_co, S_contra, R_co]: pass
 
 class Sequence(Iterable[T_co]):
     def __getitem__(self, n: Any) -> T_co: pass
@@ -56,10 +56,10 @@ class Mapping(Iterable[T], Generic[T, T_co]):
     def keys(self) -> Iterable[T]: pass  # Approximate return type
     def __getitem__(self, key: T) -> T_co: pass
 
-class Awaitable(Protocol[T]):
-    def __await__(self) -> Generator[Any, Any, T]: pass
+class Awaitable(Protocol[T_co]):
+    def __await__(self) -> Generator[Any, Any, T_co]: pass
 
-class Coroutine(Awaitable[V], Generic[T, U, V]): pass
+class Coroutine(Awaitable[R_co], Generic[T_co, S_contra, R_co]): pass
 
 def final(meth: T) -> T: pass