[GR-27646] Fix invalid type comparison in AbstractObjectIsSubclassNode.

PullRequest: graalpython/1414

Author: chumer

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/classes/AbstractObjectIsSubclassNode.java

@@ -43,10 +43,12 @@
 import com.oracle.graal.python.builtins.objects.common.SequenceNodes.GetObjectArrayNode;
 import com.oracle.graal.python.builtins.objects.common.SequenceStorageNodes;
 import com.oracle.graal.python.builtins.objects.tuple.PTuple;
+import com.oracle.graal.python.builtins.objects.type.TypeNodes.IsSameTypeNode;
 import com.oracle.graal.python.nodes.PNodeWithContext;
 import com.oracle.graal.python.runtime.PythonOptions;
 import com.oracle.truffle.api.CompilerDirectives;
 import com.oracle.truffle.api.dsl.Cached;
+import com.oracle.truffle.api.dsl.Cached.Shared;
 import com.oracle.truffle.api.dsl.GenerateUncached;
 import com.oracle.truffle.api.dsl.ImportStatic;
 import com.oracle.truffle.api.dsl.Specialization;
@@ -73,8 +75,10 @@ public final boolean execute(Object derived, Object cls) {
         return execute(null, derived, cls);
     }
 
-    @Specialization(guards = "derived == cls")
-    boolean isSameClass(@SuppressWarnings("unused") Object derived, @SuppressWarnings("unused") Object cls) {
+    @Specialization(guards = "isSameMetaObject(isSameTypeNode, derived, cls)", limit = "1")
+    @SuppressWarnings("unused")
+    static boolean doSameClass(Object derived, Object cls,
+                    @Shared("isSameType") @Cached IsSameTypeNode isSameTypeNode) {
         return true;
     }
 
@@ -84,11 +88,12 @@ protected static int[] observedSize() {
         return ary;
     }
 
-    @Specialization(guards = {"derived != cls", "derived == cachedDerived", "cls == cachedCls"}, limit = "getCallSiteInlineCacheMaxDepth()")
-    boolean isSubclass(VirtualFrame frame, @SuppressWarnings("unused") Object derived, @SuppressWarnings("unused") Object cls,
+    @Specialization(guards = {"!isSameMetaObject(isSameTypeNode, derived, cls)", "derived == cachedDerived", "cls == cachedCls"}, limit = "getCallSiteInlineCacheMaxDepth()")
+    static boolean doSubclass(VirtualFrame frame, @SuppressWarnings("unused") Object derived, @SuppressWarnings("unused") Object cls,
                     @Cached(value = "observedSize()", dimensions = 1) int[] observedSizeArray,
                     @Cached("derived") Object cachedDerived,
                     @Cached("cls") Object cachedCls,
+                    @Cached @SuppressWarnings("unused") IsSameTypeNode isSameTypeNode,
                     @Cached SequenceStorageNodes.LenNode lenNode,
                     @Cached AbstractObjectGetBasesNode getBasesNode,
                     @Cached AbstractObjectIsSubclassNode isSubclassNode,
@@ -114,7 +119,7 @@ boolean isSubclass(VirtualFrame frame, @SuppressWarnings("unused") Object derive
         return loopUnexploded(frame, cachedCls, isSubclassNode, basesAry);
     }
 
-    private static final boolean loopUnexploded(VirtualFrame frame, Object cachedCls, AbstractObjectIsSubclassNode isSubclassNode, Object[] basesAry) {
+    private static boolean loopUnexploded(VirtualFrame frame, Object cachedCls, AbstractObjectIsSubclassNode isSubclassNode, Object[] basesAry) {
         for (Object baseCls : basesAry) {
             if (isSubclassNode.execute(frame, baseCls, cachedCls)) {
                 return true;
@@ -124,7 +129,7 @@ private static final boolean loopUnexploded(VirtualFrame frame, Object cachedCls
     }
 
     @ExplodeLoop
-    private static final boolean loopBases(VirtualFrame frame, Object cachedCls, Object[] bases, AbstractObjectIsSubclassNode isSubclassNode) {
+    private static boolean loopBases(VirtualFrame frame, Object cachedCls, Object[] bases, AbstractObjectIsSubclassNode isSubclassNode) {
         for (int i = 0; i < bases.length; i++) {
             if (isSubclassNode.execute(frame, bases[i], cachedCls)) {
                 return true;
@@ -133,13 +138,14 @@ private static final boolean loopBases(VirtualFrame frame, Object cachedCls, Obj
         return false;
     }
 
-    @Specialization(replaces = {"isSubclass", "isSameClass"})
-    boolean isSubclassGeneric(VirtualFrame frame, Object derived, Object cls,
+    @Specialization(replaces = {"doSubclass", "doSameClass"})
+    static boolean doGeneric(VirtualFrame frame, Object derived, Object cls,
                     @Cached SequenceStorageNodes.LenNode lenNode,
                     @Cached AbstractObjectGetBasesNode getBasesNode,
                     @Cached AbstractObjectIsSubclassNode isSubclassNode,
+                    @Shared("isSameType") @Cached IsSameTypeNode isSameTypeNode,
                     @Cached GetObjectArrayNode getObjectArrayNode) {
-        if (derived == cls) {
+        if (isSameMetaObject(isSameTypeNode, derived, cls)) {
             return true;
         }
 
@@ -159,4 +165,12 @@ boolean isSubclassGeneric(VirtualFrame frame, Object derived, Object cls,
     private static boolean isEmpty(PTuple bases, SequenceStorageNodes.LenNode lenNode) {
         return lenNode.execute(bases.getSequenceStorage()) == 0;
     }
+
+    /**
+     * Tests if the two meta objects {@code derived} and {@code cls} are the same. This differs from
+     * {@link IsSameTypeNode} because it will also accept meta objects that are not classes.
+     */
+    static boolean isSameMetaObject(IsSameTypeNode isSameTypeNode, Object derived, Object cls) {
+        return derived == cls || isSameTypeNode.execute(derived, cls);
+    }
 }