Add PyStructSequence_FromModuleAndDesc() to create a new struct sequence type.

shihai1991 · shihai1991 · commit b5d770b0a239 · 2021-10-06T23:40:07.000+08:00
diff --git a/Doc/c-api/tuple.rst b/Doc/c-api/tuple.rst
@@ -119,6 +119,14 @@ objects, i.e. a sequence whose items can also be accessed through attributes.
 To create a struct sequence, you first have to create a specific struct sequence
 type.
 
+.. c:function:: PyTypeObject* PyStructSequence_FromModuleAndDesc(PyObject *module, PyStructSequence_Desc *desc, unsigned long tp_flags)
+
+   Create and return a new struct sequence type from the *desc*.
+   This function is similar to :c:func:`PyStructSequence_NewType`.
+
+   .. versionadded:: 3.11
+
+
 .. c:function:: PyTypeObject* PyStructSequence_NewType(PyStructSequence_Desc *desc)
 
    Create a new struct sequence type from the data in *desc*, described below. Instances
diff --git a/Doc/data/refcounts.dat b/Doc/data/refcounts.dat
@@ -2089,6 +2089,11 @@ PyState_FindModule:PyModuleDef*:def::
 PyState_RemoveModule:int:::
 PyState_RemoveModule:PyModuleDef*:def::
 
+PyStructSequence_FromModuleAndDesc:PyTypeObject*::+1:
+PyStructSequence_FromModuleAndDesc:PyObject*:module:+1:
+PyStructSequence_FromModuleAndDesc:PyStructSequence_Desc*:desc::
+PyStructSequence_FromModuleAndDesc:unsigned long:tp_flags::
+
 PyStructSequence_GET_ITEM:PyObject*::0:
 PyStructSequence_GET_ITEM:PyObject*:p:0:
 PyStructSequence_GET_ITEM:Py_ssize_t:pos::
diff --git a/Doc/data/stable_abi.dat b/Doc/data/stable_abi.dat
@@ -565,6 +565,7 @@ function,PyState_FindModule,3.2,
 function,PyState_RemoveModule,3.3,
 type,PyStructSequence_Desc,3.2,
 type,PyStructSequence_Field,3.2,
+function,PyStructSequence_FromModuleAndDesc,3.11,
 function,PyStructSequence_GetItem,3.2,
 function,PyStructSequence_New,3.2,
 function,PyStructSequence_NewType,3.2,
diff --git a/Doc/whatsnew/3.11.rst b/Doc/whatsnew/3.11.rst
@@ -455,6 +455,10 @@ New Features
 * Add a new :c:func:`PyType_GetQualName` function to get type's qualified name.
   (Contributed by Hai Shi in :issue:`42035`.)
 
+* Add a new :c:func:`PyStructSequence_FromModuleAndDesc` function to create
+  a new struct sequence type from the desc.
+  (Contributed by Hai Shi in :issue:`45113`.)
+
 Porting to Python 3.11
 ----------------------
 
diff --git a/Include/structseq.h b/Include/structseq.h
@@ -42,6 +42,10 @@ typedef PyTupleObject PyStructSequence;
 
 PyAPI_FUNC(void) PyStructSequence_SetItem(PyObject*, Py_ssize_t, PyObject*);
 PyAPI_FUNC(PyObject*) PyStructSequence_GetItem(PyObject*, Py_ssize_t);
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x030B0000
+PyAPI_FUNC(PyTypeObject *) PyStructSequence_FromModuleAndDesc(
+    PyObject *, PyStructSequence_Desc *, unsigned long);
+#endif
 
 #ifdef __cplusplus
 }
diff --git a/Misc/NEWS.d/next/C API/2021-09-26-23-05-34.bpo-45113.oePRV8.rst b/Misc/NEWS.d/next/C API/2021-09-26-23-05-34.bpo-45113.oePRV8.rst
@@ -0,0 +1,2 @@
+Add a new :c:func:`PyStructSequence_FromModuleAndDesc` function to create a new
+struct sequence type in heap.
diff --git a/Misc/stable_abi.txt b/Misc/stable_abi.txt
@@ -2149,6 +2149,8 @@ function PyType_GetName
     added 3.11
 function PyType_GetQualName
     added 3.11
+function PyStructSequence_FromModuleAndDesc
+    added 3.11
 
 # (Detailed comments aren't really needed for further entries: from here on
 #  we can use version control logs.)
diff --git a/Modules/_testcapimodule.c b/Modules/_testcapimodule.c
@@ -3919,6 +3919,30 @@ test_structseq_newtype_null_descr_doc(PyObject *Py_UNUSED(self),
     Py_RETURN_NONE;
 }
 
+static PyObject *
+test_structseq_newtype_from_heap(PyObject *Py_UNUSED(self),
+                                 PyObject *Py_UNUSED(args))
+{
+    PyStructSequence_Desc descr;
+    PyStructSequence_Field descr_fields[2];
+
+    descr_fields[0] = (PyStructSequence_Field){"foo", "foo value"};
+    descr_fields[1] = (PyStructSequence_Field){0, NULL};
+
+    descr.name = "_testcapi.test_descr";
+    descr.fields = descr_fields;
+    descr.doc = "This is used to test for creating a new type from heap";
+    descr.n_in_sequence = 1;
+
+    PyTypeObject* structseq_type =
+        (PyTypeObject *)PyStructSequence_FromModuleAndDesc(NULL, &descr, 0);
+    assert(structseq_type != NULL);
+    assert(PyType_Check(structseq_type));
+    Py_DECREF(structseq_type);
+
+    Py_RETURN_NONE;
+}
+
 static PyObject *
 test_incref_decref_API(PyObject *ob, PyObject *Py_UNUSED(ignored))
 {
@@ -5691,6 +5715,8 @@ static PyMethodDef TestMethods[] = {
         test_structseq_newtype_doesnt_leak, METH_NOARGS},
     {"test_structseq_newtype_null_descr_doc",
         test_structseq_newtype_null_descr_doc, METH_NOARGS},
+    {"test_structseq_newtype_from_heap",
+        test_structseq_newtype_from_heap, METH_NOARGS},
     {"test_incref_decref_API",  test_incref_decref_API,          METH_NOARGS},
     {"test_long_and_overflow",  test_long_and_overflow,          METH_NOARGS},
     {"test_long_as_double",     test_long_as_double,             METH_NOARGS},
diff --git a/Objects/structseq.c b/Objects/structseq.c
@@ -532,7 +532,9 @@ PyStructSequence_InitType(PyTypeObject *type, PyStructSequence_Desc *desc)
 }
 
 PyTypeObject *
-PyStructSequence_NewType(PyStructSequence_Desc *desc)
+PyStructSequence_FromModuleAndDesc(PyObject *module,
+                                   PyStructSequence_Desc *desc,
+                                   unsigned long tp_flags)
 {
     PyMemberDef *members;
     PyTypeObject *type;
@@ -565,14 +567,17 @@ PyStructSequence_NewType(PyStructSequence_Desc *desc)
     spec.name = desc->name;
     spec.basicsize = sizeof(PyStructSequence) - sizeof(PyObject *);
     spec.itemsize = sizeof(PyObject *);
-    spec.flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC;
+    spec.flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | tp_flags;
     spec.slots = slots;
 
-    type = (PyTypeObject *)PyType_FromSpecWithBases(&spec, (PyObject *)&PyTuple_Type);
+    type = (PyTypeObject *)PyType_FromSpecWithBases(&spec,
+        (PyObject *)&PyTuple_Type);
     PyMem_Free(members);
     if (type == NULL) {
         return NULL;
     }
+    Py_XINCREF(module);
+    ((PyHeapTypeObject *)type)->ht_module = module;
 
     if (initialize_structseq_dict(
             desc, type->tp_dict, n_members, n_unnamed_members) < 0) {
@@ -583,6 +588,12 @@ PyStructSequence_NewType(PyStructSequence_Desc *desc)
     return type;
 }
 
+PyTypeObject *
+PyStructSequence_NewType(PyStructSequence_Desc *desc)
+{
+    return PyStructSequence_FromModuleAndDesc(NULL, desc, 0);
+}
+
 int _PyStructSequence_Init(void)
 {
     if (_PyUnicode_FromId(&PyId_n_sequence_fields) == NULL
diff --git a/PC/python3dll.c b/PC/python3dll.c
@@ -519,6 +519,7 @@ EXPORT_FUNC(PySlice_Unpack)
 EXPORT_FUNC(PyState_AddModule)
 EXPORT_FUNC(PyState_FindModule)
 EXPORT_FUNC(PyState_RemoveModule)
+EXPORT_FUNC(PyStructSequence_FromModuleAndDesc)
 EXPORT_FUNC(PyStructSequence_GetItem)
 EXPORT_FUNC(PyStructSequence_New)
 EXPORT_FUNC(PyStructSequence_NewType)

Original file line number	Diff line number	Diff line change
`@@ -42,6 +42,10 @@ typedef PyTupleObject PyStructSequence;`
`42`	`42`
`43`	`43`	`PyAPI_FUNC(void) PyStructSequence_SetItem(PyObject, Py_ssize_t, PyObject);`
`44`	`44`	`PyAPI_FUNC(PyObject) PyStructSequence_GetItem(PyObject, Py_ssize_t);`
	`45`	`+#if !defined(Py_LIMITED_API) \|\| Py_LIMITED_API+0 >= 0x030B0000`
	`46`	`+PyAPI_FUNC(PyTypeObject *) PyStructSequence_FromModuleAndDesc(`
	`47`	`+ PyObject , PyStructSequence_Desc , unsigned long);`
	`48`	`+#endif`
`45`	`49`
`46`	`50`	`#ifdef __cplusplus`
`47`	`51`	`}`
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,2 @@`
	`1`	+Add a new :c:func:`PyStructSequence_FromModuleAndDesc` function to create a new
	`2`	`+struct sequence type in heap.`