do not allow bool as a basetype

Author: timfel

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/PythonBuiltinClassType.java

@@ -56,7 +56,7 @@
 public enum PythonBuiltinClassType implements LazyPythonClass {
 
     ForeignObject(BuiltinNames.FOREIGN),
-    Boolean("bool", BuiltinNames.BUILTINS),
+    Boolean("bool", BuiltinNames.BUILTINS, false),
     GetSetDescriptor("get_set_desc"),
     PArray("array", "array"),
     PArrayIterator("arrayiterator"),
@@ -203,11 +203,12 @@ public enum PythonBuiltinClassType implements LazyPythonClass {
     private final Shape instanceShape;
     private final String publicInModule;
     private final String qualifiedName;
+    private final boolean basetype;
 
     // initialized in static constructor
     @CompilationFinal private PythonBuiltinClassType base;
 
-    PythonBuiltinClassType(String name, String publicInModule) {
+    PythonBuiltinClassType(String name, String publicInModule, boolean basetype) {
         this.name = name;
         this.publicInModule = publicInModule;
         if (publicInModule != null && publicInModule != BuiltinNames.BUILTINS) {
@@ -216,10 +217,19 @@ public enum PythonBuiltinClassType implements LazyPythonClass {
             qualifiedName = name;
         }
         this.instanceShape = com.oracle.graal.python.builtins.objects.object.PythonObject.freshShape(this);
+        this.basetype = basetype;
+    }
+
+    PythonBuiltinClassType(String name, String publicInModule) {
+        this(name, publicInModule, true);
     }
 
     PythonBuiltinClassType(String name) {
-        this(name, null);
+        this(name, null, true);
+    }
+
+    public boolean isAcceptableBase() {
+        return basetype;
     }
 
     @Override

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

@@ -145,6 +145,7 @@
 import com.oracle.graal.python.builtins.objects.type.TypeNodes;
 import com.oracle.graal.python.builtins.objects.type.TypeNodes.GetMroNode;
 import com.oracle.graal.python.builtins.objects.type.TypeNodes.GetNameNode;
+import com.oracle.graal.python.builtins.objects.type.TypeNodes.IsAcceptableBaseNode;
 import com.oracle.graal.python.builtins.objects.type.TypeNodes.IsTypeNode;
 import com.oracle.graal.python.nodes.BuiltinNames;
 import com.oracle.graal.python.nodes.PGuards;
@@ -2100,6 +2101,7 @@ public abstract static class TypeNode extends PythonBuiltinNode {
         @Child private GetMroNode getMroNode;
         @Child private IsSubtypeNode isSubtypeNode;
         @Child private GetObjectArrayNode getObjectArrayNode;
+        @Child private IsAcceptableBaseNode isAcceptableBaseNode;
 
         protected abstract Object execute(VirtualFrame frame, Object cls, Object name, Object bases, Object dict, PKeyword[] kwds);
 
@@ -2122,7 +2124,6 @@ Object type(VirtualFrame frame, LazyPythonClass cls, String name, PTuple bases,
                         @Cached CallNode callSetNameNode,
                         @Cached CallNode callInitSubclassNode,
                         @Cached CallNode callNewFuncNode) {
-
             // Determine the proper metatype to deal with this
             LazyPythonClass metaclass = calculate_metaclass(frame, cls, bases, getMetaclassNode);
             if (metaclass != cls) {
@@ -2479,6 +2480,9 @@ private PythonAbstractClass[] getMro(PythonAbstractClass pythonClass) {
         private LazyPythonClass calculate_metaclass(VirtualFrame frame, LazyPythonClass cls, PTuple bases, GetLazyClassNode getMetaclassNode) {
             LazyPythonClass winner = cls;
             for (Object base : ensureGetObjectArrayNode().execute(bases)) {
+                if (!ensureIsAcceptableBaseNode().execute(base)) {
+                    throw raise(TypeError, "type '%p' is not an acceptable base type", base);
+                }
                 LazyPythonClass typ = getMetaclassNode.execute(base);
                 if (isSubType(frame, winner, typ)) {
                     continue;
@@ -2569,6 +2573,14 @@ private GetObjectArrayNode ensureGetObjectArrayNode() {
             }
             return getObjectArrayNode;
         }
+
+        private IsAcceptableBaseNode ensureIsAcceptableBaseNode() {
+            if (isAcceptableBaseNode == null) {
+                CompilerDirectives.transferToInterpreterAndInvalidate();
+                isAcceptableBaseNode = insert(IsAcceptableBaseNode.create());
+            }
+            return isAcceptableBaseNode;
+        }
     }
 
     @Builtin(name = MODULE, minNumOfPositionalArgs = 1, takesVarArgs = true, takesVarKeywordArgs = true, constructsClass = PythonBuiltinClassType.PythonModule, isPublic = false)

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

@@ -74,6 +74,7 @@
 import com.oracle.graal.python.builtins.objects.type.TypeNodesFactory.GetSubclassesNodeGen;
 import com.oracle.graal.python.builtins.objects.type.TypeNodesFactory.GetSulongTypeNodeGen;
 import com.oracle.graal.python.builtins.objects.type.TypeNodesFactory.GetTypeFlagsNodeFactory.GetTypeFlagsCachedNodeGen;
+import com.oracle.graal.python.builtins.objects.type.TypeNodesFactory.IsAcceptableBaseNodeGen;
 import com.oracle.graal.python.builtins.objects.type.TypeNodesFactory.IsTypeNodeGen;
 import com.oracle.graal.python.nodes.PGuards;
 import com.oracle.graal.python.nodes.PNodeWithContext;
@@ -820,6 +821,46 @@ public static IsTypeNode getUncached() {
         }
     }
 
+    public abstract static class IsAcceptableBaseNode extends Node {
+        private static final long Py_TPFLAGS_BASETYPE = (1L << 10);
+
+        public abstract boolean execute(Object obj);
+
+        @Specialization
+        boolean doUserClass(@SuppressWarnings("unused") PythonClass obj) {
+            return true;
+        }
+
+        @Specialization
+        boolean doBuiltinClass(@SuppressWarnings("unused") PythonBuiltinClass obj) {
+            return obj.getType().isAcceptableBase();
+        }
+
+        @Specialization
+        boolean doBuiltinType(@SuppressWarnings("unused") PythonBuiltinClassType obj) {
+            return obj.isAcceptableBase();
+        }
+
+        @Specialization
+        boolean doNativeClass(PythonAbstractNativeObject obj,
+                        @Cached IsTypeNode isType,
+                        @Cached GetTypeFlagsNode getFlags) {
+            if (isType.execute(obj)) {
+                return (getFlags.execute(obj) & Py_TPFLAGS_BASETYPE) != 0;
+            }
+            return false;
+        }
+
+        @Fallback
+        boolean doOther(@SuppressWarnings("unused") Object obj) {
+            return false;
+        }
+
+        public static IsAcceptableBaseNode create() {
+            return IsAcceptableBaseNodeGen.create();
+        }
+    }
+
     @ImportStatic(PGuards.class)
     @GenerateUncached
     @ReportPolymorphism