Remove zero_arg case

Author: cmaloney

Lib/test/test_clinic.py

@@ -2751,38 +2751,6 @@ class Foo "FooObject *" "Foo_Type"
         self.assertTrue(func.vectorcall)
         self.assertTrue(func.vectorcall_exact_only)
 
-    def test_vectorcall_zero_arg(self):
-        block = """
-            module m
-            class Foo "FooObject *" "Foo_Type"
-            @classmethod
-            @vectorcall zero_arg=_PyFoo_GetEmpty()
-            Foo.__new__
-                x: object = NULL
-                /
-        """
-        func = self.parse_function(block, signatures_in_block=3,
-                                   function_index=2)
-        self.assertTrue(func.vectorcall)
-        self.assertFalse(func.vectorcall_exact_only)
-        self.assertEqual(func.vectorcall_zero_arg, '_PyFoo_GetEmpty()')
-
-    def test_vectorcall_zero_arg_with_exact(self):
-        block = """
-            module m
-            class Foo "FooObject *" "Foo_Type"
-            @classmethod
-            @vectorcall exact_only zero_arg=get_cached()
-            Foo.__new__
-                x: object = NULL
-                /
-        """
-        func = self.parse_function(block, signatures_in_block=3,
-                                   function_index=2)
-        self.assertTrue(func.vectorcall)
-        self.assertTrue(func.vectorcall_exact_only)
-        self.assertEqual(func.vectorcall_zero_arg, 'get_cached()')
-
     def test_vectorcall_invalid_kwarg(self):
         err = "unknown argument"
         block = """
@@ -4475,21 +4443,6 @@ def test_vc_new_exact_subclass(self):
         self.assertIsInstance(obj, Sub)
         self.assertIsInstance(obj, ac_tester.VcNewExact)
 
-    def test_vc_new_zeroarg_no_args(self):
-        # zero_arg returns Py_None when called with no arguments
-        result = ac_tester.VcNewZeroArg()
-        self.assertIs(result, None)
-
-    def test_vc_new_zeroarg_with_args(self):
-        self.assertIsInstance(ac_tester.VcNewZeroArg(1), ac_tester.VcNewZeroArg)
-        self.assertIsInstance(ac_tester.VcNewZeroArg(b=2), ac_tester.VcNewZeroArg)
-        self.assertIsInstance(ac_tester.VcNewZeroArg(1, b=2), ac_tester.VcNewZeroArg)
-
-    def test_vc_new_zeroarg_rejects_a_as_keyword(self):
-        # 'a' is positional-only
-        with self.assertRaises(TypeError):
-            ac_tester.VcNewZeroArg(a=1)
-
 
 class LimitedCAPIOutputTests(unittest.TestCase):
 

Modules/_testclinic.c

@@ -26,8 +26,6 @@ custom_converter(PyObject *obj, custom_t *val)
 static PyTypeObject VcNew_Type;
 static PyTypeObject VcInit_Type;
 static PyTypeObject VcNewExact_Type;
-static PyTypeObject VcNewZeroArg_Type;
-
 #include "clinic/_testclinic.c.h"
 
 
@@ -2409,35 +2407,6 @@ static PyTypeObject VcNewExact_Type = {
 };
 
 
-/* VcNewZeroArg: __new__ with zero_arg; returns Py_None when called with no args */
-
-/*[clinic input]
-class _testclinic.VcNewZeroArg "PyObject *" "&VcNewZeroArg_Type"
-@classmethod
-@vectorcall zero_arg=Py_NewRef(Py_None)
-_testclinic.VcNewZeroArg.__new__ as vc_zeroarg_new
-    a: object = None
-    /
-    *
-    b: object = None
-[clinic start generated code]*/
-
-static PyObject *
-vc_zeroarg_new_impl(PyTypeObject *type, PyObject *a, PyObject *b)
-/*[clinic end generated code: output=6425b64d61c6317a input=f3d3ba860fc40034]*/
-{
-    return type->tp_alloc(type, 0);
-}
-
-static PyTypeObject VcNewZeroArg_Type = {
-    PyVarObject_HEAD_INIT(NULL, 0)
-    .tp_name = "_testclinic.VcNewZeroArg",
-    .tp_basicsize = sizeof(PyObject),
-    .tp_flags = Py_TPFLAGS_DEFAULT,
-    .tp_new = vc_zeroarg_new,
-    .tp_vectorcall = vc_zeroarg_vectorcall,
-};
-
 
 /*[clinic input]
 output push
@@ -2667,9 +2636,6 @@ PyInit__testclinic(void)
     if (PyModule_AddType(m, &VcNewExact_Type) < 0) {
         goto error;
     }
-    if (PyModule_AddType(m, &VcNewZeroArg_Type) < 0) {
-        goto error;
-    }
     return m;
 
 error:

Modules/clinic/_testclinic.c.h

@@ -778,7 +778,7 @@ static PyObject *
 tuple_subtype_new(PyTypeObject *type, PyObject *iterable);
 
 /*[clinic input]
-@vectorcall zero_arg=(PyObject*)&_Py_SINGLETON(tuple_empty)
+@vectorcall
 @classmethod
 tuple.__new__ as tuple_new
     iterable: object(c_default="NULL") = ()
@@ -794,7 +794,7 @@ If the argument is a tuple, the return value is the same object.
 
 static PyObject *
 tuple_new_impl(PyTypeObject *type, PyObject *iterable)
-/*[clinic end generated code: output=4546d9f0d469bce7 input=fff66d7a13734d92]*/
+/*[clinic end generated code: output=4546d9f0d469bce7 input=8fdda913493ebe48]*/
 {
     if (type != &PyTuple_Type)
         return tuple_subtype_new(type, iterable);

Objects/clinic/tupleobject.c.h

@@ -304,7 +304,6 @@ def reset(self) -> None:
         self.disable_fastcall = False
         self.vectorcall = False
         self.vectorcall_exact_only = False
-        self.vectorcall_zero_arg = ''
         self.permit_long_summary = False
         self.permit_long_docstring_body = False
 
@@ -480,10 +479,6 @@ def at_vectorcall(self, *args: str) -> None:
                 key, value = arg, ''
             if key == 'exact_only':
                 self.vectorcall_exact_only = True
-            elif key == 'zero_arg':
-                if not value:
-                    fail("@vectorcall zero_arg requires a value")
-                self.vectorcall_zero_arg = value
             else:
                 fail(f"@vectorcall: unknown argument {key!r}")
 
@@ -751,7 +746,6 @@ def state_modulename_name(self, line: str) -> None:
             forced_text_signature=self.forced_text_signature,
             vectorcall=self.vectorcall,
             vectorcall_exact_only=self.vectorcall_exact_only,
-            vectorcall_zero_arg=self.vectorcall_zero_arg,
         )
         self.add_function(func)
 

Objects/tupleobject.c

@@ -113,7 +113,6 @@ class Function:
     target_critical_section: list[str] = dc.field(default_factory=list)
     vectorcall: bool = False
     vectorcall_exact_only: bool = False
-    vectorcall_zero_arg: str = ''
 
     def __post_init__(self) -> None:
         self.parent = self.cls or self.module

Tools/clinic/libclinic/dsl_parser.py

@@ -1283,22 +1283,11 @@ def generate_vectorcall(self) -> str:
             }}
             """)
 
-        # Zero-arg shortcut: return a cached value when called with no args
-        zero_arg_shortcut = ""
-        if func.vectorcall_zero_arg:
-            zero_arg_shortcut = libclinic.normalize_snippet(f"""
-                if (nargs == 0 && kwnames == NULL) {{{{
-                    return {func.vectorcall_zero_arg};
-                }}}}
-            """, indent=4)
-
         # Assemble the full function
         lines = [prototype]
         lines.append(preamble)
         if exact_check:
             lines.append(exact_check)
-        if zero_arg_shortcut:
-            lines.append(zero_arg_shortcut)
         lines.extend(parsing_code)
         lines.append(finale)