Few adjustments

Author: qunaibit

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

@@ -1728,30 +1728,35 @@ public static GetTypeMemberNode getUncached() {
      * Use this node to lookup a native type member like {@code tp_alloc}.<br>
      * <p>
      * This node basically implements the native member inheritance that is done by
-     * {@code inherit_special} or other code in {@code PyType_Ready}.
+     * {@code inherit_special} or other code in {@code PyType_Ready}. In addition, we do a special
+     * case for special slots assignment that happens within {@Code type_new_alloc} for heap types.
      * </p>
      * <p>
      * Since it may be that a managed types needs to emulate such members but there is no
-     * corresponding Python attribute (e.g. {@code tp_alloc}), such members are stored as hidden
-     * keys on the managed type. However, the MRO may contain native types and in this case, we need
-     * to access the native member.
+     * corresponding Python attribute (e.g. {@code tp_vectorcall_offset}), such members are stored
+     * as hidden keys on the managed type. However, the MRO may contain native types and in this
+     * case, we need to access the native member.
      * </p>
      */
     @GenerateUncached
     public abstract static class LookupNativeMemberInMRONode extends Node {
 
         public abstract Object execute(Object cls, NativeMember nativeMemberName, HiddenKey managedMemberName);
 
-        static boolean isTpAlloc(Object cls, HiddenKey key) {
-            return cls instanceof PythonClass && key == TypeBuiltins.TYPE_ALLOC;
+        static boolean isSpecialHeapSlot(Object cls, HiddenKey key) {
+            return cls instanceof PythonClass && (key == TypeBuiltins.TYPE_ALLOC || key == TypeBuiltins.TYPE_DEL);
+            // mq: not supported yet
+            // key == TypeBuiltins.TYPE_DEALLOC (subtype_dealloc)
+            // key == TypeBuiltins.TYPE_TRAVERSE (subtype_traverse)
+            // key == TypeBuiltins.TYPE_CLEAR (subtype_clear)
         }
 
-        @Specialization(guards = "!isTpAlloc(cls, managedMemberName)")
+        @Specialization(guards = "!isSpecialHeapSlot(cls, managedMemberName)")
         static Object doSingleContext(Object cls, NativeMember nativeMemberName, HiddenKey managedMemberName,
-                                      @Cached GetMroStorageNode getMroNode,
-                                      @Cached SequenceStorageNodes.GetItemDynamicNode getItemNode,
-                                      @Cached("createForceType()") ReadAttributeFromObjectNode readAttrNode,
-                                      @Cached GetTypeMemberNode getTypeMemberNode) {
+                        @Cached GetMroStorageNode getMroNode,
+                        @Cached SequenceStorageNodes.GetItemDynamicNode getItemNode,
+                        @Cached("createForceType()") ReadAttributeFromObjectNode readAttrNode,
+                        @Cached GetTypeMemberNode getTypeMemberNode) {
 
             MroSequenceStorage mroStorage = getMroNode.execute(cls);
             int n = mroStorage.length();
@@ -1774,19 +1779,31 @@ static Object doSingleContext(Object cls, NativeMember nativeMemberName, HiddenK
             return readAttrNode.execute(PythonContext.get(readAttrNode).lookupType(PythonBuiltinClassType.PythonObject), managedMemberName);
         }
 
-        @Specialization(guards = "isTpAlloc(cls, managedMemberName)")
-        static Object doToAllocManaged(Object cls, @SuppressWarnings("unused") NativeMember nativeMemberName, HiddenKey managedMemberName,
-                        @Cached("createForceType()") ReadAttributeFromObjectNode readAttrNode,
-                        @Cached WriteAttributeToObjectNode writeAttrNode) {
+        @TruffleBoundary
+        static Object createSpecialHeapSlot(Object cls, HiddenKey managedMemberName, Node node) {
+            Object func;
+            if (managedMemberName == TypeBuiltins.TYPE_ALLOC || managedMemberName == TypeBuiltins.TYPE_DEL) {
+                PythonObject object = PythonContext.get(null).lookupType(PythonBuiltinClassType.PythonObject);
+                // We need to point to PyType_GenericAlloc or PyObject_GC_Del
+                func = ReadAttributeFromObjectNode.getUncachedForceType().execute(object, managedMemberName);
+                WriteAttributeToObjectNode.getUncached().execute(cls, managedMemberName, func);
+            } else {
+                // managedMemberName == TypeBuiltins.TYPE_DEALLOC
+                // managedMemberName == TypeBuiltins.TYPE_CLEAR
+                // managedMemberName == TypeBuiltins.TYPE_TRAVERSE
+                throw PRaiseNode.raiseUncached(node, SystemError, tsLiteral("not supported yet!"));
+            }
+            return func;
+        }
 
-            Object alloc = readAttrNode.execute(cls, managedMemberName);
-            if (alloc == PNone.NO_VALUE) {
-                PythonObject object = PythonContext.get(readAttrNode).lookupType(PythonBuiltinClassType.PythonObject);
-                Object pyTypeGenericAlloc = readAttrNode.execute(object, managedMemberName);
-                writeAttrNode.execute(cls, managedMemberName, pyTypeGenericAlloc);
-                alloc = pyTypeGenericAlloc;
+        @Specialization(guards = "isSpecialHeapSlot(cls, managedMemberName)")
+        static Object doToAllocOrDelManaged(Object cls, @SuppressWarnings("unused") NativeMember nativeMemberName, HiddenKey managedMemberName,
+                        @Cached("createForceType()") ReadAttributeFromObjectNode readAttrNode) {
+            Object func = readAttrNode.execute(cls, managedMemberName);
+            if (func == PNone.NO_VALUE) {
+                func = createSpecialHeapSlot(cls, managedMemberName, readAttrNode);
             }
-            return alloc;
+            return func;
         }
     }