Fixed the signature computation for a functools.partial-wrapped callable

The diff is hopefully self-explanatory, but the gist is that parameters can
only be overwritten via a keyword argument. This means that

* positional-only parameters cannot be overwritten;
* "normal" parameters must become keyword-only in the resulting signature.

PiperOrigin-RevId: 821616872

Author: superbobry

pytype/overlays/functools_overlay.py

@@ -147,10 +147,37 @@ def get_signatures(self) -> Sequence[function.Signature]:
         # Use the partial arguments as defaults in the signature, making them
         # optional but overwritable.
         defaults = sig.defaults.copy()
+        kwonly_params = [*sig.kwonly_params]
+        bound_param_names = set()
+        pos_only_count = sig.posonly_count
         for name, value, _ in sig.iter_args(args):
-          if value is not None:
-            defaults[name] = value
-        sigs.append(sig._replace(defaults=defaults))
+          if value is None:
+            continue
+          if sig.param_names.index(name) < sig.posonly_count:
+            # The parameter is positional-only, meaning that it cannot be
+            # overwritten via a keyword argument. Remove it.
+            bound_param_names.add(name)
+            sig.posonly_count -= 1
+            continue
+          if name not in sig.kwonly_params:
+            # The parameter can be overwritten via a keyword argument. Note
+            # that we still have to remove it from ``param_names`` to make
+            # sure it cannot be bound by position.
+            bound_param_names.add(name)
+            kwonly_params.append(name)
+
+          defaults[name] = value
+
+        sigs.append(
+            sig._replace(
+                param_names=tuple(
+                    n for n in sig.param_names if n not in bound_param_names
+                ),
+                posonly_count=pos_only_count,
+                kwonly_params=tuple(kwonly_params),
+                defaults=defaults,
+            )
+        )
     return sigs
 
   def call_slot(self, node: cfg.CFGNode, *args, **kwargs):

pytype/tests/test_attr2.py

@@ -230,6 +230,20 @@ class Foo:
       assert_type(foo.x, str)
     """)
 
+  def test_partial_with_positional_args_as_converter(self):
+    self.Check("""
+      import attr
+      import functools
+      def f(x: str, y: int) -> int:
+        del x
+        return y
+      @attr.s
+      class Foo:
+        x = attr.ib(converter=functools.partial(f, "foo"))
+      foo = Foo(x=0)
+      assert_type(foo.x, int)
+    """)
+
   def test_partial_overloaded_as_converter(self):
     self.Check("""
       import attr