gh-87613: Support *args in Argument Clinic vectorcall

`@vectorcall` accepted `*args`, but the generated code expected an
args tuple. Use fastcall form to parse the args array.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: cmaloney

Lib/test/clinic.test.c

@@ -5220,6 +5220,7 @@ Test___init___impl(TestObj *self, PyObject *args)
 /*[clinic end generated code: output=0e5836c40dbc2397 input=a615a4485c0fc3e2]*/
 
 /*[clinic input]
+@vectorcall
 @classmethod
 Test.__new__
     *args: tuple
@@ -5261,9 +5262,37 @@ Test(PyTypeObject *type, PyObject *args, PyObject *kwargs)
     return return_value;
 }
 
+static PyObject *
+Test_vectorcall(PyObject *type, PyObject *const *args,
+    size_t nargsf, PyObject *kwnames)
+{
+    PyObject *return_value = NULL;
+    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
+    PyObject *__clinic_args = NULL;
+
+    assert(_PyType_CAST(type)->tp_new == Test);
+    /* Make sure the type object is immutable: the generated
+     * vectorcall doesn't deal e.g. with users reassigning __init__. */
+    assert(PyType_HasFeature(_PyType_CAST(type), Py_TPFLAGS_IMMUTABLETYPE));
+    if (!_PyArg_NoKwnames("Test", kwnames)) {
+        goto exit;
+    }
+    __clinic_args = PyTuple_FromArray(args, nargs);
+    if (__clinic_args == NULL) {
+        goto exit;
+    }
+    return_value = Test_impl(_PyType_CAST(type), __clinic_args);
+
+exit:
+    /* Cleanup for args */
+    Py_XDECREF(__clinic_args);
+
+    return return_value;
+}
+
 static PyObject *
 Test_impl(PyTypeObject *type, PyObject *args)
-/*[clinic end generated code: output=e6fba0c8951882fd input=8ce30adb836aeacb]*/
+/*[clinic end generated code: output=07f68e3971ed24cc input=1dc824fd6cec5f8e]*/
 
 
 /*[clinic input]

Tools/clinic/libclinic/parse_args.py

@@ -923,14 +923,14 @@ def render_option_groups_parse_tuple(
         parser_code.append("    }}")
         return parser_code
 
-    def _parse_vararg(self) -> str:
+    def _parse_vararg(self, *, fastcall: bool) -> str:
         assert self.varpos is not None
         c = self.varpos.converter
         assert isinstance(c, libclinic.converters.VarPosCConverter)
         return c.parse_vararg(pos_only=self.pos_only,
                               min_pos=self.min_pos,
                               max_pos=self.max_pos,
-                              fastcall=self.fastcall,
+                              fastcall=fastcall,
                               limited_capi=self.limited_capi)
 
     def _parse_kwarg(self) -> str:
@@ -963,6 +963,7 @@ def _parse_positional_args(
         argname_fmt: str,
         nargs: str,
         limited_capi: bool,
+        fastcall: bool,
     ) -> list[str] | None:
         """Emit per-parameter positional argument parsing.
 
@@ -995,8 +996,8 @@ def _parse_positional_args(
         if self.min_pos < len(self.parameters):
             parser_code.append("skip_optional:")
         if self.varpos:
-            parser_code.append(libclinic.normalize_snippet(self._parse_vararg(),
-                                                           indent=4))
+            parser_code.append(libclinic.normalize_snippet(
+                self._parse_vararg(fastcall=fastcall), indent=4))
         elif self.var_keyword:
             parser_code.append(libclinic.normalize_snippet(self._parse_kwarg(),
                                                            indent=4))
@@ -1090,7 +1091,7 @@ def parse_pos_only(self) -> None:
 
         pos_code = self._parse_positional_args(
             argname_fmt=argname_fmt, nargs=nargs,
-            limited_capi=self.limited_capi)
+            limited_capi=self.limited_capi, fastcall=self.fastcall)
         if pos_code is not None:
             parser_code.extend(pos_code)
         else:
@@ -1148,7 +1149,8 @@ def parse_var_keyword(self) -> None:
             parser_code.append("skip_optional:")
 
         if self.varpos:
-            parser_code.append(libclinic.normalize_snippet(self._parse_vararg(), indent=4))
+            parser_code.append(libclinic.normalize_snippet(
+                self._parse_vararg(fastcall=self.fastcall), indent=4))
         if self.var_keyword:
             parser_code.append(libclinic.normalize_snippet(self._parse_kwarg(), indent=4))
         self.parser_body(*parser_code)
@@ -1376,7 +1378,12 @@ def parse_general(self, clang: CLanguage) -> None:
             if add_label:
                 parser_code.append("%s:" % add_label)
             if self.varpos:
-                parser_code.append(libclinic.normalize_snippet(self._parse_vararg(), indent=4))
+                # The vectorcall helper gets an array of arguments, not a
+                # tuple: use the converters' fastcall convention, which
+                # handles that.
+                fastcall = True if self.func.vectorcall else self.fastcall
+                parser_code.append(libclinic.normalize_snippet(
+                    self._parse_vararg(fastcall=fastcall), indent=4))
         else:
             self.use_converters()
 
@@ -1617,8 +1624,11 @@ def _vectorcall_positional(self, *,
 
         arity_checked: Already have a number of arguments check.
         """
+        # The vectorcall gets an array of arguments, not a tuple: use the
+        # converters' fastcall convention, which handles that.
         pos_code = self._parse_positional_args(
-            argname_fmt='args[%d]', nargs='nargs', limited_capi=False)
+            argname_fmt='args[%d]', nargs='nargs', limited_capi=False,
+            fastcall=True)
         # Converter support was validated when @vectorcall was parsed.
         assert pos_code is not None
         if arity_checked: