address remarks from review, add tests

Author: wirthi

graal-js/src/com.oracle.truffle.js.test/src/com/oracle/truffle/js/test/interop/ForeignObjectPrototypeTest.java

@@ -235,6 +235,46 @@ private static boolean testInstanceofIntl(String prototype, Object obj) {
         }
     }
 
+    @Test
+    public void testForeignRightPrototype() {
+        String code = "ForeignObjectPrototype = Object.getPrototypeOf(new java.lang.Object());\n" +
+                        "function f() {}; \n" +
+                        "f.prototype = ForeignObjectPrototype;\n" +
+                        "new java.lang.Object() instanceof f;";
+        testTrue(code);
+    }
+
+    private static void testTrue(String code) {
+        Assert.assertTrue(testIntl(code));
+    }
+
+    private static void testFalse(String code) {
+        Assert.assertFalse(testIntl(code));
+    }
+
+    private static boolean testIntl(String code) {
+        try (Context context = JSTest.newContextBuilder(ID).allowAllAccess(true).allowHostAccess(HostAccess.ALL).build()) {
+            Value result = context.eval(ID, code);
+            return result.asBoolean();
+        }
+    }
+
+    @Test
+    public void testCallableProxies() {
+        String code = "new java.lang.Object instanceof new Proxy(Object, {});";
+        testTrue(code);
+
+        code = "var handler = { get(target, prop, recv) { return (prop === 'prototype') ? Object.prototype : Reflect.get(target, prop, recv); } };\n" +
+                        "var proxy = new Proxy(function() {}, handler);\n" +
+                        "new java.lang.Object() instanceof proxy";
+        testTrue(code);
+
+        code = "var handler = { get(target, prop, recv) { if (prop === 'prototype') { throw new Error() } else { return Reflect.get(target, prop, recv); } } };\n" +
+                        "var proxy = new Proxy(function() {}, handler);\n" +
+                        "42 instanceof proxy";
+        testFalse(code);
+    }
+
     @ExportLibrary(InteropLibrary.class)
     public static class TestTruffleHash implements TruffleObject {
 

graal-js/src/com.oracle.truffle.js/src/com/oracle/truffle/js/nodes/binary/InstanceofNode.java

@@ -232,36 +232,51 @@ protected boolean doNotCallable(Object obj, Object check) {
 
         @Specialization(guards = {"isJSFunction(check)", "isBoundFunction(check)"})
         protected boolean doIsBound(Object obj, JSDynamicObject check,
-                        @Cached("create(context)") @Shared("instanceofNode") InstanceofNode instanceofNode) {
+                        @Cached("create(context)") InstanceofNode instanceofNode) {
             JSDynamicObject boundTargetFunction = JSFunction.getBoundTargetFunction(check);
             return instanceofNode.executeBoolean(obj, boundTargetFunction);
         }
 
         @Specialization(guards = {"!isJSObject(left)", "isForeignObject(left)", "isJSFunction(right)", "!isBoundFunction(right)"})
         protected boolean doForeignObject(@SuppressWarnings("unused") Object left, @SuppressWarnings("unused") JSDynamicObject right,
-                        @Cached ForeignObjectPrototypeNode getForeignPrototypeNode,
+                        @Cached @Shared("foreignPrototypeNode") ForeignObjectPrototypeNode getForeignPrototypeNode,
                         @Cached @Shared("invalidPrototypeBranch") BranchProfile invalidPrototypeBranch,
-                        @Cached("create(context)") @Shared("instanceofNode") InstanceofNode instanceofNode) {
+                        @Cached("create(context)") @Shared("ordinaryHasInstance") OrdinaryHasInstanceNode ordinaryHasInstanceNode) {
             if (context.isOptionForeignObjectPrototype()) {
-                Object rightProto = getConstructorPrototype(right, invalidPrototypeBranch);
-                if (rightProto == getRealm().getDatePrototype()) {
-                    // necessary because of GR-39319
-                    return false;
-                }
-                Object foreignProto = getForeignPrototypeNode.execute(left);
-                return instanceofNode.executeBoolean(foreignProto, right);
+                return foreignObjectIntl(left, right, getForeignPrototypeNode, invalidPrototypeBranch, ordinaryHasInstanceNode);
             } else {
                 return false;
             }
         }
 
+        private boolean foreignObjectIntl(Object left, JSDynamicObject right, ForeignObjectPrototypeNode getForeignPrototypeNode, BranchProfile invalidPrototypeBranch,
+                        OrdinaryHasInstanceNode ordinaryHasInstanceNode) {
+            Object rightProto = getConstructorPrototype(right, invalidPrototypeBranch);
+            if (rightProto == getRealm().getDatePrototype()) {
+                // necessary because of GR-39319
+                return false;
+            }
+            Object foreignProto = getForeignPrototypeNode.execute(left);
+            if (foreignProto == rightProto) {
+                return true;
+            }
+            return ordinaryHasInstanceNode.executeBoolean(foreignProto, right);
+        }
+
         @Specialization(guards = {"!isJSObject(left)", "!isForeignObject(left)", "isJSFunction(right)", "!isBoundFunction(right)"})
         protected boolean doNotAnObject(@SuppressWarnings("unused") Object left, @SuppressWarnings("unused") JSDynamicObject right) {
             return false;
         }
 
-        @Specialization(guards = {"!isJSObject(left)", "isJSProxy(right)", "isCallableProxy(right)"})
-        protected boolean doNotAnObjectProxy(@SuppressWarnings("unused") Object left, @SuppressWarnings("unused") JSDynamicObject right) {
+        @Specialization(guards = {"!isJSObject(left)", "isForeignObject(left)", "isJSProxy(right)", "isCallableProxy(right)"})
+        protected boolean doNotAnObjectProxyForeign(@SuppressWarnings("unused") Object left, @SuppressWarnings("unused") JSDynamicObject right,
+                        @Cached @Shared("foreignPrototypeNode") ForeignObjectPrototypeNode getForeignPrototypeNode, @Cached @Shared("invalidPrototypeBranch") BranchProfile invalidPrototypeBranch,
+                        @Cached("create(context)") @Shared("ordinaryHasInstance") OrdinaryHasInstanceNode ordinaryHasInstanceNode) {
+            return doForeignObject(left, right, getForeignPrototypeNode, invalidPrototypeBranch, ordinaryHasInstanceNode);
+        }
+
+        @Specialization(guards = {"!isJSObject(left)", "!isForeignObject(left)", "isJSProxy(right)", "isCallableProxy(right)"})
+        protected boolean doNotAnObjectProxyPrimitive(@SuppressWarnings("unused") Object left, @SuppressWarnings("unused") JSDynamicObject right) {
             return false;
         }