Enable multi-inheritance in 'PyType_Ready'.

fangerer · fangerer · commit 34971b1feebb · 2018-05-15T10:19:25.000+02:00
diff --git a/graalpython/com.oracle.graal.python.cext/src/capi.c b/graalpython/com.oracle.graal.python.cext/src/capi.c
@@ -382,4 +382,3 @@ int PyTruffle_Debug(void *arg) {
 	truffle_invoke(PY_TRUFFLE_CEXT, "PyTruffle_Debug", arg);
 	return 0;
 }
-
diff --git a/graalpython/com.oracle.graal.python.cext/src/object.c b/graalpython/com.oracle.graal.python.cext/src/object.c
@@ -162,6 +162,15 @@ Py_ssize_t PyObject_Size(PyObject *o) {
     return truffle_invoke_i(PY_TRUFFLE_CEXT, "PyObject_Size", to_java(o));
 }
 
+static int add_subclass(PyTypeObject *base, PyTypeObject *type) {
+	void* result = polyglot_invoke(PY_TRUFFLE_CEXT, "PyTruffle_Add_Subclass", to_java(base->tp_subclasses), to_java(PyLong_FromVoidPtr(type)), to_java((PyObject*)type));
+	if (result == ERROR_MARKER) {
+		return -1;
+	}
+	base->tp_subclasses = to_sulong(result);
+	return 0;
+}
+
 int PyType_Ready(PyTypeObject* cls) {
 #define ADD_IF_MISSING(attr, def) if (!(attr)) { attr = def; }
 #define ADD_METHOD(m) ADD_METHOD_OR_SLOT(m.ml_name, m.ml_meth, m.ml_flags, m.ml_doc)
@@ -205,13 +214,29 @@ int PyType_Ready(PyTypeObject* cls) {
         cls->tp_doc = "";
     }
 
+    /* Initialize tp_bases */
+    PyObject* bases = cls->tp_bases;
+    if (bases == NULL) {
+        if (base == NULL) {
+            bases = PyTuple_New(0);
+        } else {
+            bases = PyTuple_Pack(1, base);
+        }
+        if (bases == NULL) {
+        	cls->tp_flags &= ~Py_TPFLAGS_READYING;
+        	return -1;
+        }
+        cls->tp_bases = bases;
+    }
+
+
     PyTypeObject* javacls = truffle_invoke(PY_TRUFFLE_CEXT,
                                            "PyType_Ready",
                                            // no conversion of cls here, because we
                                            // store this into the PyTypeObject
                                            cls,
                                            to_java_type(metaclass),
-                                           to_java_type(base),
+                                           to_java(bases),
                                            truffle_read_string(cls->tp_name),
                                            truffle_read_string(cls->tp_doc ? cls->tp_doc : ""));
     if (polyglot_is_value(javacls)) {
@@ -382,6 +407,18 @@ int PyType_Ready(PyTypeObject* cls) {
         // TODO ...
     }
 
+    /* Link into each base class's list of subclasses */
+    bases = cls->tp_bases;
+    Py_ssize_t n = PyTuple_GET_SIZE(bases);
+    Py_ssize_t i;
+    for (i = 0; i < n; i++) {
+        PyTypeObject *b = polyglot_as__typeobject(PyTuple_GET_ITEM(bases, i));
+        if (PyType_Check(b) && add_subclass((PyTypeObject *)b, cls) < 0) {
+        	cls->tp_flags &= ~Py_TPFLAGS_READYING;
+        	return -1;
+        }
+    }
+
     // done
     cls->tp_flags = cls->tp_flags & ~Py_TPFLAGS_READYING;
     cls->tp_flags = cls->tp_flags | Py_TPFLAGS_READY;
diff --git a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/TruffleCextBuiltins.java b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/TruffleCextBuiltins.java
@@ -493,15 +493,21 @@ abstract static class PyType_ReadyNode extends PythonBuiltinNode {
         @Child WriteAttributeToObjectNode writeNode = WriteAttributeToObjectNode.create();
 
         @Specialization
-        PythonClass run(TruffleObject typestruct, PythonClass metaClass, PythonClass baseClass, String name, String doc) {
-            PythonClass cclass = factory().createNativeClassWrapper(typestruct, metaClass, name, new PythonClass[]{baseClass});
+        PythonClass run(TruffleObject typestruct, PythonClass metaClass, PTuple baseClasses, String name, String doc) {
+            Object[] array = baseClasses.getArray();
+            PythonClass[] bases = new PythonClass[array.length];
+            for (int i = 0; i < array.length; i++) {
+                bases[i] = (PythonClass) array[i];
+            }
+
+            PythonClass cclass = factory().createNativeClassWrapper(typestruct, metaClass, name, bases);
             writeNode.execute(cclass, SpecialAttributeNames.__DOC__, doc);
             return cclass;
         }
 
         @Specialization
-        PythonClass run(TruffleObject typestruct, PythonClass metaClass, PythonClass baseClass, PString name, PString doc) {
-            return run(typestruct, metaClass, baseClass, name.getValue(), doc.getValue());
+        PythonClass run(TruffleObject typestruct, PythonClass metaClass, PTuple baseClasses, PString name, PString doc) {
+            return run(typestruct, metaClass, baseClasses, name.getValue(), doc.getValue());
         }
     }
 
diff --git a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/cext/NativeMemberNames.java b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/cext/NativeMemberNames.java
@@ -50,6 +50,7 @@ public abstract class NativeMemberNames {
     public static final String TP_AS_NUMBER = "tp_as_number";
     public static final String TP_HASH = "tp_hash";
     public static final String TP_RICHCOMPARE = "tp_richcompare";
+    public static final String TP_SUBCLASSES = "tp_subclasses";
     public static final String _BASE = "_base";
     public static final String OB_ITEM = "ob_item";
     public static final String MA_USED = "ma_used";
@@ -76,6 +77,7 @@ public static boolean isValid(String key) {
             case TP_AS_NUMBER:
             case TP_HASH:
             case TP_RICHCOMPARE:
+            case TP_SUBCLASSES:
             case _BASE:
             case OB_ITEM:
             case MA_USED:
diff --git a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/cext/PythonObjectNativeWrapperMR.java b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/cext/PythonObjectNativeWrapperMR.java
@@ -65,6 +65,7 @@
 import com.oracle.graal.python.runtime.sequence.PSequence;
 import com.oracle.truffle.api.CompilerDirectives;
 import com.oracle.truffle.api.CompilerDirectives.CompilationFinal;
+import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
 import com.oracle.truffle.api.dsl.Cached;
 import com.oracle.truffle.api.dsl.Fallback;
 import com.oracle.truffle.api.dsl.ImportStatic;
@@ -205,6 +206,12 @@ Object doTpRichcompare(PythonClass object, @SuppressWarnings("unused") String ke
             return getToSulongNode().execute(getCmpNode.execute(object, SpecialMethodNames.RICHCMP));
         }
 
+        @Specialization(guards = "eq(TP_SUBCLASSES, key)")
+        Object doTpSubclasses(@SuppressWarnings("unused") PythonClass object, @SuppressWarnings("unused") String key) {
+            // TODO create dict view on subclasses set
+            return PythonObjectNativeWrapper.wrap(factory().createDict());
+        }
+
         @Specialization(guards = "eq(OB_ITEM, key)")
         Object doObItem(PSequence object, @SuppressWarnings("unused") String key) {
             return new PySequenceArrayWrapper(object);
@@ -302,6 +309,17 @@ long doTpFlags(PythonClass object, @SuppressWarnings("unused") String key, long
             return flags;
         }
 
+        @Specialization(guards = "eq(TP_SUBCLASSES, key)")
+        @TruffleBoundary
+        Object doTpSubclasses(PythonClass object, @SuppressWarnings("unused") String key, PythonObjectNativeWrapper value) {
+            // TODO more type checking; do fast path
+            PDict dict = (PDict) value.getPythonObject();
+            for (Object item : dict.items()) {
+                object.getSubClasses().add((PythonClass) item);
+            }
+            return value;
+        }
+
         @Fallback
         Object doGeneric(Object object, Object key, @SuppressWarnings("unused") Object value) {
             CompilerDirectives.transferToInterpreter();
diff --git a/graalpython/lib-graalpython/python_cext.py b/graalpython/lib-graalpython/python_cext.py
@@ -684,6 +684,14 @@ def PyType_IsSubtype(a, b):
     return b in a.mro()
 
 
+@may_raise
+def PyTruffle_Add_Subclass(bases_dict, key, cls):
+    if not bases_dict:
+        bases_dict = dict()
+    bases_dict[key] = cls
+    return bases_dict
+
+
 def PyTuple_New(size):
     return (None,) * size
 

Original file line number	Diff line number	Diff line change
`@@ -382,4 +382,3 @@ int PyTruffle_Debug(void *arg) {`
`382`	`382`	`truffle_invoke(PY_TRUFFLE_CEXT, "PyTruffle_Debug", arg);`
`383`	`383`	`return 0;`
`384`	`384`	`}`
`385`		`-`