Add code structure for gradual migration to argument-by-argument call matching.

This adds some code that will let our current function call matching algorithm
and a new, faster one exist side-by-side until the new one can handle all the
cases that the current one does. It also enables the new matching for trivial
cases (when we're matching against an InterpreterFunction with no TypeVars in
the function signature, the containing class (for a method), or the function
arguments). This is already enough to show a pretty impressive speedup in our
function call benchmark but not in the real-world use case I tested. If
anything, it's a tad slower because of the _is_generic_call check, but that'll
go away eventually.

PiperOrigin-RevId: 446044514

Author: rchen152

pytype/abstract/_function_base.py

@@ -70,6 +70,48 @@ def match_args(self, node, args, alias_map=None, match_all_views=False):
         name = self._get_cell_variable_name(a)
         assert name is not None, "Closure variable lookup failed."
         raise function.UndefinedParameterError(name)
+    # The implementation of match_args is currently rather convoluted because we
+    # have two different implementations:
+    # * Old implementation: `_match_views` matches 'args' against 'self' one
+    #   view at a time, where a view is a mapping of every variable in args to a
+    #   particular binding. This handles generics but scales poorly with the
+    #   number of bindings per variable.
+    # * New implementation: `_match_args_sequentially` matches 'args' one at a
+    #   time. This scales better but cannot yet handle generics.
+    # Subclasses should implement the following:
+    # * _match_view(node, args, view, alias_map): this will be called repeatedly
+    #   by _match_views.
+    # * _match_args_sequentially(node, args, alias_map, match_all_views): A
+    #   sequential matching implementation.
+    # TODO(b/228241343): Get rid of _match_views and simplify match_args once
+    # _match_args_sequentially can handle generics.
+    if self._is_generic_call(args):
+      return self._match_views(node, args, alias_map, match_all_views)
+    return self._match_args_sequentially(node, args, alias_map, match_all_views)
+
+  def _is_generic_call(self, args):
+    for sig in function.get_signatures(self):
+      for t in sig.annotations.values():
+        stack = [t]
+        seen = set()
+        while stack:
+          cur = stack.pop()
+          if cur in seen:
+            continue
+          seen.add(cur)
+          if cur.formal or cur.template:
+            return True
+          if _isinstance(cur, "Union"):
+            stack.extend(cur.options)
+    if self.is_attribute_of_class and args.posargs:
+      for self_val in args.posargs[0].data:
+        for cls in self_val.cls.mro:
+          if cls.template:
+            return True
+    return False
+
+  def _match_views(self, node, args, alias_map, match_all_views):
+    """Matches all views of the given args against this function."""
     error = None
     matched = []
     arg_variables = args.get_variables()
@@ -107,6 +149,9 @@ def match_args(self, node, args, alias_map=None, match_all_views=False):
   def _match_view(self, node, args, view, alias_map):
     raise NotImplementedError(self.__class__.__name__)
 
+  def _match_args_sequentially(self, node, args, alias_map, match_all_views):
+    raise NotImplementedError(self.__class__.__name__)
+
   def __repr__(self):
     return self.full_name + "(...)"
 

pytype/abstract/_interpreter_function.py

@@ -234,6 +234,30 @@ def _match_view(self, node, args, view, alias_map=None):
           self.signature, args, self.ctx, bad_param=bad_arg)
     return subst
 
+  def _match_args_sequentially(self, node, args, alias_map, match_all_views):
+    def match_succeeded(match_result):
+      bad_matches, any_match = match_result
+      if not bad_matches:
+        return True
+      if match_all_views or self.ctx.options.strict_parameter_checks:
+        return False
+      return any_match
+
+    for name, arg, formal in self.signature.iter_args(args):
+      if formal is None:
+        continue
+      if name in (self.signature.varargs_name, self.signature.kwargs_name):
+        # The annotation is Tuple or Dict, but the passed arg only has to be
+        # Iterable or Mapping.
+        formal = self.ctx.convert.widen_type(formal)
+      match_result = self.ctx.matcher(node).bad_matches(arg, formal)
+      if not match_succeeded(match_result):
+        bad_arg = function.BadParam(
+            name=name, expected=formal, error_details=match_result[0][0][1])
+        raise function.WrongArgTypes(
+            self.signature, args, self.ctx, bad_param=bad_arg)
+    return [{}]
+
   def get_first_opcode(self):
     return None
 

pytype/abstract/_pytd_function.py

@@ -396,6 +396,9 @@ def _yield_matching_signatures(self, node, args, view, alias_map):
     if not matched:
       raise error  # pylint: disable=raising-bad-type
 
+  def _match_args_sequentially(self, node, args, alias_map, match_all_views):
+    return self._match_views(node, args, alias_map, match_all_views)
+
   def set_function_defaults(self, unused_node, defaults_var):
     """Attempts to set default arguments for a function's signatures.
 

pytype/abstract/_typing.py

@@ -280,7 +280,7 @@ def _build_value(self, node, inner, ellipses):
                 root_node, container=abstract_utils.DUMMY_CONTAINER)
         else:
           actual = param_value.instantiate(root_node)
-        bad = self.ctx.matcher(root_node).bad_matches(actual, formal_param)
+        bad, _ = self.ctx.matcher(root_node).bad_matches(actual, formal_param)
         if bad:
           if not isinstance(param_value, TypeParameter):
             # If param_value is not a TypeVar, we substitute in TypeVar bounds

pytype/abstract/function.py

@@ -30,7 +30,7 @@ def get_signatures(func):
     return [sig.drop_first_parameter() for sig in sigs]  # drop "self"
   elif _isinstance(func, ("ClassMethod", "StaticMethod")):
     return get_signatures(func.method)
-  elif _isinstance(func, "SimpleFunction"):
+  elif _isinstance(func, "SignedFunction"):
     return [func.signature]
   elif _isinstance(func.cls, "CallableClass"):
     return [Signature.from_callable(func.cls)]

pytype/context.py

@@ -164,7 +164,7 @@ def check_annotation_type_mismatch(
         typ, ("typing.ClassVar", "dataclasses.InitVar"))
     if contained_type:
       typ = contained_type
-    bad = self.matcher(node).bad_matches(value, typ)
+    bad, _ = self.matcher(node).bad_matches(value, typ)
     for view, error_details in bad:
       binding = view[value]
       self.errorlog.annotation_type_mismatch(

pytype/matcher.py

@@ -175,16 +175,21 @@ def bad_matches(self, var, other_type):
       var: A cfg.Variable, containing instances.
       other_type: An instance of BaseValue.
     Returns:
-      A list of all the views of var that didn't match.
+      A pair of:
+      * A list of all the views of var that didn't match.
+      * Whether at least one view matched.
+      TODO(b/63407497): We should be able to get rid of the second value once we
+      start requiring that all views match.
     """
     bad = []
     if (var.data == [self.ctx.convert.unsolvable] or
         other_type == self.ctx.convert.unsolvable):
       # An unsolvable matches everything. Since bad_matches doesn't need to
       # compute substitutions, we can return immediately.
-      return bad
+      return bad, True
     views = abstract_utils.get_views([var], self._node)
     skip_future = None
+    any_match = False
     while True:
       try:
         view = views.send(skip_future)
@@ -200,7 +205,8 @@ def bad_matches(self, var, other_type):
         skip_future = False
       else:
         skip_future = True
-    return bad
+        any_match = True
+    return bad, any_match
 
   def match_from_mro(self, left, other_type, allow_compat_builtins=True):
     """Checks a type's MRO for a match for a formal type.
@@ -989,7 +995,7 @@ def _match_dict_against_typed_dict(self, left, other_type):
       if k not in fields:
         continue
       typ = abstract_utils.get_atomic_value(fields[k])
-      b = self.bad_matches(v, typ)
+      b, _ = self.bad_matches(v, typ)
       if b:
         bad.append((k, v, typ, b))
     if missing or extra or bad:

pytype/matcher_test.py

@@ -508,14 +508,14 @@ def test_bad_matches(self):
         self.matcher.bad_matches(
             abstract.TypeParameter("T",
                                    self.ctx).to_variable(self.ctx.root_node),
-            self.ctx.convert.unsolvable))
+            self.ctx.convert.unsolvable)[0])
 
   def test_bad_matches_no_match(self):
     self.assertTrue(
         self.matcher.bad_matches(
             abstract.TypeParameter("T",
                                    self.ctx).to_variable(self.ctx.root_node),
-            self.ctx.convert.int_type))
+            self.ctx.convert.int_type)[0])
 
   def test_any(self):
     self.assertMatch(

pytype/overlays/typed_dict.py

@@ -228,7 +228,7 @@ def _check_str_key_value(self, node, name, value_var):
     if not self._check_str_key(name):
       return
     typ = abstract_utils.get_atomic_value(self.fields[name])
-    bad = self.ctx.matcher(node).bad_matches(value_var, typ)
+    bad, _ = self.ctx.matcher(node).bad_matches(value_var, typ)
     for view, error_details in bad:
       binding = view[value_var]
       self.ctx.errorlog.annotation_type_mismatch(

pytype/overriding_checks.py

@@ -417,7 +417,7 @@ def _check_signature_compatible(method_signature, base_signature,
   def is_subtype(this_type, that_type):
     """Return True iff this_type is a subclass of that_type."""
     this_type_instance = this_type.instantiate(ctx.root_node, None)
-    return not matcher.bad_matches(this_type_instance, that_type)
+    return not matcher.bad_matches(this_type_instance, that_type)[0]
 
   check_result = (
       _check_positional_parameters(method_signature, base_signature, is_subtype)