gh-87613: Allow Argument Clinic vectorcall on heap types (#160115)

Heap types have no static type object so switch from `Py_Is` to an
assert that the shadowed `tp_new` / `tp_init` function is the expected
one to validate the vectorcall is only used with the right type.

Heap types can have zero-argument `__new__` and `__init__` so add
support  for that producing the same error message via a new helper
`_PyArg_NoPositionalStack()`.

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>

Author: cmaloney

Include/internal/pycore_modsupport.h

@@ -20,6 +20,12 @@ PyAPI_FUNC(int) _PyArg_NoPositional(const char *funcname, PyObject *args);
 #define _PyArg_NoPositional(funcname, args) \
     ((args) == NULL || _PyArg_NoPositional((funcname), (args)))
 
+// Export for Argument Clinic generated code in shared extensions
+PyAPI_FUNC(int) _PyArg_NoPositionalStack(const char *funcname,
+                                         Py_ssize_t nargs);
+#define _PyArg_NoPositionalStack(funcname, nargs) \
+    ((nargs) == 0 || _PyArg_NoPositionalStack((funcname), (nargs)))
+
 // Export for '_asyncio' shared extension
 PyAPI_FUNC(int) _PyArg_NoKeywords(const char *funcname, PyObject *kwargs);
 #define _PyArg_NoKeywords(funcname, kwargs) \

Lib/test/clinic.test.c

@@ -4946,6 +4946,7 @@ Test_cls_with_param_impl(TestObj *self, PyTypeObject *cls, int a)
 
 
 /*[clinic input]
+@vectorcall
 Test.__init__
 Empty init method.
 [clinic start generated code]*/
@@ -4981,9 +4982,42 @@ Test___init__(PyObject *self, 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 *self;
+    int _result;
+
+    assert(_PyType_CAST(type)->tp_init == Test___init__);
+    /* 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_NoPositionalStack("Test", nargs) ||
+        !_PyArg_NoKwnames("Test", kwnames)) {
+        goto exit;
+    }
+    self = _PyType_CAST(type)->tp_new(_PyType_CAST(type),
+        (PyObject *)&_Py_SINGLETON(tuple_empty), NULL);
+    if (self == NULL) {
+        goto exit;
+    }
+    _result = Test___init___impl((TestObj *)self);
+    if (_result != 0) {
+        Py_DECREF(self);
+        goto exit;
+    }
+    return_value = self;
+
+exit:
+    return return_value;
+}
+
 static int
 Test___init___impl(TestObj *self)
-/*[clinic end generated code: output=f6a35c85bc5b408f input=4ea79fee54d0c3ff]*/
+/*[clinic end generated code: output=ce04b9d7beacd894 input=645fe693f6c6b9b6]*/
 
 
 /*[clinic input]

Lib/test/test_clinic.py

@@ -3500,8 +3500,6 @@ def test_vectorcall_on_init(self):
             class Foo "FooObject *" "Foo_Type"
             @vectorcall
             Foo.__init__
-                iterable: object = NULL
-                /
         """
         func = self.parse_function(block, signatures_in_block=3,
                                    function_index=2)
@@ -3532,14 +3530,16 @@ class Foo "FooObject *" "Foo_Type"
         self.expect_failure(block, err, lineno=2)
 
     def test_vectorcall_without_type_object(self):
-        err = "@vectorcall requires the type object of 'Foo'"
+        # Heap types have no C pointer to name, so the type object is optional.
         block = """
             module m
             class Foo "FooObject *" ""
             @vectorcall
             Foo.__init__
         """
-        self.expect_failure(block, err, lineno=3)
+        func = self.parse_function(block, signatures_in_block=3,
+                                   function_index=2)
+        self.assertTrue(func.vectorcall)
 
     def test_vectorcall_unsupported_converter(self):
         # str(encoding=...) has no parse_arg() implementation.

Misc/NEWS.d/next/Tools-Demos/2026-10-21-11-53-40.gh-issue-87613.tmKBlg.rst

@@ -0,0 +1,2 @@
+Extend Argument Clinic :ref:`vectorcall` to support :ref:`heap-types` with
+zero argument construction.

Modules/_testclinic.c

@@ -24,7 +24,6 @@ custom_converter(PyObject *obj, custom_t *val)
 /* Forward declarations for vectorcall types, needed because
  * clinic/_testclinic.c.h is included before the type definitions. */
 static PyTypeObject VcNew_Type;
-static PyTypeObject VcInit_Type;
 static PyTypeObject VcNewBase_Type;
 static PyTypeObject VcKwOnly_Type;
 #include "clinic/_testclinic.c.h"
@@ -2539,7 +2538,7 @@ static PyTypeObject VcNew_Type = {
  * in both the helper body and the vectorcall fast-path inner block. */
 
 /*[clinic input]
-class _testclinic.VcInit "PyObject *" "&VcInit_Type"
+class _testclinic.VcInit "PyObject *" ""
 @vectorcall
 @critical_section
 _testclinic.VcInit.__init__ as vc_posorkw_init
@@ -2550,19 +2549,24 @@ _testclinic.VcInit.__init__ as vc_posorkw_init
 
 static int
 vc_posorkw_init_impl(PyObject *self, PyObject *a, PyObject *b)
-/*[clinic end generated code: output=6018424ba9fb0744 input=7a4513f78dd42b57]*/
+/*[clinic end generated code: output=6018424ba9fb0744 input=f0c7a84428d5b33d]*/
 {
     return 0;
 }
 
-static PyTypeObject VcInit_Type = {
-    PyVarObject_HEAD_INIT(NULL, 0)
-    .tp_name = "_testclinic.VcInit",
-    .tp_basicsize = sizeof(PyObject),
-    .tp_flags = Py_TPFLAGS_DEFAULT,
-    .tp_new = PyType_GenericNew,
-    .tp_init = vc_posorkw_init,
-    .tp_vectorcall = vc_posorkw_vectorcall,
+/* Heap type: the generated vectorcall can't name the type object. */
+static PyType_Slot VcInit_slots[] = {
+    {Py_tp_new, PyType_GenericNew},
+    {Py_tp_init, vc_posorkw_init},
+    {Py_tp_vectorcall, vc_posorkw_vectorcall},
+    {0, NULL},
+};
+
+static PyType_Spec VcInit_spec = {
+    .name = "_testclinic.VcInit",
+    .basicsize = sizeof(PyObject),
+    .flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_IMMUTABLETYPE,
+    .slots = VcInit_slots,
 };
 
 
@@ -2880,7 +2884,8 @@ PyInit__testclinic(void)
     if (PyModule_AddType(m, &VcNew_Type) < 0) {
         goto error;
     }
-    if (PyModule_AddType(m, &VcInit_Type) < 0) {
+    if (PyModule_Add(m, "VcInit",
+                     PyType_FromModuleAndSpec(m, &VcInit_spec, NULL)) < 0) {
         goto error;
     }
     if (PyModule_AddType(m, &VcNewBase_Type) < 0) {