diff --git a/mypy/constraints.py b/mypy/constraints.py index aa095316c234..9f4ce48fba8c 100644 --- a/mypy/constraints.py +++ b/mypy/constraints.py @@ -820,6 +820,12 @@ def visit_instance(self, template: Instance) -> list[Constraint]: # Infer constraints for Type[T] via metaclass of T when it makes sense. if isinstance(a_item, TypeVarType): a_item = get_proper_type(a_item.upper_bound) + if isinstance(a_item, Instance): + res.extend( + self.infer_constraints_from_protocol_members( + a_item, template, actual, template, class_obj=True + ) + ) if isinstance(a_item, Instance) and a_item.type.metaclass_type: res.extend( self.infer_constraints_from_protocol_members( diff --git a/test-data/unit/check-protocols.test b/test-data/unit/check-protocols.test index 4c0fdd55b122..875472f587bb 100644 --- a/test-data/unit/check-protocols.test +++ b/test-data/unit/check-protocols.test @@ -4865,3 +4865,28 @@ from typing import Callable, TypeVar S = TypeVar("S") class C: def __init_subclass__(cls: type[S], item: Callable[[S], None]) -> None: ... + +[case testProtocolInferenceFromBoundTypeVarClassObject] +from typing import ClassVar, Protocol, TypeVar + +class Layout: ... +L_co = TypeVar("L_co", bound=Layout, covariant=True) + +class HasLayout(Protocol[L_co]): + @property + def layout(self) -> L_co: ... + +class Table: + layout: ClassVar[Layout] + +T_co = TypeVar("T_co", bound=Table, covariant=True) + +def get_layout(cls: HasLayout[L_co]) -> L_co: + return cls.layout + +def concrete(cls: type[Table]) -> None: + reveal_type(get_layout(cls)) # N: Revealed type is "__main__.Layout" + +def generic(cls: type[T_co]) -> None: + reveal_type(get_layout(cls)) # N: Revealed type is "__main__.Layout" +[builtins fixtures/property.pyi]