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

Include/cpython/modsupport.h

@@ -99,6 +99,13 @@ PyAPI_FUNC(PyObject * const *) _PyArg_UnpackKeywordsWithVararg(
         int minpos, int maxpos, int minkw,
         int vararg, PyObject **buf);
 
+PyAPI_FUNC(PyObject * const *) _PyArg_UnpackKeywordsWithVarargKwonly(
+        PyObject *const *args, Py_ssize_t nargs,
+        PyObject *kwargs, PyObject *kwnames,
+        struct _PyArg_Parser *parser,
+        int minpos, int maxpos, int minkw,
+        int vararg, PyObject **buf);
+
 #define _PyArg_UnpackKeywords(args, nargs, kwargs, kwnames, parser, minpos, maxpos, minkw, buf) \
     (((minkw) == 0 && (kwargs) == NULL && (kwnames) == NULL && \
       (minpos) <= (nargs) && (nargs) <= (maxpos) && (args) != NULL) ? (args) : \

Lib/test/clinic.test

@@ -3767,36 +3767,32 @@ PyDoc_STRVAR(test_vararg_and_posonly__doc__,
     {"test_vararg_and_posonly", _PyCFunction_CAST(test_vararg_and_posonly), METH_FASTCALL, test_vararg_and_posonly__doc__},
 
 static PyObject *
-test_vararg_and_posonly_impl(PyObject *module, PyObject *a, PyObject *args);
+test_vararg_and_posonly_impl(PyObject *module, PyObject *a,
+                             Py_ssize_t varargssize, PyObject *const *args);
 
 static PyObject *
 test_vararg_and_posonly(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
 {
     PyObject *return_value = NULL;
+    Py_ssize_t varargssize = Py_MAX(nargs - 1, 0);
     PyObject *a;
-    PyObject *__clinic_args = NULL;
+    PyObject *const *__clinic_args;
 
     if (!_PyArg_CheckPositional("test_vararg_and_posonly", nargs, 1, PY_SSIZE_T_MAX)) {
         goto exit;
     }
     a = args[0];
-    __clinic_args = PyTuple_New(nargs - 1);
-    if (!__clinic_args) {
-        goto exit;
-    }
-    for (Py_ssize_t i = 0; i < nargs - 1; ++i) {
-        PyTuple_SET_ITEM(__clinic_args, i, Py_NewRef(args[1 + i]));
-    }
-    return_value = test_vararg_and_posonly_impl(module, a, __clinic_args);
+    __clinic_args = args + 1;
+    return_value = test_vararg_and_posonly_impl(module, a, varargssize, __clinic_args);
 
 exit:
-    Py_XDECREF(__clinic_args);
     return return_value;
 }
 
 static PyObject *
-test_vararg_and_posonly_impl(PyObject *module, PyObject *a, PyObject *args)
-/*[clinic end generated code: output=79b75dc07decc8d6 input=08dc2bf7afbf1613]*/
+test_vararg_and_posonly_impl(PyObject *module, PyObject *a,
+                             Py_ssize_t varargssize, PyObject *const *args)
+/*[clinic end generated code: output=0c242df582a012d1 input=08dc2bf7afbf1613]*/
 
 /*[clinic input]
 test_vararg
@@ -3816,7 +3812,8 @@ PyDoc_STRVAR(test_vararg__doc__,
     {"test_vararg", _PyCFunction_CAST(test_vararg), METH_FASTCALL|METH_KEYWORDS, test_vararg__doc__},
 
 static PyObject *
-test_vararg_impl(PyObject *module, PyObject *a, PyObject *args);
+test_vararg_impl(PyObject *module, PyObject *a, Py_ssize_t varargssize,
+                 PyObject *const *args);
 
 static PyObject *
 test_vararg(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
@@ -3847,26 +3844,28 @@ test_vararg(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject
         .kwtuple = KWTUPLE,
     };
     #undef KWTUPLE
-    PyObject *argsbuf[2];
+    PyObject *argsbuf[0];
+    PyObject *const *fastargs;
+    Py_ssize_t varargssize = Py_MAX(nargs - 1, 0);
     PyObject *a;
-    PyObject *__clinic_args = NULL;
+    PyObject *const *__clinic_args;
 
-    args = _PyArg_UnpackKeywordsWithVararg(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, 1, argsbuf);
-    if (!args) {
+    fastargs = _PyArg_UnpackKeywordsWithVarargKwonly(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, 1, argsbuf);
+    if (!fastargs) {
         goto exit;
     }
     a = args[0];
-    __clinic_args = args[1];
-    return_value = test_vararg_impl(module, a, __clinic_args);
+    __clinic_args = args + 1;
+    return_value = test_vararg_impl(module, a, varargssize, __clinic_args);
 
 exit:
-    Py_XDECREF(__clinic_args);
     return return_value;
 }
 
 static PyObject *
-test_vararg_impl(PyObject *module, PyObject *a, PyObject *args)
-/*[clinic end generated code: output=880365c61ae205d7 input=81d33815ad1bae6e]*/
+test_vararg_impl(PyObject *module, PyObject *a, Py_ssize_t varargssize,
+                 PyObject *const *args)
+/*[clinic end generated code: output=2f4921abd6707648 input=81d33815ad1bae6e]*/
 
 /*[clinic input]
 test_vararg_with_default
@@ -3887,7 +3886,8 @@ PyDoc_STRVAR(test_vararg_with_default__doc__,
     {"test_vararg_with_default", _PyCFunction_CAST(test_vararg_with_default), METH_FASTCALL|METH_KEYWORDS, test_vararg_with_default__doc__},
 
 static PyObject *
-test_vararg_with_default_impl(PyObject *module, PyObject *a, PyObject *args,
+test_vararg_with_default_impl(PyObject *module, PyObject *a,
+                              Py_ssize_t varargssize, PyObject *const *args,
                               int b);
 
 static PyObject *
@@ -3919,37 +3919,39 @@ test_vararg_with_default(PyObject *module, PyObject *const *args, Py_ssize_t nar
         .kwtuple = KWTUPLE,
     };
     #undef KWTUPLE
-    PyObject *argsbuf[3];
+    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 *a;
-    PyObject *__clinic_args = NULL;
+    PyObject *const *__clinic_args;
     int b = 0;
 
-    args = _PyArg_UnpackKeywordsWithVararg(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, 1, argsbuf);
-    if (!args) {
+    fastargs = _PyArg_UnpackKeywordsWithVarargKwonly(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, 1, argsbuf);
+    if (!fastargs) {
         goto exit;
     }
     a = args[0];
-    __clinic_args = args[1];
+    __clinic_args = args + 1;
     if (!noptargs) {
         goto skip_optional_kwonly;
     }
-    b = PyObject_IsTrue(args[2]);
+    b = PyObject_IsTrue(fastargs[0]);
     if (b < 0) {
         goto exit;
     }
 skip_optional_kwonly:
-    return_value = test_vararg_with_default_impl(module, a, __clinic_args, b);
+    return_value = test_vararg_with_default_impl(module, a, varargssize, __clinic_args, b);
 
 exit:
-    Py_XDECREF(__clinic_args);
     return return_value;
 }
 
 static PyObject *
-test_vararg_with_default_impl(PyObject *module, PyObject *a, PyObject *args,
+test_vararg_with_default_impl(PyObject *module, PyObject *a,
+                              Py_ssize_t varargssize, PyObject *const *args,
                               int b)
-/*[clinic end generated code: output=291e9a5a09831128 input=6e110b54acd9b22d]*/
+/*[clinic end generated code: output=60a4333c34883cc3 input=6e110b54acd9b22d]*/
 
 /*[clinic input]
 test_vararg_with_only_defaults
@@ -3970,7 +3972,8 @@ PyDoc_STRVAR(test_vararg_with_only_defaults__doc__,
     {"test_vararg_with_only_defaults", _PyCFunction_CAST(test_vararg_with_only_defaults), METH_FASTCALL|METH_KEYWORDS, test_vararg_with_only_defaults__doc__},
 
 static PyObject *
-test_vararg_with_only_defaults_impl(PyObject *module, PyObject *args, int b,
+test_vararg_with_only_defaults_impl(PyObject *module, Py_ssize_t varargssize,
+                                    PyObject *const *args, int b,
                                     PyObject *c);
 
 static PyObject *
@@ -4002,42 +4005,44 @@ test_vararg_with_only_defaults(PyObject *module, PyObject *const *args, Py_ssize
         .kwtuple = KWTUPLE,
     };
     #undef KWTUPLE
-    PyObject *argsbuf[3];
+    PyObject *argsbuf[2];
+    PyObject *const *fastargs;
     Py_ssize_t noptargs = 0 + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
-    PyObject *__clinic_args = NULL;
+    Py_ssize_t varargssize = nargs;
+    PyObject *const *__clinic_args;
     int b = 0;
     PyObject *c = " ";
 
-    args = _PyArg_UnpackKeywordsWithVararg(args, nargs, NULL, kwnames, &_parser, 0, 0, 0, 0, argsbuf);
-    if (!args) {
+    fastargs = _PyArg_UnpackKeywordsWithVarargKwonly(args, nargs, NULL, kwnames, &_parser, 0, 0, 0, 0, argsbuf);
+    if (!fastargs) {
         goto exit;
     }
-    __clinic_args = args[0];
+    __clinic_args = args + 0;
     if (!noptargs) {
         goto skip_optional_kwonly;
     }
-    if (args[1]) {
-        b = PyObject_IsTrue(args[1]);
+    if (fastargs[0]) {
+        b = PyObject_IsTrue(fastargs[0]);
         if (b < 0) {
             goto exit;
         }
         if (!--noptargs) {
             goto skip_optional_kwonly;
         }
     }
-    c = args[2];
+    c = fastargs[1];
 skip_optional_kwonly:
-    return_value = test_vararg_with_only_defaults_impl(module, __clinic_args, b, c);
+    return_value = test_vararg_with_only_defaults_impl(module, varargssize, __clinic_args, b, c);
 
 exit:
-    Py_XDECREF(__clinic_args);
     return return_value;
 }
 
 static PyObject *
-test_vararg_with_only_defaults_impl(PyObject *module, PyObject *args, int b,
+test_vararg_with_only_defaults_impl(PyObject *module, Py_ssize_t varargssize,
+                                    PyObject *const *args, int b,
                                     PyObject *c)
-/*[clinic end generated code: output=dd21b28f0db26a4b input=fa56a709a035666e]*/
+/*[clinic end generated code: output=fd25c0b3171663cc input=fa56a709a035666e]*/
 
 /*[clinic input]
 test_paramname_module
@@ -4102,3 +4107,129 @@ exit:
 static PyObject *
 test_paramname_module_impl(PyObject *module, PyObject *mod)
 /*[clinic end generated code: output=4a2a849ecbcc8b53 input=afefe259667f13ba]*/
+
+
+/*[clinic input]
+module TestModule
+class TestModule.TestClass1 "TestClassObject *" "&TestModule_Type"
+class TestModule.TestClass2 "TestClassObject *" "&TestModule_Type"
+[clinic start generated code]*/
+/*[clinic end generated code: output=da39a3ee5e6b4b0d input=cd38925654911fd4]*/
+
+
+/*[clinic input]
+TestModule.TestClass1.__init__
+
+    *args: object
+
+[clinic start generated code]*/
+
+static int
+TestModule_TestClass1___init___impl(TestClassObject *self,
+                                    Py_ssize_t varargssize,
+                                    PyObject *const *args);
+
+static int
+TestModule_TestClass1___init__(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+    int return_value = -1;
+    Py_ssize_t varargssize = PyTuple_GET_SIZE(args);
+    PyTypeObject *base_tp = &TestModule_Type;
+    PyObject *const *__clinic_args;
+
+    if ((Py_IS_TYPE(self, base_tp) ||
+         Py_TYPE(self)->tp_new == base_tp->tp_new) &&
+        !_PyArg_NoKeywords("TestClass1", kwargs)) {
+        goto exit;
+    }
+    if (!_PyArg_CheckPositional("TestClass1", PyTuple_GET_SIZE(args), 0, PY_SSIZE_T_MAX)) {
+        goto exit;
+    }
+    __clinic_args = _PyTuple_CAST(args)->ob_item;
+    return_value = TestModule_TestClass1___init___impl((TestClassObject *)self, varargssize, __clinic_args);
+
+exit:
+    return return_value;
+}
+
+static int
+TestModule_TestClass1___init___impl(TestClassObject *self,
+                                    Py_ssize_t varargssize,
+                                    PyObject *const *args)
+/*[clinic end generated code: output=3f3f406f43e296d2 input=3e093b8ea0b74b0c]*/
+
+
+/*[clinic input]
+TestModule.TestClass2.__init__
+
+    pos: object
+    *args: object
+    kw: object = None
+
+[clinic start generated code]*/
+
+static int
+TestModule_TestClass2___init___impl(TestClassObject *self, PyObject *pos,
+                                    Py_ssize_t varargssize,
+                                    PyObject *const *args, PyObject *kw);
+
+static int
+TestModule_TestClass2___init__(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+    int return_value = -1;
+    #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(pos), &_Py_ID(kw), },
+    };
+    #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[] = {"pos", "kw", NULL};
+    static _PyArg_Parser _parser = {
+        .keywords = _keywords,
+        .fname = "TestClass2",
+        .kwtuple = KWTUPLE,
+    };
+    #undef KWTUPLE
+    PyObject *argsbuf[1];
+    PyObject * const *fastargs;
+    Py_ssize_t nargs = PyTuple_GET_SIZE(args);
+    Py_ssize_t noptargs = Py_MIN(nargs, 1) + (kwargs ? PyDict_GET_SIZE(kwargs) : 0) - 1;
+    Py_ssize_t varargssize = Py_MAX(nargs - 1, 0);
+    PyObject *pos;
+    PyObject *const *__clinic_args;
+    PyObject *kw = Py_None;
+
+    fastargs = _PyArg_UnpackKeywordsWithVarargKwonly(_PyTuple_CAST(args)->ob_item, nargs, kwargs, NULL, &_parser, 1, 1, 0, 1, argsbuf);
+    if (!fastargs) {
+        goto exit;
+    }
+    pos = PyTuple_GET_ITEM(args, 0);
+    __clinic_args = _PyTuple_CAST(args)->ob_item + 1;
+    if (!noptargs) {
+        goto skip_optional_kwonly;
+    }
+    kw = fastargs[0];
+skip_optional_kwonly:
+    return_value = TestModule_TestClass2___init___impl((TestClassObject *)self, pos, varargssize, __clinic_args, kw);
+
+exit:
+    return return_value;
+}
+
+static int
+TestModule_TestClass2___init___impl(TestClassObject *self, PyObject *pos,
+                                    Py_ssize_t varargssize,
+                                    PyObject *const *args, PyObject *kw)
+/*[clinic end generated code: output=335f080bcb0946ab input=833936c1d51c4329]*/

Lib/test/test_clinic.py

@@ -1266,6 +1266,24 @@ 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_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), ))
+
+    def test_class_new_vararg(self):
+        with self.assertRaises(TypeError):
+            ac_tester.class_new_vararg()
+        with self.assertRaises(TypeError):
+            ac_tester.class_new_vararg(1, b=2)
+        self.assertEqual(ac_tester.class_new_vararg(1, 2, 3, 4), (1, (2, 3, 4)))
+
+    def test_vararg_with_default(self):
+        with self.assertRaises(TypeError):
+            ac_tester.class_new_vararg_with_default()
+        self.assertEqual(ac_tester.class_new_vararg_with_default(1, b=2), (1, (), 2))
+        self.assertEqual(ac_tester.class_new_vararg_with_default(1, 2, 3, 4), (1, (2, 3, 4), None))
+        self.assertEqual(ac_tester.class_new_vararg_with_default(1, 2, 3, 4, b=5), (1, (2, 3, 4), 5))
+
     def test_gh_32092_oob(self):
         ac_tester.gh_32092_oob(1, 2, 3, 4, kw1=5, kw2=6)
 

Misc/NEWS.d/next/Core and Builtins/2022-01-04-08-09-32.bpo-46212._Fvxj6.rst

@@ -0,0 +1,5 @@
+Avoid creating temporary varargs tuple in argument passing with Argument Clinic generated code.
+
+Introduce the :c:func:`_PyArg_UnpackKeywordsWithVarargKwonly` function,
+which checks and parses positional arguments, varargs, and keyword arguments,
+but returns only parsed kwonly arguments.