fix IsSubtypeNode for variable subtypes and constant basetype

The isSubMro method tried to be clever and only check if the basetype is at a
single position in the subtype's MRO. This works fine if all classes from the
subtype up to (but not including) the basetype class only have a single
base. But if anything in between has multiple bases, the MRO will have extra
elements in between.

Example: _io.UnsupportedOperation inherits from ValueError and OSError, leading
to this MRO:
   <class 'io.UnsupportedOperation'>
   <class 'OSError'>
   <class 'ValueError'>
   <class 'Exception'>
   <class 'BaseException'>
   <class 'object'>

OSError has this:
   <class 'OSError'>
   <class 'Exception'>
   <class 'BaseException'>
   <class 'object'>

The diff is two, previously the IsSubtypeNode might now check at index 2 of the
subtype's MRO, and find ValueError to be not the same as OSError. Thus the need
to loop from index 0 to index 2.

Author: timfel

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

@@ -85,18 +85,29 @@ protected static boolean isSameType(IsSameTypeNode isSameTypeNode, Object cls, O
         return isSameTypeNode.execute(cls, cachedCls);
     }
 
-    protected boolean isSubMro(Object base, MroSequenceStorage derivedMro, int baseMroLen, IsSameTypeNode isSameTypeNode) {
-        CompilerAsserts.partialEvaluationConstant(baseMroLen);
-        PythonAbstractClass[] derivedMroAry = derivedMro.getInternalClassArray();
-        int derivedMroLen = derivedMroAry.length;
-        int offset = derivedMroLen - baseMroLen;
-        if (offset >= 0) {
-            return isSameType(isSameTypeNode, derivedMroAry[offset], base);
-        } else {
-            return false;
+    /**
+     * This method is used to search for a constant base type in the mro of
+     * non-constant potential subtypes when all subtypes' MROs have the same
+     * length. Since the entire base mro must strictly be behind the base, we
+     * only need to search from the beginning of the mro to the length
+     * difference.
+     */
+    @ExplodeLoop(kind = LoopExplosionKind.FULL_UNROLL_UNTIL_RETURN)
+    protected boolean isSubMro(Object base, PythonAbstractClass[] derivedMroAry, int mroDiff, IsSameTypeNode isSameTypeNode) {
+        CompilerAsserts.partialEvaluationConstant(base);
+        CompilerAsserts.partialEvaluationConstant(mroDiff);
+        for (int i = 0; i <= mroDiff; i++) {
+            if (isSameType(isSameTypeNode, derivedMroAry[i], base)) {
+                return true;
+            }
         }
+        return false;
     }
 
+    /**
+     * This method is used to search in a constant length subtype mro for a
+     * (non-constant) base type. It has to loop over the entire mro to do this.
+     */
     @ExplodeLoop(kind = LoopExplosionKind.FULL_UNROLL_UNTIL_RETURN)
     protected boolean isInMro(Object cls, MroSequenceStorage mro, int sz, IsSameTypeNode isSameTypeNode) {
         PythonAbstractClass[] mroAry = mro.getInternalClassArray();
@@ -147,19 +158,27 @@ boolean isSubtypeOfCachedMultiContext(Object derived, Object cls,
         return isInMro;
     }
 
+    protected static int sub(int a, int b) {
+        return a - b;
+    }
+
     @Specialization(guards = {
                     "cachedCls != null",
                     "getType(cls, builtinTypeProfile, builtinClassProfile) == cachedCls",
-                    "isKindOfBuiltinClass(derived)" // see assertion in isSubMro
+                    "isKindOfBuiltinClass(derived)", // see assertion in isSubMro
+                    "mroAry.length == derivedMroLen",
+                    "mroDiff < 16",
     }, replaces = "isSubtypeOfCachedMultiContext", limit = "getVariableArgumentInlineCacheLimit()")
     boolean isVariableSubtypeOfConstantTypeCachedMultiContext(Object derived, @SuppressWarnings("unused") Object cls,
                     @SuppressWarnings("unused") @Cached ConditionProfile builtinTypeProfile,
                     @SuppressWarnings("unused") @Cached ConditionProfile builtinClassProfile,
                     @Cached IsSameTypeNode isSameTypeNode,
                     @Cached GetMroStorageNode getMro,
+                    @Bind("getMro.execute(derived).getInternalClassArray()") PythonAbstractClass[] mroAry,
+                    @Cached("mroAry.length") int derivedMroLen,
                     @Cached("getType(cls, builtinTypeProfile, builtinClassProfile)") PythonBuiltinClassType cachedCls,
-                    @Cached("getMro.execute(cachedCls).getInternalClassArray().length") int baseMroLen) {
-        return isSubMro(cachedCls, getMro.execute(derived), baseMroLen, isSameTypeNode);
+                    @Cached("sub(derivedMroLen, getMro.execute(cachedCls).getInternalClassArray().length)") int mroDiff) {
+        return isSubMro(cachedCls, mroAry, mroDiff, isSameTypeNode);
     }
 
     @Specialization(guards = {
@@ -215,6 +234,8 @@ boolean isSubtypeOfVariableTypeCached(@SuppressWarnings("unused") Object derived
     @Specialization(guards = {
                     "isKindOfBuiltinClass(derived)", // see assertion in isSubMro
                     "isKindOfBuiltinClass(cls)", // see assertion in isSubMro
+                    "mroAry.length == derivedMroLen",
+                    "mroDiff < 16",
                     "isSameType(isSameClsNode, cls, cachedCls)",
     }, limit = "getVariableArgumentInlineCacheLimit()", replaces = {
                     "isSubtypeOfCachedMultiContext",
@@ -229,10 +250,12 @@ boolean isVariableSubtypeOfConstantTypeCached(Object derived, @SuppressWarnings(
                     @Cached("cls") @SuppressWarnings("unused") Object cachedCls,
                     @Cached GetMroStorageNode getMro,
                     @SuppressWarnings("unused") @Cached("getMro.execute(cachedCls)") MroSequenceStorage baseMro,
-                    @Cached("baseMro.getInternalClassArray().length") int baseMroLen,
                     @Cached IsSameTypeNode isSameTypeInLoopNode,
+                    @Bind("getMro.execute(derived).getInternalClassArray()") PythonAbstractClass[] mroAry,
+                    @Cached("mroAry.length") int derivedMroLen,
+                    @Cached("sub(derivedMroLen, baseMro.getInternalClassArray().length)") int mroDiff,
                     @Cached @SuppressWarnings("unused") IsSameTypeNode isSameClsNode) {
-        return isSubMro(cachedCls, getMro.execute(derived), baseMroLen, isSameTypeInLoopNode);
+        return isSubMro(cachedCls, mroAry, mroDiff, isSameTypeInLoopNode);
     }
 
     @Specialization(guards = {