Fix incorrect generic case in IsNode

Author: fangerer

graalpython/com.oracle.graal.python.test/src/tests/seq_tests.py

@@ -215,6 +215,14 @@ def test_contains(self):
 
         self.assertRaises(TypeError, u.__contains__)
 
+        # define function such that we use the same code in multiple calls
+        def isin(l, item):
+            return item in l
+        # activate generic case (compares built-in type to object)
+        assert not isin([object()], list)
+        # use generic case to compare built-in types
+        assert isin([type([])], list)
+
 # TODO These test fails
 #    def test_contains_fake(self):
 #        class AllEq:

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/expression/IsExpressionNode.java

@@ -306,15 +306,15 @@ static boolean doPNoneObject(PNone left, Object right,
         }
 
         // pstring (may be interned)
-        @Specialization
+        @Specialization(limit = "1")
         static boolean doPString(PString left, PString right,
-                        @CachedLibrary(limit = "2") PythonObjectLibrary lib) {
+                        @CachedLibrary("left") PythonObjectLibrary lib) {
             return lib.isSame(left, right);
         }
 
         // everything else
-        @Specialization(limit = "getCallSiteInlineCacheMaxDepth()")
-        static boolean doGeneric(Object left, Object right,
+        @Specialization(guards = "isFallbackCase(left, right)", limit = "getCallSiteInlineCacheMaxDepth()")
+        static boolean doOther(Object left, Object right,
                         @CachedLibrary("left") PythonObjectLibrary lib) {
             if (left == right) {
                 return true;
@@ -330,6 +330,42 @@ static boolean doGeneric(Object left, Object right,
             return false;
         }
 
+        private static boolean isPrimitive(Object object) {
+            return object instanceof Boolean || object instanceof Integer || object instanceof Long || object instanceof Double;
+        }
+
+        private static boolean isBuiltinClassCase(Object left, Object right) {
+            return left instanceof PythonBuiltinClassType && right instanceof PythonBuiltinClass;
+        }
+
+        static boolean isFallbackCase(Object left, Object right) {
+            if (isPrimitive(left) && isPrimitive(right)) {
+                return false;
+            }
+            if (left instanceof Boolean && right instanceof PInt || left instanceof PInt && right instanceof Boolean) {
+                return false;
+            }
+            if (left instanceof Integer && right instanceof PInt || left instanceof PInt && right instanceof Integer) {
+                return false;
+            }
+            if (left instanceof PythonAbstractNativeObject && right instanceof PythonAbstractNativeObject) {
+                return false;
+            }
+            if (left instanceof PString && right instanceof PString) {
+                return false;
+            }
+            if (isBuiltinClassCase(left, right) || isBuiltinClassCase(right, left)) {
+                return false;
+            }
+            if (left instanceof PCode && right instanceof PCode) {
+                return false;
+            }
+            if (left instanceof PNone || right instanceof PNone) {
+                return false;
+            }
+            return true;
+        }
+
         public static IsNode create() {
             return IsNodeGen.create();
         }