[suggest] Use the type of a method in a parent class as a guess

msullivan · msullivan · commit d2f6e93a8d70 · 2019-11-19T17:50:35.000-08:00
diff --git a/mypy/suggestions.py b/mypy/suggestions.py
@@ -404,6 +404,22 @@ def find_best(self, func: FuncDef, guesses: List[CallableType]) -> Tuple[Callabl
                    key=lambda s: (count_errors(errors[s]), self.score_callable(s)))
         return best, count_errors(errors[best])
 
+    def get_guesses_from_parent(self, node: FuncDef) -> List[CallableType]:
+        """Try to get a guess of a method type from a parent class."""
+        if not node.info:
+            return []
+
+        for parent in node.info.mro[1:]:
+            pnode = parent.names.get(node.name)
+            if pnode and isinstance(pnode.node, (FuncDef, Decorator)):
+                typ = pnode.node.type
+                if isinstance(typ, CallableType) and len(typ.arg_types) == len(node.arguments):
+                    # Return the first thing we find, since it probably doesn't make sense
+                    # to grab things further up in the chain if an earlier parent has it.
+                    return [pnode.node.type]
+
+        return []
+
     def get_suggestion(self, mod: str, node: FuncDef) -> PyAnnotateSignature:
         """Compute a suggestion for a function.
 
@@ -426,6 +442,7 @@ def get_suggestion(self, mod: str, node: FuncDef) -> PyAnnotateSignature:
                 callsites,
                 uses,
             )
+        guesses += self.get_guesses_from_parent(node)
         guesses = self.filter_options(guesses, is_method)
         best, _ = self.find_best(node, guesses)
 
diff --git a/test-data/unit/fine-grained-suggest.test b/test-data/unit/fine-grained-suggest.test
@@ -790,6 +790,42 @@ def baz():
 () -> str
 ==
 
+[case testSuggestParent]
+# suggest: foo.B.foo
+# suggest: foo.B.bar
+# suggest: foo.C.foo
+[file foo.py]
+from typing import TypeVar, Callable, Any
+F = TypeVar('F', bound=Callable[..., Any])
+def deco(f: F) -> F: ...
+
+class A:
+    def foo(self, x: int) -> float:
+        return 0.0
+
+    @deco
+    def bar(self, x: int) -> float:
+        return 0.0
+
+
+class B(A):
+    def foo(self, x):
+        return 0.0
+
+    @deco
+    def bar(self, x):
+        return 0.0
+
+class C(B):
+    def foo(self, x):
+        return 0.0
+
+[out]
+(int) -> float
+(int) -> float
+(int) -> float
+==
+
 [case testSuggestColonBadLocation]
 # suggest: tmp/foo.py:7:8:9
 [file foo.py]
