bpo-43908: Immutable types inherit vectorcall (GH-27001)

Erlend Egeberg Aasland · vstinner · web-flow · commit a3739b207adb · 2021-07-08T12:48:01.000+02:00
Heap types with the Py_TPFLAGS_IMMUTABLETYPE flag can now inherit the
PEP 590 vectorcall protocol.  Previously, this was only possible for static types.

Co-authored-by: Victor Stinner &lt;vstinner@python.org&gt;
diff --git a/Doc/c-api/typeobj.rst b/Doc/c-api/typeobj.rst
@@ -710,7 +710,7 @@ and :c:type:`PyType_Type` effectively act as defaults.)
 
    .. warning::
 
-      It is not recommended for :ref:`heap types <heap-types>` to implement
+      It is not recommended for :ref:`mutable heap types <heap-types>` to implement
       the vectorcall protocol.
       When a user sets :attr:`__call__` in Python code, only *tp_call* is updated,
       likely making it inconsistent with the vectorcall function.
@@ -734,8 +734,9 @@ and :c:type:`PyType_Type` effectively act as defaults.)
    always inherited. If it's not, then the subclass won't use
    :ref:`vectorcall <vectorcall>`, except when
    :c:func:`PyVectorcall_Call` is explicitly called.
-   This is in particular the case for :ref:`heap types <heap-types>`
-   (including subclasses defined in Python).
+   This is in particular the case for types without the
+   :const:`Py_TPFLAGS_IMMUTABLETYPE` flag set (including subclasses defined in
+   Python).
 
 
 .. c:member:: getattrfunc PyTypeObject.tp_getattr
@@ -1125,9 +1126,9 @@ and :c:type:`PyType_Type` effectively act as defaults.)
 
       **Inheritance:**
 
-      This flag is never inherited by :ref:`heap types <heap-types>`.
-      For extension types, it is inherited whenever
-      :c:member:`~PyTypeObject.tp_descr_get` is inherited.
+      This flag is never inherited by types without the
+      :const:`Py_TPFLAGS_IMMUTABLETYPE` flag set.  For extension types, it is
+      inherited whenever :c:member:`~PyTypeObject.tp_descr_get` is inherited.
 
 
    .. XXX Document more flags here?
@@ -1172,9 +1173,9 @@ and :c:type:`PyType_Type` effectively act as defaults.)
 
       **Inheritance:**
 
-      This bit is inherited for :ref:`static subtypes <static-types>` if
+      This bit is inherited for types with the
+      :const:`Py_TPFLAGS_IMMUTABLETYPE` flag set, if
       :c:member:`~PyTypeObject.tp_call` is also inherited.
-      :ref:`Heap types <heap-types>` do not inherit ``Py_TPFLAGS_HAVE_VECTORCALL``.
 
       .. versionadded:: 3.9
 
diff --git a/Doc/whatsnew/3.11.rst b/Doc/whatsnew/3.11.rst
@@ -214,6 +214,11 @@ Porting to Python 3.11
   (:c:member:`PyTypeObject.tp_traverse`).
   (Contributed by Victor Stinner in :issue:`44263`.)
 
+* Heap types with the :const:`Py_TPFLAGS_IMMUTABLETYPE` flag can now inherit
+  the :pep:`590` vectorcall protocol.  Previously, this was only possible for
+  :ref:`static types <static-types>`.
+  (Contributed by Erlend E. Aasland in :issue:`43908`)
+
 Deprecated
 ----------
 
diff --git a/Lib/test/test_call.py b/Lib/test/test_call.py
@@ -563,7 +563,7 @@ def test_method_descriptor_flag(self):
         self.assertTrue(_testcapi.MethodDescriptorDerived.__flags__ & Py_TPFLAGS_METHOD_DESCRIPTOR)
         self.assertFalse(_testcapi.MethodDescriptorNopGet.__flags__ & Py_TPFLAGS_METHOD_DESCRIPTOR)
 
-        # Heap type should not inherit Py_TPFLAGS_METHOD_DESCRIPTOR
+        # Mutable heap types should not inherit Py_TPFLAGS_METHOD_DESCRIPTOR
         class MethodDescriptorHeap(_testcapi.MethodDescriptorBase):
             pass
         self.assertFalse(MethodDescriptorHeap.__flags__ & Py_TPFLAGS_METHOD_DESCRIPTOR)
@@ -574,7 +574,7 @@ def test_vectorcall_flag(self):
         self.assertFalse(_testcapi.MethodDescriptorNopGet.__flags__ & Py_TPFLAGS_HAVE_VECTORCALL)
         self.assertTrue(_testcapi.MethodDescriptor2.__flags__ & Py_TPFLAGS_HAVE_VECTORCALL)
 
-        # Heap type should not inherit Py_TPFLAGS_HAVE_VECTORCALL
+        # Mutable heap types should not inherit Py_TPFLAGS_HAVE_VECTORCALL
         class MethodDescriptorHeap(_testcapi.MethodDescriptorBase):
             pass
         self.assertFalse(MethodDescriptorHeap.__flags__ & Py_TPFLAGS_HAVE_VECTORCALL)
diff --git a/Misc/NEWS.d/next/Core and Builtins/2021-07-03-00-20-39.bpo-43908.YHuV_s.rst b/Misc/NEWS.d/next/Core and Builtins/2021-07-03-00-20-39.bpo-43908.YHuV_s.rst
@@ -0,0 +1,3 @@
+Heap types with the :const:`Py_TPFLAGS_IMMUTABLETYPE` flag can now inherit the
+:pep:`590` vectorcall protocol.  Previously, this was only possible for
+:ref:`static types <static-types>`.  Patch by Erlend E. Aasland.
diff --git a/Objects/typeobject.c b/Objects/typeobject.c
@@ -5881,8 +5881,8 @@ inherit_slots(PyTypeObject *type, PyTypeObject *base)
         /* Inherit Py_TPFLAGS_HAVE_VECTORCALL for non-heap types
         * if tp_call is not overridden */
         if (!type->tp_call &&
-            (base->tp_flags & Py_TPFLAGS_HAVE_VECTORCALL) &&
-            !(type->tp_flags & Py_TPFLAGS_HEAPTYPE))
+            _PyType_HasFeature(base, Py_TPFLAGS_HAVE_VECTORCALL) &&
+            _PyType_HasFeature(type, Py_TPFLAGS_IMMUTABLETYPE))
         {
             type->tp_flags |= Py_TPFLAGS_HAVE_VECTORCALL;
         }
@@ -5915,8 +5915,8 @@ inherit_slots(PyTypeObject *type, PyTypeObject *base)
          * but only for extension types */
         if (base->tp_descr_get &&
             type->tp_descr_get == base->tp_descr_get &&
-            !(type->tp_flags & Py_TPFLAGS_HEAPTYPE) &&
-            (base->tp_flags & Py_TPFLAGS_METHOD_DESCRIPTOR))
+            _PyType_HasFeature(type, Py_TPFLAGS_IMMUTABLETYPE) &&
+            _PyType_HasFeature(base, Py_TPFLAGS_METHOD_DESCRIPTOR))
         {
             type->tp_flags |= Py_TPFLAGS_METHOD_DESCRIPTOR;
         }

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	+Heap types with the :const:`Py_TPFLAGS_IMMUTABLETYPE` flag can now inherit the
	`2`	+:pep:`590` vectorcall protocol. Previously, this was only possible for
	`3`	+:ref:`static types <static-types>`. Patch by Erlend E. Aasland.
Original file line number	Diff line number	Diff line change
`@@ -5881,8 +5881,8 @@ inherit_slots(PyTypeObject type, PyTypeObject base)`
`5881`	`5881`	`/* Inherit Py_TPFLAGS_HAVE_VECTORCALL for non-heap types`
`5882`	`5882`	`* if tp_call is not overridden */`
`5883`	`5883`	`if (!type->tp_call &&`
`5884`		`- (base->tp_flags & Py_TPFLAGS_HAVE_VECTORCALL) &&`
`5885`		`- !(type->tp_flags & Py_TPFLAGS_HEAPTYPE))`
	`5884`	`+ _PyType_HasFeature(base, Py_TPFLAGS_HAVE_VECTORCALL) &&`
	`5885`	`+ _PyType_HasFeature(type, Py_TPFLAGS_IMMUTABLETYPE))`
`5886`	`5886`	`{`
`5887`	`5887`	`type->tp_flags \|= Py_TPFLAGS_HAVE_VECTORCALL;`
`5888`	`5888`	`}`
`@@ -5915,8 +5915,8 @@ inherit_slots(PyTypeObject type, PyTypeObject base)`
`5915`	`5915`	`* but only for extension types */`
`5916`	`5916`	`if (base->tp_descr_get &&`
`5917`	`5917`	`type->tp_descr_get == base->tp_descr_get &&`
`5918`		`- !(type->tp_flags & Py_TPFLAGS_HEAPTYPE) &&`
`5919`		`- (base->tp_flags & Py_TPFLAGS_METHOD_DESCRIPTOR))`
	`5918`	`+ _PyType_HasFeature(type, Py_TPFLAGS_IMMUTABLETYPE) &&`
	`5919`	`+ _PyType_HasFeature(base, Py_TPFLAGS_METHOD_DESCRIPTOR))`
`5920`	`5920`	`{`
`5921`	`5921`	`type->tp_flags \|= Py_TPFLAGS_METHOD_DESCRIPTOR;`
`5922`	`5922`	`}`