[GR-14811] add missing PInt and LazyPythonClass specializations in IsSubType and LookupAndCallBinary nodes

PullRequest: graalpython/462

Author: cosminbasca

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

@@ -588,6 +588,21 @@ boolean doManaged(PythonManagedClass left, PythonManagedClass right) {
             return left == right;
         }
 
+        @Specialization
+        boolean doManaged(PythonBuiltinClassType left, PythonBuiltinClassType right) {
+            return left == right;
+        }
+
+        @Specialization
+        boolean doManaged(PythonBuiltinClassType left, PythonBuiltinClass right) {
+            return left == right.getType();
+        }
+
+        @Specialization
+        boolean doManaged(PythonBuiltinClass left, PythonBuiltinClassType right) {
+            return left.getType() == right;
+        }
+
         @Specialization
         boolean doNativeSlow(PythonAbstractNativeObject left, PythonAbstractNativeObject right) {
             if (fastCheck) {

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/call/special/LookupAndCallBinaryNode.java

@@ -45,14 +45,15 @@
 import com.oracle.graal.python.builtins.objects.PNone;
 import com.oracle.graal.python.builtins.objects.PNotImplemented;
 import com.oracle.graal.python.builtins.objects.function.PBuiltinFunction;
-import com.oracle.graal.python.builtins.objects.type.PythonAbstractClass;
+import com.oracle.graal.python.builtins.objects.type.LazyPythonClass;
 import com.oracle.graal.python.builtins.objects.type.TypeNodes;
 import com.oracle.graal.python.nodes.PNodeWithContext;
 import com.oracle.graal.python.nodes.attributes.LookupAttributeInMRONode;
 import com.oracle.graal.python.nodes.attributes.LookupInheritedAttributeNode;
 import com.oracle.graal.python.nodes.classes.IsSubtypeNode;
 import com.oracle.graal.python.nodes.function.builtins.PythonBinaryBuiltinNode;
 import com.oracle.graal.python.nodes.object.GetClassNode;
+import com.oracle.graal.python.nodes.object.GetLazyClassNode;
 import com.oracle.truffle.api.CompilerDirectives;
 import com.oracle.truffle.api.dsl.Cached;
 import com.oracle.truffle.api.dsl.Specialization;
@@ -285,15 +286,15 @@ Object callObject(Object left, Object right,
     Object callObject(Object left, Object right,
                     @Cached("create(name)") LookupAttributeInMRONode getattr,
                     @Cached("create(rname)") LookupAttributeInMRONode getattrR,
-                    @Cached("create()") GetClassNode getClass,
-                    @Cached("create()") GetClassNode getClassR,
+                    @Cached("create()") GetLazyClassNode getClass,
+                    @Cached("create()") GetLazyClassNode getClassR,
                     @Cached("create()") TypeNodes.IsSameTypeNode isSameTypeNode,
                     @Cached("create()") IsSubtypeNode isSubtype,
                     @Cached("createBinaryProfile()") ConditionProfile notImplementedBranch) {
         Object result = PNotImplemented.NOT_IMPLEMENTED;
-        PythonAbstractClass leftClass = getClass.execute(left);
+        LazyPythonClass leftClass = getClass.execute(left);
         Object leftCallable = getattr.execute(leftClass);
-        PythonAbstractClass rightClass = getClassR.execute(right);
+        LazyPythonClass rightClass = getClassR.execute(right);
         Object rightCallable = getattrR.execute(rightClass);
         if (leftCallable == rightCallable) {
             rightCallable = PNone.NO_VALUE;

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

@@ -40,6 +40,7 @@
  */
 package com.oracle.graal.python.nodes.classes;
 
+import com.oracle.graal.python.builtins.objects.type.LazyPythonClass;
 import com.oracle.graal.python.builtins.objects.type.PythonAbstractClass;
 import com.oracle.graal.python.builtins.objects.type.TypeNodes.GetMroStorageNode;
 import com.oracle.graal.python.builtins.objects.type.TypeNodes.IsSameTypeNode;
@@ -114,8 +115,8 @@ boolean isSubtypeOfConstantType(@SuppressWarnings("unused") PythonAbstractClass
                         assumptions = "mro.getLookupStableAssumption()" //
         )
         @ExplodeLoop
-        boolean isSubtypeOfVariableType(@SuppressWarnings("unused") PythonAbstractClass derived, PythonAbstractClass cls,
-                        @Cached("derived") @SuppressWarnings("unused") PythonAbstractClass cachedDerived,
+        boolean isSubtypeOfVariableType(@SuppressWarnings("unused") LazyPythonClass derived, LazyPythonClass cls,
+                        @Cached("derived") @SuppressWarnings("unused") LazyPythonClass cachedDerived,
                         @Cached("getMro(cachedDerived)") MroSequenceStorage mro) {
             for (PythonAbstractClass n : mro.getInternalClassArray()) {
                 if (isSameType(n, cls)) {
@@ -126,7 +127,7 @@ boolean isSubtypeOfVariableType(@SuppressWarnings("unused") PythonAbstractClass
         }
 
         @Specialization(replaces = {"isSubtypeOfConstantType", "isSubtypeOfVariableType"})
-        boolean issubTypeGeneric(PythonAbstractClass derived, PythonAbstractClass cls) {
+        boolean issubTypeGeneric(LazyPythonClass derived, LazyPythonClass cls) {
             for (PythonAbstractClass n : getMro(derived).getInternalClassArray()) {
                 if (isSameType(n, cls)) {
                     return true;
@@ -153,15 +154,15 @@ public boolean isSubclass(Object derived, Object cls) {
             return abstractIsSubclassNode.execute(derived, cls);
         }
 
-        protected MroSequenceStorage getMro(PythonAbstractClass clazz) {
+        protected MroSequenceStorage getMro(LazyPythonClass clazz) {
             if (getMroNode == null) {
                 CompilerDirectives.transferToInterpreterAndInvalidate();
                 getMroNode = insert(GetMroStorageNode.create());
             }
             return getMroNode.execute(clazz);
         }
 
-        private boolean isSameType(PythonAbstractClass left, PythonAbstractClass right) {
+        private boolean isSameType(LazyPythonClass left, LazyPythonClass right) {
             if (isSameTypeNode == null) {
                 CompilerDirectives.transferToInterpreterAndInvalidate();
                 isSameTypeNode = insert(IsSameTypeNode.create());