gh-156500: Skip non-positional parameters in wrap_dll_function()

argtypes was built from every annotated parameter, so an annotated
keyword-only, *args or **kwargs parameter contributed an extra
positional entry. argtypes describes positional arguments only, so the
generated function pointer asked for an argument the C function does
not have and could not be called by any call matching its own stub.

Build argtypes from co_varnames[:co_argcount] instead, which keeps the
existing rule that unannotated parameters are skipped.

Author: fedonman

Doc/library/ctypes.rst

@@ -711,8 +711,10 @@ Specifying function pointers using type annotations
          """Optional docstring. There should be no function body."""
 
    The body of the decorated function is ignored, and any parameters that are
-   missing type annotations are skipped. The names of the parameters are ignored
-   and do not have to match the underlying C implementation.
+   missing type annotations are skipped. Variadic and keyword-only parameters
+   are skipped as well, since :attr:`~ctypes._CFuncPtr.argtypes` describes
+   positional arguments only. The names of the parameters are ignored and do
+   not have to match the underlying C implementation.
 
    If the decorated function does not have a return type annotation, a
    :exc:`ValueError` is raised. If the name of the function does not exist

Lib/ctypes/util.py

@@ -509,8 +509,11 @@ def decorator(func):
         except KeyError as error:
             raise ValueError(f"{name!r} missing return type annotation") from error
 
+        code = func.__code__
+        positional = code.co_varnames[:code.co_argcount]
+
         ptr.restype = restype
-        ptr.argtypes = tuple(annotations.values())
+        ptr.argtypes = tuple(annotations[n] for n in positional if n in annotations)
         functools.update_wrapper(ptr, func, updated=())
 
         return ptr

Lib/test/test_ctypes/test_funcptr.py

@@ -153,6 +153,38 @@ def noexist():
             def PyObject_GetAttrString(op: ctypes.py_object, attr: ctypes.c_char_p):
                 pass
 
+    def test_wrap_dll_function_non_positional(self):
+        # argtypes describes positional arguments only, so variadic and
+        # keyword-only parameters must not contribute an entry.
+        @wrap_dll_function(ctypes.pythonapi)
+        def PyObject_GetAttr(op: ctypes.py_object, attr: ctypes.py_object,
+                             *args: ctypes.c_int) -> ctypes.py_object:
+            pass
+
+        self.assertEqual(PyObject_GetAttr.argtypes,
+                         (ctypes.py_object, ctypes.py_object))
+
+        @wrap_dll_function(ctypes.pythonapi)
+        def PyObject_GetAttr(op: ctypes.py_object, attr: ctypes.py_object,
+                             **kwargs: ctypes.c_int) -> ctypes.py_object:
+            pass
+
+        self.assertEqual(PyObject_GetAttr.argtypes,
+                         (ctypes.py_object, ctypes.py_object))
+
+        @wrap_dll_function(ctypes.pythonapi)
+        def PyObject_GetAttr(op: ctypes.py_object, attr: ctypes.py_object,
+                             *, kwonly: ctypes.c_int) -> ctypes.py_object:
+            pass
+
+        self.assertEqual(PyObject_GetAttr.argtypes,
+                         (ctypes.py_object, ctypes.py_object))
+
+        class Foo:
+            a = "abc"
+
+        self.assertEqual(PyObject_GetAttr(Foo, "a"), "abc")
+
     def test_wrap_dll_function_str_ann(self):
         from test.test_ctypes import wrap_str_ann
         version = wrap_str_ann.Py_GetVersion()