gh-90370: Avoid temporary varargs tuple creation in argument passing

Lib/test/clinic.test

@@ -4108,6 +4108,136 @@ static PyObject *
 test_paramname_module_impl(PyObject *module, PyObject *mod)
 /*[clinic end generated code: output=4a2a849ecbcc8b53 input=afefe259667f13ba]*/
 
+/*[clinic input]
+test_vararg_with_other_name
+
+    *strange_name_vararg: object
+
+[clinic start generated code]*/
+
+PyDoc_STRVAR(test_vararg_with_other_name__doc__,
+"test_vararg_with_other_name($module, /, *strange_name_vararg)\n"
+"--\n"
+"\n");
+
+#define TEST_VARARG_WITH_OTHER_NAME_METHODDEF    \
+    {"test_vararg_with_other_name", _PyCFunction_CAST(test_vararg_with_other_name), METH_FASTCALL, test_vararg_with_other_name__doc__},
+
+static PyObject *
+test_vararg_with_other_name_impl(PyObject *module, Py_ssize_t varargssize,
+                                 PyObject *const *strange_name_vararg);
+
+static PyObject *
+test_vararg_with_other_name(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    Py_ssize_t varargssize = nargs;
+    PyObject *const *strange_name_vararg;
+
+    if (!_PyArg_CheckPositional("test_vararg_with_other_name", nargs, 0, PY_SSIZE_T_MAX)) {
+        goto exit;
+    }
+    strange_name_vararg = args + 0;
+    return_value = test_vararg_with_other_name_impl(module, varargssize, strange_name_vararg);
+
+exit:
+    return return_value;
+}
+
+static PyObject *
+test_vararg_with_other_name_impl(PyObject *module, Py_ssize_t varargssize,
+                                 PyObject *const *strange_name_vararg)
+/*[clinic end generated code: output=7340df6f8a2b95a8 input=44747a55460ea494]*/
+
+/*[clinic input]
+test_vararg_with_default_with_other_name
+
+    a as other_a: object
+    *args as other_args: object
+    b as other_b: bool = False
+
+[clinic start generated code]*/
+
+PyDoc_STRVAR(test_vararg_with_default_with_other_name__doc__,
+"test_vararg_with_default_with_other_name($module, /, a, *args, b=False)\n"
+"--\n"
+"\n");
+
+#define TEST_VARARG_WITH_DEFAULT_WITH_OTHER_NAME_METHODDEF    \
+    {"test_vararg_with_default_with_other_name", _PyCFunction_CAST(test_vararg_with_default_with_other_name), METH_FASTCALL|METH_KEYWORDS, test_vararg_with_default_with_other_name__doc__},
+
+static PyObject *
+test_vararg_with_default_with_other_name_impl(PyObject *module,
+                                              PyObject *other_a,
+                                              Py_ssize_t varargssize,
+                                              PyObject *const *other_args,
+                                              int other_b);
+
+static PyObject *
+test_vararg_with_default_with_other_name(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
+{
+    PyObject *return_value = NULL;
+    #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
+
+    #define NUM_KEYWORDS 2
+    static struct {
+        PyGC_Head _this_is_not_used;
+        PyObject_VAR_HEAD
+        PyObject *ob_item[NUM_KEYWORDS];
+    } _kwtuple = {
+        .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
+        .ob_item = { &_Py_ID(a), &_Py_ID(b), },
+    };
+    #undef NUM_KEYWORDS
+    #define KWTUPLE (&_kwtuple.ob_base.ob_base)
+
+    #else  // !Py_BUILD_CORE
+    #  define KWTUPLE NULL
+    #endif  // !Py_BUILD_CORE
+
+    static const char * const _keywords[] = {"a", "b", NULL};
+    static _PyArg_Parser _parser = {
+        .keywords = _keywords,
+        .fname = "test_vararg_with_default_with_other_name",
+        .kwtuple = KWTUPLE,
+    };
+    #undef KWTUPLE
+    PyObject *argsbuf[1];
+    PyObject *const *fastargs;
+    Py_ssize_t noptargs = Py_MIN(nargs, 1) + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
+    Py_ssize_t varargssize = Py_MAX(nargs - 1, 0);
+    PyObject *other_a;
+    PyObject *const *other_args;
+    int other_b = 0;
+
+    fastargs = _PyArg_UnpackKeywordsWithVarargKwonly(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, 1, argsbuf);
+    if (!fastargs) {
+        goto exit;
+    }
+    other_a = args[0];
+    other_args = args + 1;
+    if (!noptargs) {
+        goto skip_optional_kwonly;
+    }
+    other_b = PyObject_IsTrue(fastargs[0]);
+    if (other_b < 0) {
+        goto exit;
+    }
+skip_optional_kwonly:
+    return_value = test_vararg_with_default_with_other_name_impl(module, other_a, varargssize, other_args, other_b);
+
+exit:
+    return return_value;
+}
+
+static PyObject *
+test_vararg_with_default_with_other_name_impl(PyObject *module,
+                                              PyObject *other_a,
+                                              Py_ssize_t varargssize,
+                                              PyObject *const *other_args,
+                                              int other_b)
+/*[clinic end generated code: output=d2149d17eba67671 input=779a17a90096c922]*/
+
 
 /*[clinic input]
 module TestModule

Lib/test/test_clinic.py

@@ -1266,6 +1266,17 @@ def test_vararg_with_only_defaults(self):
         self.assertEqual(ac_tester.vararg_with_only_defaults(1, 2, 3, 4), ((1, 2, 3, 4), None))
         self.assertEqual(ac_tester.vararg_with_only_defaults(1, 2, 3, 4, b=5), ((1, 2, 3, 4), 5))
 
+    def test_vararg_with_other_name(self):
+        self.assertEqual(ac_tester.vararg_with_other_name(), ((), ))
+        self.assertEqual(ac_tester.vararg_with_other_name(1, 2, 3, 4), ((1, 2, 3, 4), ))
+
+    def test_vararg_with_default_with_other_name(self):
+        with self.assertRaises(TypeError):
+            ac_tester.vararg_with_default_with_other_name()
+        self.assertEqual(ac_tester.vararg_with_default_with_other_name(1, b=False), (1, (), False))
+        self.assertEqual(ac_tester.vararg_with_default_with_other_name(1, 2, 3, 4), (1, (2, 3, 4), False))
+        self.assertEqual(ac_tester.vararg_with_default_with_other_name(1, 2, 3, 4, b=True), (1, (2, 3, 4), True))
+
     def test_class_new_vararg_only(self):
         self.assertEqual(ac_tester.class_new_vararg_only(), ((), ))
         self.assertEqual(ac_tester.class_new_vararg_only(1, 2, 3, 4), ((1, 2, 3, 4), ))

Modules/_testclinic.c

@@ -1091,6 +1091,55 @@ vararg_with_only_defaults_impl(PyObject *module, Py_ssize_t varargssize,
 }
 
 
+/*[clinic input]
+vararg_with_other_name
+
+    *strange_name_vararg: object
+
+[clinic start generated code]*/
+
+static PyObject *
+vararg_with_other_name_impl(PyObject *module, Py_ssize_t varargssize,
+                            PyObject *const *strange_name_vararg)
+/*[clinic end generated code: output=73a50a717838e561 input=db56857a45dfa50e]*/
+{
+    PyObject *vararg_tuple = pack_varargs_to_tuple(varargssize, strange_name_vararg);
+    if (!vararg_tuple) {
+        return NULL;
+    }
+    PyObject *result = pack_arguments_newref(1, vararg_tuple);
+    Py_DECREF(vararg_tuple);
+    return result;
+}
+
+
+/*[clinic input]
+vararg_with_default_with_other_name
+
+    a as other_a: object
+    *args as other_args: object
+    b as other_b: bool = False
+
+[clinic start generated code]*/
+
+static PyObject *
+vararg_with_default_with_other_name_impl(PyObject *module, PyObject *other_a,
+                                         Py_ssize_t varargssize,
+                                         PyObject *const *other_args,
+                                         int other_b)
+/*[clinic end generated code: output=a7ac0fa0c132a04f input=b895540d71cd74f9]*/
+{
+    PyObject *vararg_tuple = pack_varargs_to_tuple(varargssize, other_args);
+    if (!vararg_tuple) {
+        return NULL;
+    }
+    PyObject *obj_b = other_b ? Py_True : Py_False;
+    PyObject *result = pack_arguments_newref(3, other_a, vararg_tuple, obj_b);
+    Py_DECREF(vararg_tuple);
+    return result;
+}
+
+
 
 static PyTypeObject TestClass_Type = {
         PyVarObject_HEAD_INIT(NULL, 0)
@@ -1313,6 +1362,8 @@ static PyMethodDef tester_methods[] = {
     VARARG_METHODDEF
     VARARG_WITH_DEFAULT_METHODDEF
     VARARG_WITH_ONLY_DEFAULTS_METHODDEF
+    VARARG_WITH_OTHER_NAME_METHODDEF
+    VARARG_WITH_DEFAULT_WITH_OTHER_NAME_METHODDEF
     {"class_new_vararg_only",
      _PyCFunction_CAST(_testclinic_TestClassVarargOnly),
      METH_VARARGS | METH_KEYWORDS,

Tools/clinic/clinic.py

@@ -968,10 +968,9 @@ def parser_body(prototype, *fields, declarations=''):
                 if p.is_vararg():
                     if not new_or_init:
                         parser_code.append(normalize_snippet("""
-                            %s = %s + %d;
+                            %s = args + %d;
                             """ % (
                             p.converter.parser_name,
-                            p.name,
                             vararg
                         ), indent=4))
                     else: