Subscriptable TypeVar

[pbabics]

Are you reporting a bug, or opening a feature request?

Feature request if behaviour is not supported, otherwise bug

Example:

from typing import Generic, Any, TypeVar, List, Dict, cast, Callable

import dataclasses


MetaDataType = TypeVar('MetaDataType')

@dataclasses.dataclass
class Item(Generic[MetaDataType]):
	value: int
	metadata: MetaDataType


ItemType = TypeVar('ItemType', bound = Item)

# Generic[ItemType[MetaDataType]] fails at runtime, but mypy does not complain about it
class BasicStorage(Generic[ItemType[MetaDataType]]):

	def __init__(self) -> None:
		self._storage: List[ItemType] = []

	def item_factory(self, value: int, metadata: MetaDataType) -> ItemType:
		# This fails without cast altought `ItemType` has upper bound on `Item`
		return cast(ItemType, Item[MetaDataType](value, metadata))

	def get_last_item(self) -> ItemType:
		return self._storage[-1]

	def append(self, value: int, metadata: MetaDataType) -> ItemType:
		item = self.item_factory(value, metadata)
		self._storage.append(item)
		return item


class ExtendedItem(Item[Dict[str, Any]]):
	''' Some helper properties '''


class ExtendedStorage(BasicStorage[ExtendedItem]):

	# Causes error: Argument 2 of "item_factory" is incompatible with supertype "BasicStorage"; supertype defines the argument type as "MetaDataType"
	# Although ExtendedItem is basically `Item[Dict[str, Any]]`
	def item_factory( # type: ignore
		self,
		value: int,
		metadata: Dict[str, Any]
	) -> ExtendedItem:
		return ExtendedItem(value, metadata)

Actual behaviour

> basic_storage2 = BasicStorage[Item[Dict[str, Any]]]()
> basic_storage2.append(42, 14) # <~ This should cause error, "metadata" is `Dict[str, Any]`
> reveal_type(basic_storage2.get_last_item())
Revealed type is 'test.Item*[builtins.dict[builtins.str, Any]]'
> reveal_type(basic_storage2.get_last_item().metadata)
Revealed type is 'builtins.dict*[builtins.str, Any]'

> storage = ExtendedStorage()
> storage.append(42, 14) # <~ This should cause error, "metadata" is `Dict[str, Any]`
> reveal_type(storage.get_last_item())
Revealed type is 'test.ExtendedItem*'
> reveal_type(storage.get_last_item().metadata)
Revealed type is 'builtins.dict*[builtins.str, Any]'

Expected behaviour

Previous examples should cause errors and probably cast could be omitted in BasicStorage.item_factory, as result of this method is same as upper bound of ItemType

What are the versions of mypy and Python you are using?

Python 3.7.6
Mypy 0.761

Do you see the same issue after installing mypy from Git master?

Yes

What are the mypy flags you are using? (For example --strict-optional)

No additional flags

Similar issues

#3331

[msullivan]

This is higher kinded types, I think: python/typing#548. They are great but niche enough in this setting that they aren't on the road map currently.

We should probably reject writing class BasicStorage(Generic[ItemType[MetaDataType]]):

[hauntsaninja]

Closing as a duplicate of python/typing#548. Mypy isn't going to do anything non standard here