Merge pull request #1569 from google/google_sync

rchen152 · web-flow · commit 07ed7afc7dd7 · 2024-01-23T14:53:19.000-08:00
Google sync
diff --git a/pytype/abstract/_function_base.py b/pytype/abstract/_function_base.py
@@ -525,17 +525,16 @@ def _map_args(self, node, args):
       raise function.WrongKeywordArgs(sig, args, self.ctx, posonly_kws)
     callargs.update(positional)
     callargs.update(kws)
-    for key, kwonly in self.get_nondefault_params():
+    for key, kwonly in itertools.chain(
+        self.get_nondefault_params(),
+        ((key, True) for key in sig.kwonly_params)):
       if key not in callargs:
         if args.starstarargs or (args.starargs and not kwonly):
           # We assume that because we have *args or **kwargs, we can use these
           # to fill in any parameters we might be missing.
           callargs[key] = self.ctx.new_unsolvable(node)
         else:
           raise function.MissingParameter(sig, args, self.ctx, key)
-    for key in sig.kwonly_params:
-      if key not in callargs:
-        raise function.MissingParameter(sig, args, self.ctx, key)
     if sig.varargs_name:
       varargs_name = sig.varargs_name
       extraneous = posargs[self.argcount(node):]
diff --git a/pytype/blocks/blocks.py b/pytype/blocks/blocks.py
@@ -161,6 +161,9 @@ def __init__(self, code, bytecode, order):
     for insn in bytecode:
       insn.code = self
 
+  def __repr__(self):
+    return f"OrderedCode({self.qualname}, version={self.python_version})"
+
   @property
   def co_consts(self):
     # The blocks/pyc code mixes CodeType and OrderedCode objects when
diff --git a/pytype/matcher.py b/pytype/matcher.py
@@ -474,7 +474,7 @@ def _match_type_param_against_type_param(self, t1, t2, subst, view):
       # constraints even if t1 is bounded.
       if not t1.constraints:
         return None  # t1 is unconstrained, t2 has constraints
-      if set(t1.constraints) - set(t2.constraints):
+      if any(c not in t2.constraints for c in t1.constraints):
         return None  # t1 is more permissive than t2
     elif t2.bound:
       if t1.bound:
diff --git a/pytype/overlays/special_builtins.py b/pytype/overlays/special_builtins.py
@@ -781,6 +781,11 @@ def call(self, node, func, args, alias_map=None):
     else:
       return super().call(node, func, args, alias_map)
 
+  def get_special_attribute(self, node, name, valself):
+    # For doing something like getting the __getitem__ attribute to subscript
+    # dict, we want to use the real dict type.
+    return self.ctx.convert.dict_type.get_special_attribute(node, name, valself)
+
 
 class Type(BuiltinClass, mixin.HasSlots):
 
diff --git a/pytype/tests/test_dataclasses.py b/pytype/tests/test_dataclasses.py
@@ -781,6 +781,18 @@ class C:
         def __init__(self, *, x: int = ..., y: str) -> None: ...
     """)
 
+  @test_utils.skipBeforePy((3, 10), "KW_ONLY is new in 3.10")
+  def test_kwonly_and_kwargs(self):
+    self.Check("""
+      import dataclasses
+      @dataclasses.dataclass
+      class C:
+        _: dataclasses.KW_ONLY
+        x: int
+      def f(**kwargs):
+        return C(**kwargs)
+    """)
+
   def test_star_import(self):
     with self.DepTree([("foo.pyi", """
       import dataclasses
diff --git a/pytype/tests/test_typevar2.py b/pytype/tests/test_typevar2.py
@@ -1057,6 +1057,23 @@ def f(x: T) -> T:
       f("oops")  # wrong-arg-types
     """)
 
+  @test_utils.skipBeforePy((3, 9), "subscripting builtins.dict is new in 3.9")
+  def test_builtin_dict_constraint(self):
+    with self.DepTree([("foo.pyi", """
+      from typing import TypeVar
+      T = TypeVar('T', int, dict[str, int])
+      class C:
+        def f(self, x: T) -> T: ...
+    """)]):
+      self.Check("""
+        import foo
+        from typing import TypeVar
+        T = TypeVar('T', int, dict[str, int])
+        class C(foo.C):
+          def f(self, x: T) -> T:
+            return x
+      """)
+
 
 if __name__ == "__main__":
   test_base.main()
