[suggest] Rework max guesses and eliminate max args (python#7972)

msullivan · web-flow · commit 70b2b19f54f3 · 2019-11-18T14:56:16.000-08:00
Rework max guesses to be configurable and to throw out guesses past
the limit instead of just hard failing. This might allow succeeding in
more situations. Eliminate the maximum argument restriction since we
no longer compute all of the options before looking at the number of
possibilities.
diff --git a/mypy/dmypy/client.py b/mypy/dmypy/client.py
@@ -116,6 +116,8 @@ def __init__(self, prog: str) -> None:
                help="Find callsites instead of suggesting a type")
 p.add_argument('--use-fixme', metavar='NAME', type=str,
                help="A dummy name to use instead of Any for types that can't be inferred")
+p.add_argument('--max-guesses', type=int,
+               help="Set the maximum number of types to try for a function (default 64)")
 
 hang_parser = p = subparsers.add_parser('hang', help="Hang for 100 seconds")
 
@@ -370,7 +372,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, flex_any=args.flex_any, try_text=args.try_text,
-                       use_fixme=args.use_fixme)
+                       use_fixme=args.use_fixme, max_guesses=args.max_guesses)
     check_output(response, verbose=False, junit_xml=None, perf_stats_file=None)
 
 
diff --git a/mypy/suggestions.py b/mypy/suggestions.py
@@ -213,7 +213,9 @@ def __init__(self, fgmanager: FineGrainedBuildManager,
                  no_any: bool = False,
                  try_text: bool = False,
                  flex_any: Optional[float] = None,
-                 use_fixme: Optional[str] = None) -> None:
+                 use_fixme: Optional[str] = None,
+                 max_guesses: Optional[int] = None
+                 ) -> None:
         self.fgmanager = fgmanager
         self.manager = fgmanager.manager
         self.plugin = self.manager.plugin
@@ -227,7 +229,7 @@ def __init__(self, fgmanager: FineGrainedBuildManager,
         if no_any:
             self.flex_any = 1.0
 
-        self.max_guesses = 64
+        self.max_guesses = max_guesses or 64
         self.use_fixme = use_fixme
 
     def suggest(self, function: str) -> str:
@@ -362,8 +364,10 @@ def get_guesses(self, is_method: bool, base: CallableType, defaults: List[Option
         """
         options = self.get_args(is_method, base, defaults, callsites, uses)
         options = [self.add_adjustments(tps) for tps in options]
-        return [refine_callable(base, base.copy_modified(arg_types=list(x)))
-                for x in itertools.product(*options)]
+
+        # Take the first `max_guesses` guesses.
+        product = itertools.islice(itertools.product(*options), 0, self.max_guesses)
+        return [refine_callable(base, base.copy_modified(arg_types=list(x))) for x in product]
 
     def get_callsites(self, func: FuncDef) -> Tuple[List[Callsite], List[str]]:
         """Find all call sites of a function."""
@@ -414,9 +418,6 @@ def get_suggestion(self, mod: str, node: FuncDef) -> PyAnnotateSignature:
 
         is_method = bool(node.info) and not node.is_static
 
-        if len(node.arg_names) >= 10:
-            raise SuggestionFailure("Too many arguments")
-
         with strict_optional_set(graph[mod].options.strict_optional):
             guesses = self.get_guesses(
                 is_method,
@@ -426,8 +427,6 @@ def get_suggestion(self, mod: str, node: FuncDef) -> PyAnnotateSignature:
                 uses,
             )
         guesses = self.filter_options(guesses, is_method)
-        if len(guesses) > self.max_guesses:
-            raise SuggestionFailure("Too many possibilities!")
         best, _ = self.find_best(node, guesses)
 
         # Now try to find the return type!
diff --git a/mypy/test/testfinegrained.py b/mypy/test/testfinegrained.py
@@ -283,11 +283,13 @@ def maybe_suggest(self, step: int, server: Server, src: str, tmp_dir: str) -> Li
             flex_any = float(m.group(1)) if m else None
             m = re.match(r'--use-fixme=(\w+)', flags)
             use_fixme = m.group(1) if m else None
+            m = re.match('--max-guesses=([0-9]+)', flags)
+            max_guesses = int(m.group(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, flex_any=flex_any, use_fixme=use_fixme,
-                           callsites=callsites))
+                           callsites=callsites, max_guesses=max_guesses))
             val = res['error'] if 'error' in res else res['out'] + res['err']
             if json:
                 # JSON contains already escaped \ on Windows, so requires a bit of care.
diff --git a/test-data/unit/fine-grained-suggest.test b/test-data/unit/fine-grained-suggest.test
@@ -44,6 +44,23 @@ bar.py:4: (arg=str)
 bar.py:6: (*typing.List[str])
 bar.py:8: (**typing.Dict[str, str])
 
+[case testMaxGuesses]
+# suggest: foo.foo
+# suggest: --max-guesses=2 foo.foo
+[file foo.py]
+# The idea here is that we can only find the union type with more guesses.
+def foo(x, y):
+    if not isinstance(x, int):
+        x+'1'
+
+foo(1, 2)
+foo('3', '4')
+[builtins fixtures/isinstancelist.pyi]
+[out]
+(Union[int, str], object) -> None
+(object, object) -> None
+==
+
 [case testSuggestInferFunc1]
 # flags: --strict-optional
 # suggest: foo.foo
