Implement C API functions PyStructSequence_InitType and PyStructSequence_InitType2.

Author: fangerer

graalpython/com.oracle.graal.python.cext/src/structseq.c

@@ -40,8 +40,61 @@
  */
 #include "capi.h"
 
-/* StructSequences */
+/* StructSequences a.k.a. 'namedtuple' */
 UPCALL_ID(PyStructSequence_New);
 PyObject* PyStructSequence_New(PyTypeObject* o) {
-    return UPCALL_CEXT_O(_jls_PyStructSequence_New, native_to_java((PyObject*)o));
+    return UPCALL_CEXT_O(_jls_PyStructSequence_New, native_type_to_java(o));
 }
+
+UPCALL_ID(PyStructSequence_InitType2);
+int PyStructSequence_InitType2(PyTypeObject *type, PyStructSequence_Desc *desc) {
+    PyObject *dict;
+    PyMemberDef* members;
+    Py_ssize_t n_members, n_unnamed_members, i, k;
+    PyObject *v;
+
+    memset(type, 0, sizeof(PyTypeObject));
+
+    // put field names and doc strings into two tuples
+    PyObject* field_names = PyTuple_New(n_members);
+    PyObject* field_docs = PyTuple_New(n_members);
+    PyStructSequence_Field* fields = desc->fields;
+    for (i = 0; i < n_members; i++) {
+    	PyTuple_SetItem(field_names, i, polyglot_from_string(fields[i].name, SRC_CS));
+    	PyTuple_SetItem(field_docs, i, polyglot_from_string(fields[i].doc, SRC_CS));
+    }
+
+    // we create the new type managed
+    PyTypeObject* newType = (PyTypeObject*) UPCALL_CEXT_O(_jls_PyStructSequence_InitType2,
+    		polyglot_from_string(desc->name, SRC_CS),
+			polyglot_from_string(desc->doc, SRC_CS),
+			native_to_java(field_names),
+			native_to_java(field_docs));
+
+    // copy generic fields (CPython mem-copies a template)
+    type->tp_basicsize = sizeof(PyStructSequence) - sizeof(PyObject *);
+    type->tp_itemsize = sizeof(PyObject *);
+    type->tp_repr = newType->tp_repr;
+    type->tp_flags = Py_TPFLAGS_DEFAULT;
+    type->tp_members = NULL;
+    type->tp_new = newType->tp_new;
+    type->tp_base = &PyTuple_Type;
+
+    // now copy specific fields
+    type->tp_name = newType->tp_name;
+    type->tp_doc = newType->tp_doc;
+    type->tp_dict = newType->tp_dict;
+
+    // now initialize the type
+    if (PyType_Ready(type) < 0)
+        return -1;
+    Py_INCREF(type);
+
+    return 0;
+}
+
+// taken from CPython "Objects/structseq.c"
+void PyStructSequence_InitType(PyTypeObject *type, PyStructSequence_Desc *desc) {
+    (void)PyStructSequence_InitType2(type, desc);
+}
+

graalpython/lib-graalpython/python_cext.py

@@ -724,9 +724,23 @@ def PyModule_AddObject(m, k, v):
     return None
 
 
-from posix import stat_result
 def PyStructSequence_New(typ):
-    return stat_result([None] * stat_result.n_sequence_fields * 2)
+    return typ()
+
+
+namedtuple_type = None
+def PyStructSequence_InitType2(type_name, type_doc, field_names, field_docs):
+    assert len(field_names) == len(field_docs)
+    global namedtuple_type
+    if not namedtuple_type:
+        from collections import namedtuple as namedtuple_type
+    new_type = namedtuple_type(type_name, field_names)
+    new_type.__doc__ = type_doc
+    for i in range(len(field_names)):
+        prop = getattr(new_type, field_names[i])
+        assert isinstance(prop, property)
+        prop.__doc__ = field_docs[i]
+    return new_type
 
 
 def METH_UNSUPPORTED(fun):