Specify type when type variables are remained in inherited classmethod.

When the method is classmethod, replacing type variables with its specified type in bases attribute by expand_type_by_instance.

Author: kitsuyui

mypy/checkmember.py

@@ -13,7 +13,10 @@
 )
 from mypy.messages import MessageBuilder
 from mypy.maptype import map_instance_to_supertype
-from mypy.expandtype import expand_type_by_instance, expand_type, freshen_function_type_vars
+from mypy.expandtype import (
+    expand_type_by_instance, expand_type, freshen_function_type_vars,
+    expand_type_by_instance_bases,
+)
 from mypy.infer import infer_type_arguments
 from mypy.typevars import fill_typevars
 from mypy.plugin import AttributeContext
@@ -559,6 +562,14 @@ def analyze_class_attribute_access(itype: Instance,
             msg.fail(messages.GENERIC_INSTANCE_VAR_CLASS_ACCESS, context)
         is_classmethod = ((is_decorated and cast(Decorator, node.node).func.is_class)
                           or (isinstance(node.node, FuncBase) and node.node.is_class))
+        if is_classmethod and isinstance(itype, Instance) and not isinstance(original_type, TypeType) and itype.args:
+            unbound_types = [arg for arg in itype.args if isinstance(arg, TypeVarType)]
+            if unbound_types:
+                message = messages.GENERIC_CLASSMETHOD_OF_GENERIC_CLASS.format(
+                    ', '.join(typevar.name for typevar in unbound_types))
+                msg.fail(message, context)
+
+        t = expand_type_by_instance_bases(t, itype)
         result = add_class_tvars(t, itype, is_classmethod, builtin_type, original_type)
         if not is_lvalue:
             result = analyze_descriptor_access(original_type, result, builtin_type,

mypy/expandtype.py

@@ -29,6 +29,14 @@ def expand_type_by_instance(typ: Type, instance: Instance) -> Type:
         return expand_type(typ, variables)
 
 
+def expand_type_by_instance_bases(typ: Type, instance: Instance) -> Type:
+    if instance.args:
+        return expand_type_by_instance(typ, instance)
+    for base in instance.type.bases:
+        typ = expand_type_by_instance_bases(typ, base)
+    return typ
+
+
 F = TypeVar('F', bound=FunctionLike)
 
 

mypy/messages.py

@@ -104,6 +104,8 @@
 DUPLICATE_TYPE_SIGNATURES = 'Function has duplicate type signatures'  # type: Final
 GENERIC_INSTANCE_VAR_CLASS_ACCESS = \
     'Access to generic instance variables via class is ambiguous'  # type: Final
+GENERIC_CLASSMETHOD_OF_GENERIC_CLASS = \
+    'Access to classmethod of generic type remains type variables {} is ambiguous.'  # type: Final
 CANNOT_ISINSTANCE_TYPEDDICT = 'Cannot use isinstance() with a TypedDict type'  # type: Final
 CANNOT_ISINSTANCE_NEWTYPE = 'Cannot use isinstance() with a NewType type'  # type: Final
 BARE_GENERIC = 'Missing type parameters for generic type'  # type: Final

test-data/unit/check-generics.test

@@ -1815,3 +1815,212 @@ def g(x: T) -> T: return x
 [out]
 main:3: error: Revealed type is 'def [b.T] (x: b.T`-1) -> b.T`-1'
 main:4: error: Revealed type is 'def [T] (x: T`-1) -> T`-1'
+
+[case testClassMethodOfGenericClass]
+from typing import TypeVar, Generic
+T = TypeVar('T')
+class A(Generic[T]):
+    @classmethod
+    def f(cls) -> T: ...
+class B(A[str]): pass
+class C(A[int]): pass
+reveal_type(B.f)  # E: Revealed type is 'def () -> builtins.str*'
+reveal_type(B.f())  # E: Revealed type is 'builtins.str*'
+reveal_type(C.f)  # E: Revealed type is 'def () -> builtins.int*'
+reveal_type(C.f())  # E: Revealed type is 'builtins.int*'
+[builtins fixtures/classmethod.pyi]
+
+[case testClassMethodOfGenericClassMultipleInheritance]
+from typing import TypeVar, Generic
+T = TypeVar('T')
+class A(Generic[T]):
+    @classmethod
+    def f(cls) -> T: pass
+class B(Generic[T]):
+    @classmethod
+    def g(cls) -> T: pass
+class C(A[str], B[int]):
+    @classmethod
+    def f(cls) -> str: pass
+    @classmethod
+    def g(cls) -> int: pass
+reveal_type(C.f())  # E: Revealed type is 'builtins.str'
+reveal_type(C.g())  # E: Revealed type is 'builtins.int'
+[builtins fixtures/classmethod.pyi]
+
+[case testClassMethodOfSubcClassOfSubClassOfGenericClass]
+from typing import TypeVar, Generic
+T = TypeVar('T')
+class A(Generic[T]):
+    @classmethod
+    def f(cls) -> T: ...
+class B(A[str]): pass
+class C(B): pass
+class D(C): pass
+reveal_type(B.f)  # E: Revealed type is 'def () -> builtins.str*'
+reveal_type(B.f())  # E: Revealed type is 'builtins.str*'
+reveal_type(C.f)  # E: Revealed type is 'def () -> builtins.str*'
+reveal_type(C.f())  # E: Revealed type is 'builtins.str*'
+reveal_type(D.f)  # E: Revealed type is 'def () -> builtins.str*'
+reveal_type(D.f())  # E: Revealed type is 'builtins.str*'
+[builtins fixtures/classmethod.pyi]
+
+[case testClassMethodOfGenericClassMultipleLevelInheritance]
+from typing import TypeVar, Generic
+T = TypeVar('T')
+class A(Generic[T]):
+    @classmethod
+    def f(cls) -> T: ...
+class B(A[str]): pass
+class C(B): pass
+class D(C): pass
+class E(D): pass
+reveal_type(C.f)  # E: Revealed type is 'def () -> builtins.str*'
+reveal_type(C.f())  # E: Revealed type is 'builtins.str*'
+reveal_type(D.f)  # E: Revealed type is 'def () -> builtins.str*'
+reveal_type(D.f())  # E: Revealed type is 'builtins.str*'
+reveal_type(E.f)  # E: Revealed type is 'def () -> builtins.str*'
+reveal_type(E.f())  # E: Revealed type is 'builtins.str*'
+[builtins fixtures/classmethod.pyi]
+
+[case testClassMethodOfGenericClassMultipleLevelInheritanceWithChangingTypeVariable]
+from typing import TypeVar, Generic
+T = TypeVar('T')
+S = TypeVar('S')
+class A(Generic[T]):
+    @classmethod
+    def f(cls) -> T: ...
+class B(A[S]): pass
+class C(B[str]): pass
+class D(B[int]): pass
+reveal_type(B[str].f())  # E: Revealed type is 'builtins.str'
+reveal_type(B[int].f())  # E: Revealed type is 'builtins.int'
+reveal_type(C.f())  # E: Revealed type is 'builtins.str*'
+reveal_type(D.f())  # E: Revealed type is 'builtins.int*'
+[builtins fixtures/classmethod.pyi]
+
+[case testClassMethodOfMultipleGenericClass]
+from typing import TypeVar, Generic
+T = TypeVar('T')
+class A(Generic[T]):
+    @classmethod
+    def f(cls) -> T: ...
+class B(Generic[T]):
+    @classmethod
+    def f(cls) -> T: ...
+class C(A[str], B[int]): pass
+class D(A[int], B[str]): pass
+reveal_type(C.f)  # E: Revealed type is 'def () -> builtins.str'
+reveal_type(C.f())  # E: Revealed type is 'builtins.str'
+reveal_type(D.f)  # E: Revealed type is 'def () -> builtins.int'
+reveal_type(D.f())  # E: Revealed type is 'builtins.int'
+[builtins fixtures/classmethod.pyi]
+
+[case testClassMethodOfGenericClassOverriding]
+from typing import Generic, TypeVar
+T = TypeVar('T')
+class A(Generic[T]):
+    @classmethod
+    def f(cls) -> T: pass
+class B(A[str]):
+    @classmethod
+    def f(cls) -> str: pass
+class C(A[str]):
+    @classmethod
+    def f(cls) -> int: pass  # E: Return type of "f" incompatible with supertype "A"
+[builtins fixtures/classmethod.pyi]
+
+[case testClassMethodOfInheritingGenericTypeFromGenericType]
+from typing import Generic, TypeVar
+T = TypeVar('T')
+S = TypeVar('S')
+class A(Generic[T]):
+    @classmethod
+    def f(cls) -> T: pass
+class B(A[S]): pass
+A.f  # E: Access to classmethod of generic type remains type variables T is ambiguous.
+B.f  # E: Access to classmethod of generic type remains type variables S is ambiguous.
+[builtins fixtures/classmethod.pyi]
+
+[case testClassMethodOfGenericClassComplexType]
+from typing import Generic, TypeVar, Iterable, Tuple
+T = TypeVar('T')
+class A(Generic[T]):
+    @classmethod
+    def f(cls) -> T: pass
+reveal_type(A[Iterable[str]].f())  # E: Revealed type is 'typing.Iterable[builtins.str]'
+[builtins fixtures/classmethod.pyi]
+
+[case testClassMethodOfGenericClassComplexReturnType]
+from typing import Generic, TypeVar, Iterable, Tuple
+T = TypeVar('T')
+class A(Generic[T]):
+    @classmethod
+    def f(cls) -> Iterable[Tuple[T, T]]: pass
+reveal_type(A[str].f())  # E: Revealed type is 'typing.Iterable[Tuple[builtins.str, builtins.str]]'
+[builtins fixtures/classmethod.pyi]
+
+[case testClassMethodOfGenericClassComplexArgumentType]
+from typing import Generic, TypeVar, Iterable, Tuple
+T = TypeVar('T')
+class A(Generic[T]):
+    @classmethod
+    def f(cls, arg: Iterable[Tuple[T, T]]) -> T: pass
+reveal_type(A[str].f((('x', 'y'),)))  # E: Revealed type is 'builtins.str'
+[builtins fixtures/classmethod.pyi]
+
+[case testClassMethodOfGenericClassMoreComplexTypeAndReturnTypeAndArgumentType]
+from typing import Generic, TypeVar, Iterable, Tuple
+T = TypeVar('T')
+class A(Generic[T]):
+    @classmethod
+    def f(cls, arg: Iterable[Tuple[T, T]]) -> Iterable[Tuple[T, T, T]]: pass
+arg = ((('x',), ('y',),),)
+reveal_type(A[Iterable[str]].f(arg))  # E: Revealed type is 'typing.Iterable[Tuple[typing.Iterable[builtins.str], typing.Iterable[builtins.str], typing.Iterable[builtins.str]]]'
+[builtins fixtures/classmethod.pyi]
+
+[case testClassMethodOfGenericClassMultipleTypeVariable]
+from typing import Generic, TypeVar, Tuple
+T = TypeVar('T')
+S = TypeVar('S')
+class A(Generic[T, S]):
+    @classmethod
+    def f(cls) -> Tuple[T, S]: pass
+reveal_type(A[str, int].f())  # E: Revealed type is 'Tuple[builtins.str, builtins.int]'
+reveal_type(A[int, str].f())  # E: Revealed type is 'Tuple[builtins.int, builtins.str]'
+[builtins fixtures/classmethod.pyi]
+
+[case testClassMethodOverloadingGenericClass]
+from typing import overload, TypeVar, Generic, Tuple
+T = TypeVar('T')
+class A(Generic[T]):
+    @overload
+    @classmethod
+    def f(cls, s: str) -> Tuple[str, T]: pass
+    @overload
+    @classmethod
+    def f(cls, s: int) -> Tuple[T, int]: pass
+    @classmethod
+    def f(cls, s): pass
+class B(A[str]): pass
+class C(A[int]): pass
+reveal_type(A[str].f(1))  # E: Revealed type is 'Tuple[builtins.str, builtins.int]'
+reveal_type(A[str].f('a'))  # E: Revealed type is 'Tuple[builtins.str, builtins.str]'
+reveal_type(A[int].f(1))  # E: Revealed type is 'Tuple[builtins.int, builtins.int]'
+reveal_type(A[int].f('a'))  # E: Revealed type is 'Tuple[builtins.str, builtins.int]'
+reveal_type(B.f(1))  # E: Revealed type is 'Tuple[builtins.str*, builtins.int]'
+reveal_type(B.f('a'))  # E: Revealed type is 'Tuple[builtins.str, builtins.str*]'
+reveal_type(C.f(1))  # E: Revealed type is 'Tuple[builtins.int*, builtins.int]'
+reveal_type(C.f('a'))  # E: Revealed type is 'Tuple[builtins.str, builtins.int*]'
+[builtins fixtures/classmethod.pyi]
+
+[case testClassmethodFromClassMethodOfGenericClass]
+from typing import Generic, TypeVar
+T = TypeVar('T')
+class X(Generic[T]):
+    @classmethod
+    def a(cls) -> T: pass
+    @classmethod
+    def b(cls) -> T:
+        return cls.a()
+[builtins fixtures/classmethod.pyi]