Give self a type when using check_untyped_defs

Author: msullivan

mypy/checker.py

@@ -535,6 +535,11 @@ def check_overlapping_overloads(self, defn: OverloadedFuncDef) -> None:
                 else:
                     impl = impl_type
 
+                # Prevent extra noise from inconsistent use of @classmethod by copying
+                # the first arg from the method being checked against.
+                if sig1.arg_types and defn.info:
+                    impl = impl.copy_modified(arg_types=[sig1.arg_types[0]] + impl.arg_types[1:])
+
                 # Is the overload alternative's arguments subtypes of the implementation's?
                 if not is_callable_compatible(impl, sig1,
                                               is_compat=is_subtype_no_promote,

mypy/semanal.py

@@ -616,11 +616,11 @@ def prepare_method_signature(self, func: FuncDef, info: TypeInfo) -> None:
         # Only non-static methods are special.
         functype = func.type
         if not func.is_static:
+            if func.name() == '__init_subclass__':
+                func.is_class = True
             if not func.arguments:
                 self.fail('Method must have at least one argument', func)
             elif isinstance(functype, CallableType):
-                if func.name() == '__init_subclass__':
-                    func.is_class = True
                 self_type = get_proper_type(functype.arg_types[0])
                 if isinstance(self_type, AnyType):
                     leading_type = fill_typevars(info)  # type: Type

mypy/typeops.py

@@ -10,7 +10,7 @@
 from mypy.types import (
     TupleType, Instance, FunctionLike, Type, CallableType, TypeVarDef, Overloaded,
     TypeVarType, TypeType, UninhabitedType, FormalArgument, UnionType, NoneType,
-    AnyType, TypeOfAny, ProperType, get_proper_type, get_proper_types, copy_type
+    AnyType, TypeOfAny, TypeType, ProperType, get_proper_type, get_proper_types, copy_type
 )
 from mypy.nodes import (
     FuncBase, FuncItem, OverloadedFuncDef, TypeInfo, TypeVar, ARG_STAR, ARG_STAR2,
@@ -397,8 +397,17 @@ def function_type(func: FuncBase, fallback: Instance) -> FunctionLike:
 
 def callable_type(fdef: FuncItem, fallback: Instance,
                   ret_type: Optional[Type] = None) -> CallableType:
+    # FIXME? somewhat unfortunate duplication with prepare_method_signature in semanal
+    if fdef.info and not fdef.is_static:
+        self_type = fill_typevars(fdef.info)  # type: Type
+        if fdef.is_class or fdef.name() == '__new__':
+            self_type = TypeType.make_normalized(self_type)
+        args = [self_type] + [AnyType(TypeOfAny.unannotated)] * (len(fdef.arg_names)-1)
+    else:
+        args = [AnyType(TypeOfAny.unannotated)] * len(fdef.arg_names)
+
     return CallableType(
-        [AnyType(TypeOfAny.unannotated)] * len(fdef.arg_names),
+        args,
         fdef.arg_kinds,
         [None if argument_elide_name(n) else n for n in fdef.arg_names],
         ret_type or AnyType(TypeOfAny.unannotated),

test-data/unit/check-classes.test

@@ -2610,7 +2610,7 @@ t = Test()
 t.crash = 'test'  # E: "Test" has no attribute "crash"
 
 class A:
-    def __setattr__(self): ...  # E: Invalid signature "def (self: Any) -> Any" for "__setattr__"
+    def __setattr__(self): ...  # E: Invalid signature "def (self: __main__.A) -> Any" for "__setattr__"
 a = A()
 a.test = 4  # E: "A" has no attribute "test"
 
@@ -6178,3 +6178,15 @@ class B(A):
     def meth(cls: Type[T]) -> List[T]: ...
 
 [builtins fixtures/isinstancelist.pyi]
+
+[case testCheckUntypedDefsSelf]
+# flags: --check-untyped-defs
+class Foo:
+    def foo(self):
+        self.bar()
+        self.baz()  # E: "Foo" has no attribute "baz"
+
+    @classmethod
+    def bar(cls):
+        cls.baz()  # E: "Type[Foo]" has no attribute "baz"
+[builtins fixtures/classmethod.pyi]

test-data/unit/typexport-basic.test

@@ -893,7 +893,7 @@ class A:
     def f(self): pass
 A.f
 [out]
-MemberExpr(5) : def (self: Any) -> Any
+MemberExpr(5) : def (self: A) -> Any
 
 [case testOverloadedUnboundMethod]
 ## MemberExpr
@@ -921,7 +921,7 @@ class A:
     def f(self, *args): pass
 A.f
 [out]
-MemberExpr(10) : Overload(def (self: Any) -> Any, def (self: Any, Any) -> Any)
+MemberExpr(10) : Overload(def (self: A) -> Any, def (self: A, Any) -> Any)
 
 [case testUnboundMethodWithInheritance]
 ## MemberExpr
@@ -986,7 +986,7 @@ class A(Generic[t]):
     def f(self, x): pass
 A.f(None, None)
 [out]
-MemberExpr(7) : def (self: Any, x: Any) -> Any
+MemberExpr(7) : def (self: A[t`1], x: Any) -> Any
 
 [case testGenericMethodOfGenericClass]
 ## MemberExpr