Add a test class where all args are keyword allowed to increase coverage of generated cases

Author: cmaloney

Lib/test/test_clinic.py

@@ -4444,6 +4444,21 @@ def test_vc_new_exact_subclass(self):
         self.assertIsInstance(obj, Sub)
         self.assertIsInstance(obj, ac_tester.VcNewExact)
 
+    def test_vc_kwonly(self):
+        # keyword-only 'b': vectorcall has no kwnames==NULL fast path,
+        # so every call goes through the helper.
+        self.assertIsInstance(ac_tester.VcKwOnly(1), ac_tester.VcKwOnly)
+        self.assertIsInstance(ac_tester.VcKwOnly(1, b=2), ac_tester.VcKwOnly)
+        self.assertIsInstance(ac_tester.VcKwOnly(a=1, b=2), ac_tester.VcKwOnly)
+
+    def test_vc_kwonly_b_as_positional(self):
+        with self.assertRaises(TypeError):
+            ac_tester.VcKwOnly(1, 2)
+
+    def test_vc_kwonly_missing_required(self):
+        with self.assertRaises(TypeError):
+            ac_tester.VcKwOnly()
+
 
 class LimitedCAPIOutputTests(unittest.TestCase):
 

Modules/_testclinic.c

@@ -26,6 +26,7 @@ custom_converter(PyObject *obj, custom_t *val)
 static PyTypeObject VcNew_Type;
 static PyTypeObject VcInit_Type;
 static PyTypeObject VcNewExact_Type;
+static PyTypeObject VcKwOnly_Type;
 #include "clinic/_testclinic.c.h"
 
 
@@ -2407,6 +2408,38 @@ static PyTypeObject VcNewExact_Type = {
 };
 
 
+/* VcKwOnly: @vectorcall + keyword-only arg.
+ * Exercises the no-kwnames==NULL-fast-path branch of the vectorcall codegen:
+ * the vectorcall function delegates unconditionally to the helper because the
+ * keyword-only parameter rules out the positional-only fast path. */
+
+/*[clinic input]
+class _testclinic.VcKwOnly "PyObject *" "&VcKwOnly_Type"
+@classmethod
+@vectorcall
+_testclinic.VcKwOnly.__new__ as vc_kwonly_new
+    a: object
+    *
+    b: object = None
+[clinic start generated code]*/
+
+static PyObject *
+vc_kwonly_new_impl(PyTypeObject *type, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=00417079caa234dc input=68c863b55575a9e1]*/
+{
+    return type->tp_alloc(type, 0);
+}
+
+static PyTypeObject VcKwOnly_Type = {
+    PyVarObject_HEAD_INIT(NULL, 0)
+    .tp_name = "_testclinic.VcKwOnly",
+    .tp_basicsize = sizeof(PyObject),
+    .tp_flags = Py_TPFLAGS_DEFAULT,
+    .tp_new = vc_kwonly_new,
+    .tp_vectorcall = vc_kwonly_vectorcall,
+};
+
+
 
 /*[clinic input]
 output push
@@ -2636,6 +2669,9 @@ PyInit__testclinic(void)
     if (PyModule_AddType(m, &VcNewExact_Type) < 0) {
         goto error;
     }
+    if (PyModule_AddType(m, &VcKwOnly_Type) < 0) {
+        goto error;
+    }
     return m;
 
 error:

Modules/clinic/_testclinic.c.h

@@ -354,6 +354,7 @@ Modules/_testclinic.c	-	DeprKwdInitNoInline	-
 Modules/_testclinic.c	-	DeprKwdNew	-
 Modules/_testclinic.c	-	TestClass	-
 Modules/_testclinic.c	-	VcInit_Type	-
+Modules/_testclinic.c	-	VcKwOnly_Type	-
 Modules/_testclinic.c	-	VcNew_Type	-
 Modules/_testclinic.c	-	VcNewExact_Type	-
 

Tools/c-analyzer/cpython/globals-to-fix.tsv

@@ -1206,7 +1206,14 @@ def _vc_prototype(self) -> str:
                 size_t nargsf, PyObject *kwnames)
         """)
 
-    def _vc_preamble(self) -> str:
+    def _vc_preamble(self, needs_finale: bool) -> str:
+        if not needs_finale:
+            # No fast path, no impl call: return_value and the per-arg
+            # locals are unused — emit only what the helper call needs.
+            return libclinic.normalize_snippet("""
+                {{
+                    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
+            """) + "\n"
         return libclinic.normalize_snippet("""
             {{
                 PyObject *return_value = NULL;
@@ -1275,7 +1282,7 @@ def generate_vectorcall(self) -> str:
         """Generate a vectorcall function for __init__ or __new__."""
         parsing_code, needs_finale = self._generate_vc_parsing_code()
 
-        lines = [self._vc_prototype(), self._vc_preamble()]
+        lines = [self._vc_prototype(), self._vc_preamble(needs_finale)]
 
         exact_check = self._vc_exact_check()
         if exact_check:
@@ -1288,7 +1295,7 @@ def generate_vectorcall(self) -> str:
             # Slow path already returned via the helper call; close the
             # function so the impl-call finale would not be emitted as
             # dead code.
-            lines.append("}")
+            lines.append("}}")
 
         code = libclinic.linear_format(
             "\n".join(lines),