Fix allocating instances of managed subclasses of native classes

Author: msimacek

graalpython/com.oracle.graal.python.test/src/tests/cpyext/test_bytes.py

@@ -619,3 +619,9 @@ def test_builtins(self):
         assert b.replace(b'e', b'a') == b'hallo'
         assert b.upper() == b'HELLO'
         assert BytesSubclass(b'a,b').split(BytesSubclass(b',')) == [b'a', b'b']
+
+    def test_managed_subclass(self):
+        class ManagedSubclass(BytesSubclass):
+            pass
+
+        assert is_native_object(ManagedSubclass(b"hello"))

graalpython/com.oracle.graal.python.test/src/tests/cpyext/test_err.py

@@ -666,6 +666,12 @@ def test_init(self):
         assert type(e) == ExceptionSubclass
         assert isinstance(e, Exception)
 
+    def test_managed_subtype(self):
+        class ManagedSubclass(ExceptionSubclass):
+            pass
+
+        assert is_native_object(ManagedSubclass())
+
     def test_raise_type(self):
         try:
             raise ExceptionSubclass

graalpython/com.oracle.graal.python.test/src/tests/cpyext/test_tuple.py

@@ -267,3 +267,9 @@ def test_builtins(self):
         assert repr(t) == "(1, 2, 3)"
         assert t.index(2) == 1
         assert t.count(2) == 1
+
+    def test_managed_sublclass(self):
+        class ManagedSubclass(TupleSubclass):
+            pass
+
+        assert is_native_object(ManagedSubclass(1, 2, 3))

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

@@ -264,12 +264,13 @@ protected static NativeCAPISymbol getFunction(String typenamePrefix) {
             return result;
         }
 
-        @Specialization(guards = "needsNativeAllocation(object)")
+        @Specialization
         Object callNativeConstructor(Object object, Object arg,
                         @Cached ToSulongNode toSulongNode,
                         @Cached NativeToPythonNode toJavaNode,
                         @CachedLibrary(limit = "1") InteropLibrary interopLibrary,
                         @Cached ImportCAPISymbolNode importCAPISymbolNode) {
+            assert TypeNodes.NeedsNativeAllocationNode.executeUncached(object);
             try {
                 Object result = interopLibrary.execute(importCAPISymbolNode.execute(getFunction()), toSulongNode.execute(object), arg);
                 return toJavaNode.execute(result);

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

@@ -52,6 +52,7 @@
 import com.oracle.graal.python.builtins.objects.traceback.PTraceback;
 import com.oracle.graal.python.builtins.objects.tuple.PTuple;
 import com.oracle.graal.python.builtins.objects.type.PythonBuiltinClass;
+import com.oracle.graal.python.builtins.objects.type.TypeNodes;
 import com.oracle.graal.python.builtins.objects.type.TypeNodes.GetNameNode;
 import com.oracle.graal.python.lib.PyExceptionInstanceCheckNode;
 import com.oracle.graal.python.nodes.PRaiseNode;
@@ -104,7 +105,7 @@ public final class PBaseException extends PythonObject {
 
     public PBaseException(Object cls, Shape instanceShape, Object[] exceptionAttributes, PTuple args) {
         super(cls, instanceShape);
-        assert !(cls instanceof PythonNativeClass);
+        assert !TypeNodes.NeedsNativeAllocationNode.executeUncached(cls);
         this.exceptionAttributes = exceptionAttributes;
         this.args = args;
         this.hasMessageFormat = false;
@@ -114,7 +115,7 @@ public PBaseException(Object cls, Shape instanceShape, Object[] exceptionAttribu
 
     public PBaseException(Object cls, Shape instanceShape, Object[] exceptionAttributes) {
         super(cls, instanceShape);
-        assertContainsNoJavaString(exceptionAttributes);
+        assert !TypeNodes.NeedsNativeAllocationNode.executeUncached(cls);
         assert !(cls instanceof PythonNativeClass);
         this.exceptionAttributes = exceptionAttributes;
         this.args = null;
@@ -125,7 +126,7 @@ public PBaseException(Object cls, Shape instanceShape, Object[] exceptionAttribu
 
     public PBaseException(Object cls, Shape instanceShape, Object[] exceptionAttributes, TruffleString format, Object[] formatArgs) {
         super(cls, instanceShape);
-        assert !(cls instanceof PythonNativeClass);
+        assert !TypeNodes.NeedsNativeAllocationNode.executeUncached(cls);
         this.exceptionAttributes = exceptionAttributes;
         this.args = null;
         this.hasMessageFormat = true;

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/exception/PBaseException.java

@@ -2599,12 +2599,11 @@ private static long getBuiltinTypeItemsize(PythonBuiltinClassType cls) {
                 case PBytes -> 1;
                 case PInt -> 4;
                 case PFrame, PMemoryView, PTuple, PStatResult, PTerminalSize, PUnameResult, PStructTime, PProfilerEntry,
-                                PProfilerSubentry, PStructPasswd, PStructRusage, PVersionInfo, PFlags, PFloatInfo,
-                                PIntInfo, PHashInfo, PThreadInfo, PUnraisableHookArgs, PIOBase, PFileIO, PBufferedIOBase,
-                                PBufferedReader, PBufferedWriter, PBufferedRWPair, PBufferedRandom, PIncrementalNewlineDecoder,
-                                PTextIOWrapper, CArgObject, CThunkObject, StgDict, Structure, Union, PyCPointer, PyCArray,
-                                PyCData, SimpleCData, PyCFuncPtr, CField, DictRemover, StructParam ->
-                    8;
+                        PProfilerSubentry, PStructPasswd, PStructRusage, PVersionInfo, PFlags, PFloatInfo,
+                        PIntInfo, PHashInfo, PThreadInfo, PUnraisableHookArgs, PIOBase, PFileIO, PBufferedIOBase,
+                        PBufferedReader, PBufferedWriter, PBufferedRWPair, PBufferedRandom, PIncrementalNewlineDecoder,
+                        PTextIOWrapper, CArgObject, CThunkObject, StgDict, Structure, Union, PyCPointer, PyCArray,
+                        PyCData, SimpleCData, PyCFuncPtr, CField, DictRemover, StructParam -> 8;
                 case PythonClass -> 40;
                 default -> 0;
             };
@@ -2673,4 +2672,45 @@ void set(PythonManagedClass cls, long value,
             write.execute(cls, TYPE_DICTOFFSET, value);
         }
     }
+
+    /**
+     * Tests if the given {@code cls} is a Python class that needs a native allocation. This is the
+     * case if {@code cls} either is a native class or it is a managed class that (indirectly)
+     * inherits from a native class.
+     */
+    @GenerateUncached
+    @GenerateInline
+    @GenerateCached(false)
+    public abstract static class NeedsNativeAllocationNode extends Node {
+        public abstract boolean execute(Node inliningTarget, Object cls);
+
+        public static boolean executeUncached(Object cls) {
+            return TypeNodesFactory.NeedsNativeAllocationNodeGen.getUncached().execute(null, cls);
+        }
+
+        @Specialization
+        static boolean doPBCT(@SuppressWarnings("unused") PythonBuiltinClassType cls) {
+            return false;
+        }
+
+        @Specialization
+        static boolean doBuiltin(@SuppressWarnings("unused") PythonBuiltinClass cls) {
+            return false;
+        }
+
+        @Specialization
+        static boolean doManaged(PythonManagedClass cls) {
+            return cls.needsNativeAllocation();
+        }
+
+        @Specialization
+        static boolean doNative(@SuppressWarnings("unused") PythonNativeClass cls) {
+            return true;
+        }
+
+        @Fallback
+        static boolean doOther(@SuppressWarnings("unused") Object cls) {
+            return false;
+        }
+    }
 }

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

@@ -368,18 +368,6 @@ public static boolean isNativeClass(Object klass) {
         return PythonNativeClass.isInstance(klass);
     }
 
-    /**
-     * Tests if the given {@code klass} is a Python class that needs a native allocation. This is
-     * the case if {@code klass} either is a native class or it is a managed class that (indirectly)
-     * inherits from a native class.
-     */
-    public static boolean needsNativeAllocation(Object klass) {
-        if (klass instanceof PythonManagedClass managedClass) {
-            return managedClass.needsNativeAllocation();
-        }
-        return PythonNativeClass.isInstance(klass);
-    }
-
     public static boolean isPythonClass(Object klass) {
         return PythonAbstractClass.isInstance(klass) || klass instanceof PythonBuiltinClassType;
     }