Fix HPy test test_legacy_inherits_from_pure_raises

Author: fangerer

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

@@ -1850,6 +1850,7 @@ static Object doPointer(GraalHPyContext hpyContext, PythonNativeObject n, @Suppr
      *         int basicsize;
      *         int itemsize;
      *         unsigned int flags;
+     *         int legacy;
      *         void *legacy_slots;
      *         HPyDef **defines;
      *         const char *doc;
@@ -1881,6 +1882,7 @@ static Object doGeneric(GraalHPyContext context, Object typeSpec, Object typeSpe
                         @Cached HPyCreateGetSetDescriptorNode createGetSetDescriptorNode,
                         @Cached GetSuperClassNode getSuperClassNode,
                         @Cached IsSameTypeNode isSameTypeNode,
+                        @Cached ReadAttributeFromObjectNode readHPyTypeFlagsNode,
                         @Cached(parameters = "New") LookupCallableSlotInMRONode lookupNewNode,
                         @Cached HPyAsPythonObjectNode hPyAsPythonObjectNode,
                         @Cached PRaiseNode raiseNode) {
@@ -1930,6 +1932,13 @@ static Object doGeneric(GraalHPyContext context, Object typeSpec, Object typeSpe
                     throw raiseNode.raise(TypeError, "HPy_TPFLAGS_INTERNAL_PURE should not be used directly, set .legacy=true instead");
                 }
 
+                long legacy = castToLong(valueLib, ptrLib.readMember(typeSpec, "legacy"));
+                if (legacy != 0) {
+                    flags &= ~GraalHPyDef.HPy_TPFLAGS_INTERNAL_PURE;
+                } else {
+                    flags |= GraalHPyDef.HPy_TPFLAGS_INTERNAL_PURE;
+                }
+
                 long basicSize = castToLong(valueLib, ptrLib.readMember(typeSpec, "basicsize"));
                 long itemSize = castToLong(valueLib, ptrLib.readMember(typeSpec, "itemsize"));
                 writeAttributeToObjectNode.execute(newType, GraalHPyDef.TYPE_HPY_ITEMSIZE, itemSize);
@@ -2007,10 +2016,10 @@ static Object doGeneric(GraalHPyContext context, Object typeSpec, Object typeSpe
                  * constructors won't usually do that. So, we compute the constructor here and
                  * decorate it.
                  */
+                Object baseClass = getSuperClassNode.execute(newType);
                 if (basicSize > 0 && !seenNew) {
                     Object inheritedConstructor = null;
 
-                    Object baseClass = getSuperClassNode.execute(newType);
                     if (!isSameTypeNode.execute(baseClass, PythonBuiltinClassType.PythonObject)) {
                         // Lookup the inherited constructor and pass it to the HPy decorator.
                         inheritedConstructor = lookupNewNode.execute(baseClass);
@@ -2020,6 +2029,15 @@ static Object doGeneric(GraalHPyContext context, Object typeSpec, Object typeSpe
                     writeAttributeToObjectNode.execute(newType, SpecialMethodNames.__NEW__, constructorDecorator);
                 }
 
+                long baseFlags;
+                if (baseClass instanceof PythonClass) {
+                    baseFlags = ((PythonClass) baseClass).flags;
+                } else {
+                    Object baseFlagsObj = readHPyTypeFlagsNode.execute(baseClass, GraalHPyDef.TYPE_HPY_FLAGS);
+                    baseFlags = baseFlagsObj != PNone.NO_VALUE ? (long) baseFlagsObj : 0;
+                }
+                checkInheritanceConstraints(flags, baseFlags, raiseNode);
+
                 return newType;
             } catch (CannotCastException | InteropException e) {
                 throw raiseNode.raise(SystemError, "Could not create type from spec because: %m", e);
@@ -2100,6 +2118,24 @@ private static String[] splitName(String specName) {
             return new String[]{null, specName};
         }
 
+        private static void checkInheritanceConstraints(long flags, long baseFlags, PRaiseNode raiseNode) {
+            boolean isPure = (flags & GraalHPyDef.HPy_TPFLAGS_INTERNAL_PURE) != 0;
+            boolean isBasePure = (baseFlags & GraalHPyDef.HPy_TPFLAGS_INTERNAL_PURE) != 0;
+            // Pure types may inherit from:
+            //
+            // * pure types, or
+            // * PyBaseObject_Type, or
+            // * other builtin or legacy types as long as long as they do not
+            // access the struct layout (e.g. by using HPy_AsStruct or defining
+            // a deallocator with HPy_tp_destroy).
+            //
+            // It would be nice to relax these restrictions or check them here.
+            // See https://github.com/hpyproject/hpy/issues/169 for details.
+            if (!isPure && isBasePure) {
+                throw raiseNode.raise(TypeError, "A legacy type should not inherit its memory layout from a pure type");
+            }
+        }
+
         private static long castToLong(InteropLibrary lib, Object value) throws OverflowException {
             if (lib.fitsInLong(value)) {
                 try {

graalpython/lib-graalpython/modules/hpy/test/test_hpytype_legacy.py

@@ -103,7 +103,6 @@ def test_legacy_methods(self):
         assert mod.h(4, 5, 6) == 456
         assert mod.k(c=6, b=5, a=4) == 456
 
-    @pytest.mark.xfail
     def test_legacy_inherits_from_pure_raises(self):
         import pytest
         mod_src = """