Compute correct named/unnamed member count

Author: fangerer

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

@@ -43,6 +43,8 @@
 #define REAL_SIZE_TP(tp) PyLong_AsSsize_t(PyDict_GetItem((tp)->tp_dict, polyglot_from_string("n_fields", SRC_CS)))
 #define REAL_SIZE(op) REAL_SIZE_TP(Py_TYPE(op))
 
+char *PyStructSequence_UnnamedField = "unnamed field";
+
 static void
 structseq_dealloc(PyStructSequence *obj)
 {
@@ -61,10 +63,23 @@ PyObject* PyStructSequence_New(PyTypeObject* o) {
     return UPCALL_CEXT_O(_jls_PyStructSequence_New, native_type_to_java(o));
 }
 
-typedef int (*structseq_init_fun_t)(void *, void *, void *, void *, void *);
+static Py_ssize_t
+count_members(PyStructSequence_Desc *desc, Py_ssize_t *n_unnamed_members) {
+    Py_ssize_t i;
+
+    *n_unnamed_members = 0;
+    for (i = 0; desc->fields[i].name != NULL; ++i) {
+        if (desc->fields[i].name == PyStructSequence_UnnamedField) {
+            (*n_unnamed_members)++;
+        }
+    }
+    return i;
+}
+
+typedef int (*structseq_init_fun_t)(void *, void *, void *, void *, void *, int);
 UPCALL_TYPED_ID(PyStructSequence_InitType2, structseq_init_fun_t);
 int PyStructSequence_InitType2(PyTypeObject *type, PyStructSequence_Desc *desc) {
-    Py_ssize_t n_members = desc->n_in_sequence;
+    Py_ssize_t n_members, n_unnamed_members, n_named_members;
     Py_ssize_t i;
 
     memset(type, 0, sizeof(PyTypeObject));
@@ -74,36 +89,41 @@ int PyStructSequence_InitType2(PyTypeObject *type, PyStructSequence_Desc *desc)
     type->tp_name = desc->name;
     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_doc = desc->doc;
     type->tp_base = &PyTuple_Type;
-    //type->tp_alloc = newType->tp_alloc;
     type->tp_dealloc = (destructor)structseq_dealloc;
 
     // now initialize the type
     if (PyType_Ready(type) < 0)
         return -1;
     Py_INCREF(type);
 
+    n_members = count_members(desc, &n_unnamed_members);
+    n_named_members = n_members - n_unnamed_members;
     // put field names and doc strings into two lists
-    void** field_names = (void **) truffle_managed_malloc(n_members * sizeof(void *));
-    void** field_docs = (void **) truffle_managed_malloc(n_members * sizeof(void *));
+    void** field_names = (void **) truffle_managed_malloc(n_named_members * sizeof(void *));
+    void** field_docs = (void **) truffle_managed_malloc(n_named_members * sizeof(void *));
     PyStructSequence_Field* fields = desc->fields;
+    int j = 0;
     for (i = 0; i < n_members; i++) {
-        field_names[i] = polyglot_from_string(fields[i].name, SRC_CS);
-        field_docs[i] = polyglot_from_string(fields[i].doc, SRC_CS);
+        if (fields[i].name != PyStructSequence_UnnamedField) {
+            field_names[j] = polyglot_from_string(fields[i].name, SRC_CS);
+            field_docs[j] = polyglot_from_string(fields[i].doc, SRC_CS);
+            j++;
+        }
     }
 
     // this initializes the type dict (adds attributes)
     return _jls_PyStructSequence_InitType2(
             native_type_to_java(type),
             polyglot_from_string(desc->name, SRC_CS),
             polyglot_from_string(desc->doc, SRC_CS),
-            polyglot_from_PyObjectPtr_array(field_names, n_members),
-            polyglot_from_PyObjectPtr_array(field_docs, n_members)
+            /* TODO(fa): use polyglot_from_VoidPtr_array once this is visible */
+            polyglot_from_PyObjectPtr_array((PyObjectPtr *) field_names, (uint64_t) n_members),
+            polyglot_from_PyObjectPtr_array((PyObjectPtr *) field_docs, (uint64_t) n_members),
+            desc->n_in_sequence
     );
 }
 

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/PythonCextBuiltins.java

@@ -4014,31 +4014,34 @@ public void call(@SuppressWarnings("unused") PythonContext context) {
     }
 
     // directly called without landing function
-    @Builtin(name = "PyStructSequence_InitType2", minNumOfPositionalArgs = 5)
+    @Builtin(name = "PyStructSequence_InitType2", minNumOfPositionalArgs = 6)
     @GenerateNodeFactory
     abstract static class PyStructSequenceInitType2 extends NativeBuiltin {
 
         @Specialization(limit = "1")
-        static int doGeneric(Object klass, String typeName, String typeDoc, Object fieldNamesObj, Object fieldDocsObj,
+        static int doGeneric(Object klass, String typeName, String typeDoc, Object fieldNamesObj, Object fieldDocsObj, int nInSequence,
                         @CachedLanguage PythonLanguage language,
                         @CachedLibrary("fieldNamesObj") InteropLibrary lib,
-                        @Cached(parameters = "true") WriteAttributeToObjectNode clearNewNode) {
+                        @Cached(parameters = "true") WriteAttributeToObjectNode clearNewNode,
+                        @Cached PRaiseNativeNode raiseNode) {
             // 'fieldNames' and 'fieldDocs' must be of same type; they share the interop lib
             assert fieldNamesObj.getClass() == fieldDocsObj.getClass();
 
             try {
-                if (lib.hasArrayElements(fieldNamesObj) && lib.hasArrayElements(fieldDocsObj)) {
-                    int n = PInt.intValueExact(lib.getArraySize(fieldNamesObj));
-                    String[] fieldNames = new String[n];
-                    String[] fieldDocs = new String[n];
-                    for (int i = 0; i < n; i++) {
-                        fieldNames[i] = cast(lib.readArrayElement(fieldNamesObj, i));
-                        fieldDocs[i] = cast(lib.readArrayElement(fieldDocsObj, i));
-                    }
-                    clearNewNode.execute(klass, __NEW__, PNone.NO_VALUE);
-                    StructSequenceDescriptor d = new StructSequenceDescriptor(typeName, typeDoc, 0, fieldNames, fieldDocs);
-                    StructSequence.initType(language, klass, d);
+                int n = PInt.intValueExact(lib.getArraySize(fieldNamesObj));
+                if (n != lib.getArraySize(fieldDocsObj)) {
+                    // internal error: the C function must type the object correctly
+                    throw CompilerDirectives.shouldNotReachHere("len(fieldNames) != len(fieldDocs)");
+                }
+                String[] fieldNames = new String[n];
+                String[] fieldDocs = new String[n];
+                for (int i = 0; i < n; i++) {
+                    fieldNames[i] = cast(lib.readArrayElement(fieldNamesObj, i));
+                    fieldDocs[i] = cast(lib.readArrayElement(fieldDocsObj, i));
                 }
+                clearNewNode.execute(klass, __NEW__, PNone.NO_VALUE);
+                StructSequenceDescriptor d = new StructSequenceDescriptor(typeName, typeDoc, nInSequence, fieldNames, fieldDocs);
+                StructSequence.initType(language, klass, d);
                 return 0;
             } catch (UnsupportedMessageException | InvalidArrayIndexException e) {
                 throw CompilerDirectives.shouldNotReachHere();