Allow more fine-grained filtering based on the any-ness of a type

msullivan · msullivan · commit 5b17584ed5f1 · 2019-08-28T14:00:18.000-07:00
diff --git a/mypy/dmypy/client.py b/mypy/dmypy/client.py
@@ -108,6 +108,8 @@ def __init__(self, prog: str) -> None:
                help="Only produce suggestions that cause no errors")
 p.add_argument('--no-any', action='store_true',
                help="Only produce suggestions that don't contain Any")
+p.add_argument('--flex-any', type=float,
+               help="Allow anys in types if they go above a certain score")
 p.add_argument('--try-text', action='store_true',
                help="Try using unicode wherever str is inferred")
 p.add_argument('--callsites', action='store_true',
@@ -365,7 +367,7 @@ def do_suggest(args: argparse.Namespace) -> None:
     """
     response = request(args.status_file, 'suggest', function=args.function,
                        json=args.json, callsites=args.callsites, no_errors=args.no_errors,
-                       no_any=args.no_any, try_text=args.try_text)
+                       no_any=args.no_any, flex_any=args.flex_any, try_text=args.try_text)
     check_output(response, verbose=False, junit_xml=None, perf_stats_file=None)
 
 
diff --git a/mypy/dmypy_server.py b/mypy/dmypy_server.py
@@ -515,7 +515,7 @@ def _find_changed(self, sources: List[BuildSource],
     def cmd_suggest(self,
                     function: str,
                     callsites: bool,
-                    **kwargs: bool) -> Dict[str, object]:
+                    **kwargs: Any) -> Dict[str, object]:
         """Suggest a signature for a function."""
         if not self.fine_grained_manager:
             return {'error': "Command 'suggest' is only valid after a 'check' command"}
diff --git a/mypy/suggestions.py b/mypy/suggestions.py
@@ -145,19 +145,23 @@ class SuggestionEngine:
     """Engine for finding call sites and suggesting signatures."""
 
     def __init__(self, fgmanager: FineGrainedBuildManager,
+                 *,
                  json: bool,
                  no_errors: bool = False,
                  no_any: bool = False,
-                 try_text: bool = False) -> None:
+                 try_text: bool = False,
+                 flex_any: Optional[float] = None) -> None:
         self.fgmanager = fgmanager
         self.manager = fgmanager.manager
         self.plugin = self.manager.plugin
         self.graph = fgmanager.graph
 
         self.give_json = json
         self.no_errors = no_errors
-        self.no_any = no_any
         self.try_text = try_text
+        self.flex_any = flex_any
+        if no_any:
+            self.flex_any = 1.0
 
         self.max_guesses = 16
 
@@ -285,13 +289,13 @@ def get_callsites(self, func: FuncDef) -> Tuple[List[Callsite], List[str]]:
 
         return collector_plugin.mystery_hits, errors
 
-    def filter_options(self, guesses: List[CallableType]) -> List[CallableType]:
+    def filter_options(self, guesses: List[CallableType], is_method: bool) -> List[CallableType]:
         """Apply any configured filters to the possible guesses.
 
-        Currently the only option is disabling Anys."""
+        Currently the only option is filtering based on Any prevalance."""
         return [
             t for t in guesses
-            if not self.no_any or not callable_has_any(t)
+            if self.flex_any is None or self.any_score_callable(t, is_method) >= self.flex_any
         ]
 
     def find_best(self, func: FuncDef, guesses: List[CallableType]) -> Tuple[CallableType, int]:
@@ -329,7 +333,7 @@ def get_suggestion(self, function: str) -> str:
                 self.get_trivial_type(node),
                 self.get_default_arg_types(graph[mod], node),
                 callsites)
-        guesses = self.filter_options(guesses)
+        guesses = self.filter_options(guesses, is_method)
         if len(guesses) > self.max_guesses:
             raise SuggestionFailure("Too many possibilities!")
         best, _ = self.find_best(node, guesses)
@@ -344,7 +348,7 @@ def get_suggestion(self, function: str) -> str:
                 ret_types = [NoneType()]
 
         guesses = [best.copy_modified(ret_type=t) for t in ret_types]
-        guesses = self.filter_options(guesses)
+        guesses = self.filter_options(guesses, is_method)
         best, errors = self.find_best(node, guesses)
 
         if self.no_errors and errors:
@@ -511,14 +515,16 @@ def format_callable(self,
     def format_type(self, cur_module: Optional[str], typ: Type) -> str:
         return typ.accept(TypeFormatter(cur_module, self.graph))
 
-    def score_type(self, t: Type) -> int:
+    def score_type(self, t: Type, arg_pos: bool) -> int:
         """Generate a score for a type that we use to pick which type to use.
 
         Lower is better, prefer non-union/non-any types. Don't penalize optionals.
         """
         t = get_proper_type(t)
         if isinstance(t, AnyType):
             return 20
+        if arg_pos and isinstance(t, NoneType):
+            return 20
         if isinstance(t, UnionType):
             if any(isinstance(x, AnyType) for x in t.items):
                 return 20
@@ -529,7 +535,41 @@ def score_type(self, t: Type) -> int:
         return 0
 
     def score_callable(self, t: CallableType) -> int:
-        return sum([self.score_type(x) for x in t.arg_types])
+        return (sum([self.score_type(x, arg_pos=True) for x in t.arg_types]) +
+                self.score_type(t.ret_type, arg_pos=False))
+
+    def any_score_type(self, ut: Type, arg_pos: bool) -> float:
+        """Generate a very made up number representing the Anyness of a type.
+
+        Higher is better, 1.0 is max
+        """
+        t = get_proper_type(ut)
+        if isinstance(t, AnyType) and t.type_of_any != TypeOfAny.special_form:
+            return 0
+        if isinstance(t, NoneType) and arg_pos:
+            return 0.5
+        if isinstance(t, UnionType):
+            if any(isinstance(x, AnyType) for x in t.items):
+                return 0.5
+            if any(has_any_type(x) for x in t.items):
+                return 0.25
+        if has_any_type(t):
+            return 0.5
+
+        return 1.0
+
+    def any_score_callable(self, t: CallableType, is_method: bool) -> float:
+        # Ignore the first argument of methods
+        scores = [self.any_score_type(x, arg_pos=True) for x in t.arg_types[int(is_method):]]
+        # Return type counts twice (since it spreads type information), unless it is
+        # None in which case it does not count at all. (Though it *does* still count
+        # if there are no arguments.)
+        if not isinstance(get_proper_type(t.ret_type), NoneType) or not scores:
+            ret = self.any_score_type(t.ret_type, arg_pos=False)
+            scores += [ret, ret]
+
+        # print(scores, t)
+        return sum(scores) / len(scores)
 
 
 class TypeFormatter(TypeStrVisitor):
@@ -611,13 +651,6 @@ def count_errors(msgs: List[str]) -> int:
     return len([x for x in msgs if ' error: ' in x])
 
 
-def callable_has_any(t: CallableType) -> int:
-    # We count a bare None in argument position as Any, since
-    # pyannotate turns it into Optional[Any]
-    return (any(isinstance(at, NoneType) for at in get_proper_types(t.arg_types))
-            or has_any_type(t))
-
-
 T = TypeVar('T')
 
 
diff --git a/mypy/test/testfinegrained.py b/mypy/test/testfinegrained.py
@@ -276,10 +276,12 @@ def maybe_suggest(self, step: int, server: Server, src: str) -> List[str]:
             no_any = '--no-any' in flags
             no_errors = '--no-errors' in flags
             try_text = '--try-text' in flags
+            m = re.match('--flex-any=([0-9.]+)', flags)
+            flex_any = float(m[1]) if m else None
             res = cast(Dict[str, Any],
                        server.cmd_suggest(
                            target.strip(), json=json, no_any=no_any, no_errors=no_errors,
-                           try_text=try_text,
+                           try_text=try_text, flex_any=flex_any,
                            callsites=callsites))
             val = res['error'] if 'error' in res else res['out'] + res['err']
             output.extend(val.strip().split('\n'))
@@ -288,7 +290,7 @@ def maybe_suggest(self, step: int, server: Server, src: str) -> List[str]:
     def get_suggest(self, program_text: str,
                     incremental_step: int) -> List[Tuple[str, str]]:
         step_bit = '1?' if incremental_step == 1 else str(incremental_step)
-        regex = '# suggest{}: (--[a-zA-Z0-9_\\-./?^ ]+ )*([a-zA-Z0-9_./?^ ]+)$'.format(step_bit)
+        regex = '# suggest{}: (--[a-zA-Z0-9_\\-./=?^ ]+ )*([a-zA-Z0-9_./?^ ]+)$'.format(step_bit)
         m = re.findall(regex, program_text, flags=re.MULTILINE)
         return m
 
diff --git a/test-data/unit/fine-grained-suggest.test b/test-data/unit/fine-grained-suggest.test
@@ -484,3 +484,65 @@ def bar() -> None:
 (int, Any) -> int
 (int, Any) -> int
 ==
+
+[case testSuggestFlexAny]
+# flags: --strict-optional
+# suggest: --flex-any=0.4 m.foo
+# suggest: --flex-any=0.7 m.foo
+# suggest: --flex-any=0.4 m.bar
+# suggest: --flex-any=0.6 m.bar
+# suggest: --flex-any=0.5 m.baz
+# suggest: --flex-any=0.5 m.F.foo
+# suggest: --flex-any=0.7 m.F.foo
+# suggest: --flex-any=0.7 m.noargs
+# suggest2: --flex-any=0.4 m.foo
+# suggest2: --flex-any=0.7 m.foo
+[file m.py]
+from typing import Any
+any: Any
+
+def foo(arg):
+    return 0
+def bar(x, y):
+    return any
+
+def baz(x):
+    pass
+
+class F:
+    def foo(self, x):
+        return 0
+
+def noargs():
+    pass
+
+[file n.py]
+from typing import Any
+any: Any
+
+from m import foo, bar
+def wtvr() -> None:
+    foo(any)
+    bar(1, 2)
+
+[file n.py.2]
+from typing import Any
+any: Any
+
+from m import foo, bar
+def wtvr() -> None:
+    foo([any])
+
+[builtins fixtures/isinstancelist.pyi]
+[out]
+(Any) -> int
+No guesses that match criteria!
+(int, int) -> Any
+No guesses that match criteria!
+No guesses that match criteria!
+(Any) -> int
+No guesses that match criteria!
+() -> None
+==
+(typing.List[Any]) -> int
+(typing.List[Any]) -> int
