Give classmethod first arg a reasonable type. Fixes #292

Give classmethod first arg a reasonable type. Fixes #292.

Author: gvanrossum

mypy/checkexpr.py

@@ -218,7 +218,7 @@ def check_call(self, callee: Type, args: List[Node],
         """
         arg_messages = arg_messages or self.msg
         if isinstance(callee, CallableType):
-            if callee.is_type_obj() and callee.type_object().is_abstract:
+            if callee.is_concrete_type_obj() and callee.type_object().is_abstract:
                 type = callee.type_object()
                 self.msg.cannot_instantiate_abstract_class(
                     callee.type_object().name(), type.abstract_attributes,

mypy/checkmember.py

@@ -187,7 +187,7 @@ def analyze_var(name: str, var: Var, itype: Instance, info: TypeInfo, node: Cont
                 # methods: the former to the instance, the latter to the
                 # class.
                 functype = cast(FunctionLike, t)
-                check_method_type(functype, itype, node, msg)
+                check_method_type(functype, itype, var.is_classmethod, node, msg)
                 signature = method_type(functype)
                 if var.is_property:
                     # A property cannot have an overloaded type => the cast
@@ -228,17 +228,29 @@ def lookup_member_var_or_accessor(info: TypeInfo, name: str,
         return None
 
 
-def check_method_type(functype: FunctionLike, itype: Instance,
+def check_method_type(functype: FunctionLike, itype: Instance, is_classmethod: bool,
                       context: Context, msg: MessageBuilder) -> None:
     for item in functype.items():
         if not item.arg_types or item.arg_kinds[0] not in (ARG_POS, ARG_STAR):
             # No positional first (self) argument (*args is okay).
             msg.invalid_method_type(item, context)
-        else:
+        elif not is_classmethod:
             # Check that self argument has type 'Any' or valid instance type.
             selfarg = item.arg_types[0]
             if not subtypes.is_equivalent(selfarg, itype):
                 msg.invalid_method_type(item, context)
+        else:
+            # Check that cls argument has type 'Any' or valid class type.
+            # (This is sufficient for the current treatment of @classmethod,
+            # but probably needs to be revisited when we implement Type[C]
+            # or advanced variants of it like Type[<args>, C].)
+            clsarg = item.arg_types[0]
+            if isinstance(clsarg, CallableType) and clsarg.is_type_obj():
+                if not subtypes.is_equivalent(clsarg.ret_type, itype):
+                    msg.invalid_class_method_type(item, context)
+            else:
+                if not subtypes.is_equivalent(clsarg, AnyType()):
+                    msg.invalid_class_method_type(item, context)
 
 
 def analyze_class_attribute_access(itype: Instance,
@@ -370,7 +382,9 @@ def class_callable(init_type: CallableType, info: TypeInfo, type_type: Instance)
     callable_type = init_type.copy_modified(
         ret_type=self_type(info), fallback=type_type, name=None, variables=variables)
     c = callable_type.with_name('"{}"'.format(info.name()))
-    return convert_class_tvars_to_func_tvars(c, len(initvars))
+    cc = convert_class_tvars_to_func_tvars(c, len(initvars))
+    cc.is_classmethod_class = True
+    return cc
 
 
 def convert_class_tvars_to_func_tvars(callable: CallableType,

mypy/messages.py

@@ -733,6 +733,9 @@ def cannot_determine_type_in_base(self, name: str, base: str, context: Context)
     def invalid_method_type(self, sig: CallableType, context: Context) -> None:
         self.fail('Invalid method type', context)
 
+    def invalid_class_method_type(self, sig: CallableType, context: Context) -> None:
+        self.fail('Invalid class method type', context)
+
     def incompatible_conditional_function_def(self, defn: FuncDef) -> None:
         self.fail('All conditional function variants must have identical '
                   'signatures', defn)

mypy/semanal.py

@@ -306,9 +306,10 @@ def prepare_method_signature(self, func: FuncDef) -> None:
                 self.fail('Method must have at least one argument', func)
             elif func.type:
                 sig = cast(FunctionLike, func.type)
-                # TODO: A classmethod's first argument should be more
-                #       precisely typed than Any.
-                leading_type = AnyType() if func.is_class else self_type(self.type)
+                if func.is_class:
+                    leading_type = self.class_type(self.type)
+                else:
+                    leading_type = self_type(self.type)
                 func.type = replace_implicit_first_type(sig, leading_type)
 
     def is_conditional_func(self, previous: Node, new: FuncDef) -> bool:
@@ -808,6 +809,16 @@ def analyze_metaclass(self, defn: ClassDef) -> None:
     def object_type(self) -> Instance:
         return self.named_type('__builtins__.object')
 
+    def class_type(self, info: TypeInfo) -> Type:
+        # Construct a function type whose fallback is cls.
+        from mypy import checkmember  # To avoid import cycle.
+        leading_type = checkmember.type_object_type(info, self.builtin_type)
+        if isinstance(leading_type, Overloaded):
+            # Overloaded __init__ is too complex to handle.  Plus it's stubs only.
+            return AnyType()
+        else:
+            return leading_type
+
     def named_type(self, qualified_name: str, args: List[Type] = None) -> Instance:
         sym = self.lookup_qualified(qualified_name, None)
         return Instance(cast(TypeInfo, sym.node), args or [])

mypy/test/data/check-classes.test

@@ -763,6 +763,54 @@ class A:
 A().f = A.f # E: Cannot assign to a method
 [builtins fixtures/classmethod.py]
 
+[case testClassMethodCalledInClassMethod]
+import typing
+class C:
+  @classmethod
+  def foo(cls) -> None: pass
+  @classmethod
+  def bar(cls) -> None:
+    cls()
+    cls(1)      # E: Too many arguments for "C"
+    cls.bar()
+    cls.bar(1)  # E: Too many arguments for "bar" of "C"
+    cls.bozo()  # E: "C" has no attribute "bozo"
+[builtins fixtures/classmethod.py]
+[out]
+main: note: In member "bar" of class "C":
+
+[case testClassMethodCalledOnClass]
+import typing
+class C:
+  @classmethod
+  def foo(cls) -> None: pass
+C.foo()
+C.foo(1)  # E: Too many arguments for "foo" of "C"
+C.bozo()  # E: "C" has no attribute "bozo"
+[builtins fixtures/classmethod.py]
+
+[case testClassMethodCalledOnInstance]
+import typing
+class C:
+  @classmethod
+  def foo(cls) -> None: pass
+C().foo()
+C().foo(1)  # E: Too many arguments for "foo" of "C"
+C.bozo()    # E: "C" has no attribute "bozo"
+[builtins fixtures/classmethod.py]
+
+[case testClassMethodMayCallAbstractMethod]
+from abc import abstractmethod
+import typing
+class C:
+  @classmethod
+  def foo(cls) -> None:
+      cls().bar()
+  @abstractmethod
+  def bar(self) -> None:
+      pass
+[builtins fixtures/classmethod.py]
+
 
 -- Properties
 -- ----------

mypy/test/data/semanal-classes.test

@@ -458,7 +458,7 @@ MypyFile:1(
         Args(
           Var(cls)
           Var(z))
-        def (cls: Any, z: builtins.int) -> builtins.str
+        def (cls: def () -> __main__.A, z: builtins.int) -> builtins.str
         Class
         Block:3(
           PassStmt:3())))))
@@ -478,7 +478,7 @@ MypyFile:1(
         f
         Args(
           Var(cls))
-        def (cls: Any) -> builtins.str
+        def (cls: def () -> __main__.A) -> builtins.str
         Class
         Block:3(
           PassStmt:3())))))

mypy/typeanal.py

@@ -179,7 +179,7 @@ def visit_type_var(self, t: TypeVarType) -> Type:
     def visit_callable_type(self, t: CallableType) -> Type:
         return t.copy_modified(arg_types=self.anal_array(t.arg_types),
                                ret_type=t.ret_type.accept(self),
-                               fallback=self.builtin_type('builtins.function'),
+                               fallback=t.fallback or self.builtin_type('builtins.function'),
                                variables=self.anal_var_defs(t.variables),
                                bound_vars=self.anal_bound_vars(t.bound_vars))
 

mypy/types.py

@@ -231,6 +231,9 @@ class FunctionLike(Type):
     @abstractmethod
     def is_type_obj(self) -> bool: pass
 
+    def is_concrete_type_obj(self) -> bool:
+        return self.is_type_obj()
+
     @abstractmethod
     def type_object(self) -> mypy.nodes.TypeInfo: pass
 
@@ -278,6 +281,8 @@ class CallableType(FunctionLike):
 
     # Is this Callable[..., t] (with literal '...')?
     is_ellipsis_args = False
+    # Is this callable constructed for the benefit of a classmethod's 'cls' argument?
+    is_classmethod_class = False
     # Was this type implicitly generated instead of explicitly specified by the user?
     implicit = False
 
@@ -292,7 +297,9 @@ def __init__(self, arg_types: List[Type],
                  bound_vars: List[Tuple[int, Type]] = None,
                  line: int = -1,
                  is_ellipsis_args: bool = False,
-                 implicit=False) -> None:
+                 implicit=False,
+                 is_classmethod_class=False,
+                 ) -> None:
         if variables is None:
             variables = []
         if not bound_vars:
@@ -338,11 +345,16 @@ def copy_modified(self,
             line=line if line is not _dummy else self.line,
             is_ellipsis_args=(
                 is_ellipsis_args if is_ellipsis_args is not _dummy else self.is_ellipsis_args),
+            implicit=self.implicit,
+            is_classmethod_class=self.is_classmethod_class,
         )
 
     def is_type_obj(self) -> bool:
         return self.fallback.type.fullname() == 'builtins.type'
 
+    def is_concrete_type_obj(self) -> bool:
+        return self.is_type_obj() and self.is_classmethod_class
+
     def type_object(self) -> mypy.nodes.TypeInfo:
         assert self.is_type_obj()
         ret = self.ret_type