Support native subtypes in the tuple constructor.

Author: fangerer

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

@@ -303,6 +303,11 @@ Py_ssize_t get_tp_basicsize(PyTypeObject* obj) {
 	return obj->tp_basicsize;
 }
 
+/** to be used from Java code only; reads native 'tp_alloc' field */
+allocfunc get_tp_alloc(PyTypeObject* obj) {
+	return obj->tp_alloc;
+}
+
 /** to be used from Java code only; returns the type ID for a byte array */
 polyglot_typeid get_byte_array_typeid(uint64_t len) {
     return polyglot_array_typeid(polyglot_i8_typeid(), len);

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

@@ -79,3 +79,36 @@ PyObject* PyTuple_Pack(Py_ssize_t n, ...) {
     }
     return result;
 }
+
+MUST_INLINE
+static PyObject * tuple_create(PyObject *iterable) {
+    if (iterable == NULL) {
+        return PyTuple_New(0);
+    }
+    return PySequence_Tuple(iterable);
+}
+
+PyObject * tuple_subtype_new(PyTypeObject *type, PyObject *iterable) {
+    PyObject *tmp, *newobj, *item;
+    Py_ssize_t i, n;
+
+    assert(PyType_IsSubtype(type, &PyTuple_Type));
+    tmp = tuple_create(iterable);
+    if (tmp == NULL) {
+        return NULL;
+    }
+    assert(PyTuple_Check(tmp));
+    n = PyTuple_GET_SIZE(tmp);
+
+    newobj = type->tp_alloc(type, n);
+    if (newobj == NULL) {
+        return NULL;
+    }
+    for (i = 0; i < n; i++) {
+        item = PyTuple_GetItem(tmp, i);
+        Py_INCREF(item);
+        PyTuple_SetItem(newobj, i, item);
+    }
+    Py_DECREF(tmp);
+    return newobj;
+}

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

@@ -1818,16 +1818,27 @@ private ConditionProfile getIsPStringProfile() {
     @GenerateNodeFactory
     public abstract static class TupleNode extends PythonBinaryBuiltinNode {
 
-        @Specialization
-        protected PTuple constructTuple(VirtualFrame frame, LazyPythonClass cls, Object value,
+        @Specialization(guards = "!isNativeClass(cls)")
+        protected PTuple constructTuple(VirtualFrame frame, LazyPythonClass cls, Object iterable,
                         @Cached("create()") TupleNodes.ConstructTupleNode constructTupleNode) {
-            return constructTupleNode.execute(frame, cls, value);
+            return constructTupleNode.execute(frame, cls, iterable);
+        }
+
+        // delegate to tuple_subtype_new(PyTypeObject *type, PyObject *x)
+        @Specialization(guards = "isSubtypeOfTuple(frame, isSubtype, cls)", limit = "1")
+        Object doNative(@SuppressWarnings("unused") VirtualFrame frame, PythonNativeClass cls, Object iterable,
+                        @Cached @SuppressWarnings("unused") IsSubtypeNode isSubtype,
+                        @Cached CExtNodes.TupleSubtypeNew subtypeNew) {
+            return subtypeNew.execute(cls, iterable);
+        }
+
+        protected static boolean isSubtypeOfTuple(VirtualFrame frame, IsSubtypeNode isSubtypeNode, PythonNativeClass cls) {
+            return isSubtypeNode.execute(frame, cls, PythonBuiltinClassType.PTuple);
         }
 
         @Fallback
-        public PTuple tupleObject(@SuppressWarnings("unused") Object cls, Object arg) {
-            CompilerAsserts.neverPartOfCompilation();
-            throw new RuntimeException("tuple does not support iterable object " + arg);
+        public PTuple tupleObject(Object cls, @SuppressWarnings("unused") Object arg) {
+            throw raise(PythonBuiltinClassType.TypeError, "'cls' is not a type object (%p)", cls);
         }
     }
 

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/cext/CExtNodes.java

@@ -259,6 +259,17 @@ public static FloatSubtypeNew create() {
         }
     }
 
+    public abstract static class TupleSubtypeNew extends SubtypeNew {
+        @Override
+        protected final String getTypenamePrefix() {
+            return "tuple";
+        }
+
+        public static TupleSubtypeNew create() {
+            return CExtNodesFactory.TupleSubtypeNewNodeGen.create();
+        }
+    }
+
     // -----------------------------------------------------------------------------------------------------------------
     public abstract static class FromNativeSubclassNode extends CExtBaseNode {
 

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/type/TypeBuiltins.java

@@ -36,6 +36,7 @@
 import static com.oracle.graal.python.nodes.SpecialAttributeNames.__MRO__;
 import static com.oracle.graal.python.nodes.SpecialAttributeNames.__NAME__;
 import static com.oracle.graal.python.nodes.SpecialAttributeNames.__QUALNAME__;
+import static com.oracle.graal.python.nodes.SpecialMethodNames.__ALLOC__;
 import static com.oracle.graal.python.nodes.SpecialMethodNames.__CALL__;
 import static com.oracle.graal.python.nodes.SpecialMethodNames.__DELETE__;
 import static com.oracle.graal.python.nodes.SpecialMethodNames.__GETATTRIBUTE__;
@@ -78,6 +79,7 @@
 import com.oracle.graal.python.builtins.objects.type.TypeNodes.GetSubclassesNode;
 import com.oracle.graal.python.nodes.PGuards;
 import com.oracle.graal.python.nodes.SpecialAttributeNames;
+import com.oracle.graal.python.nodes.SpecialMethodNames;
 import com.oracle.graal.python.nodes.argument.positional.PositionalArgumentsNode;
 import com.oracle.graal.python.nodes.attributes.GetAttributeNode.GetFixedAttributeNode;
 import com.oracle.graal.python.nodes.attributes.LookupAttributeInMRONode;
@@ -123,6 +125,7 @@ public class TypeBuiltins extends PythonBuiltins {
     public static final HiddenKey TYPE_DICTOFFSET = new HiddenKey(__DICTOFFSET__);
     public static final HiddenKey TYPE_ITEMSIZE = new HiddenKey(__ITEMSIZE__);
     public static final HiddenKey TYPE_BASICSIZE = new HiddenKey(__BASICSIZE__);
+    public static final HiddenKey TYPE_ALLOC = new HiddenKey(__ALLOC__);
 
     @Override
     protected List<? extends NodeFactory<? extends PythonBuiltinBaseNode>> getNodeFactories() {
@@ -887,4 +890,42 @@ Object flags(PythonAbstractClass self) {
             return getFlagsNode.execute(self);
         }
     }
+
+    @Builtin(name = __ALLOC__, minNumOfPositionalArgs = 1, maxNumOfPositionalArgs = 2, isGetter = true, isSetter = true)
+    abstract static class AllocNode extends AbstractSlotNode {
+
+        @Specialization(guards = "isNoValue(value)")
+        Object getAlloc(PythonManagedClass cls, @SuppressWarnings("unused") PNone value,
+                        @Cached("create()") IsBuiltinClassProfile profile,
+                        @Cached("create()") ReadAttributeFromObjectNode getName) {
+            // recursion anchor; since the metaclass of 'type' is 'type'
+            if (profile.profileClass(cls, PythonBuiltinClassType.PythonClass)) {
+                return getName.execute(cls, TYPE_ALLOC);
+            }
+            return getName.execute(cls, __ALLOC__);
+        }
+
+        @Specialization(guards = "!isNoValue(value)")
+        Object setName(@SuppressWarnings("unused") PythonBuiltinClass cls, @SuppressWarnings("unused") Object value) {
+            throw raise(PythonErrorType.RuntimeError, "can't set attributes of built-in/extension 'type'");
+        }
+
+        @Specialization(guards = {"!isNoValue(value)", "!isPythonBuiltinClass(cls)"})
+        Object setName(PythonClass cls, Object value,
+                        @Cached WriteAttributeToObjectNode setName) {
+            return setName.execute(cls, __ALLOC__, value);
+        }
+
+        @Specialization(guards = "isNoValue(value)")
+        Object getNative(PythonNativeClass cls, @SuppressWarnings("unused") PNone value,
+                        @Cached("create()") GetTypeMemberNode getTpAllocNode) {
+            return getTpAllocNode.execute(cls, NativeMemberNames.TP_ALLOC);
+        }
+
+        @Specialization(guards = "!isNoValue(value)")
+        Object setNative(@SuppressWarnings("unused") PythonAbstractNativeObject cls, @SuppressWarnings("unused") Object value) {
+            throw raise(PythonErrorType.RuntimeError, "can't set attributes of native type");
+        }
+    }
+
 }