[GR-39067] Backport fixes around foreign prototype.

PullRequest: js/2508

Author: wirthi

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

@@ -206,24 +206,75 @@ public void testJSBuiltinCanBeOverwritten() {
 
     @Test
     public void testForeignInstanceof() {
-        testInstanceofIntl("Array", ProxyArray.fromArray("fun", "with", "proxy", "array"));
-        testPrototypeIntl("Date", Instant.now());
-        testPrototypeIntl("Map", new TestTruffleHash());
-        testPrototypeIntl("String", new TestTruffleString());
-        testPrototypeIntl("Boolean", new TestTruffleBoolean());
-        testPrototypeIntl("Number", new TestTruffleNumber());
-        testPrototypeIntl("Function", (ProxyExecutable) v -> true);
-        testPrototypeIntl("Object", new Object());
+        // test expected Instance
+        Assert.assertTrue(testInstanceofIntl("Array", ProxyArray.fromArray("fun", "with", "proxy", "array")));
+        // Assert.assertTrue(testInstanceofIntl("Date", Instant.now())); //see GR-39319
+        Assert.assertTrue(testInstanceofIntl("Map", new TestTruffleHash()));
+        Assert.assertTrue(testInstanceofIntl("String", new TestTruffleString()));
+        Assert.assertTrue(testInstanceofIntl("Boolean", new TestTruffleBoolean()));
+        Assert.assertTrue(testInstanceofIntl("Number", new TestTruffleNumber()));
+        Assert.assertTrue(testInstanceofIntl("Function", (ProxyExecutable) v -> true));
+        Assert.assertTrue(testInstanceofIntl("Object", new Object()));
+
+        // test non-matching instance
+        Assert.assertFalse(testInstanceofIntl("RegExp", ProxyArray.fromArray("fun", "with", "proxy", "array")));
+        Assert.assertFalse(testInstanceofIntl("RegExp", Instant.now()));
+        Assert.assertFalse(testInstanceofIntl("RegExp", new TestTruffleHash()));
+        Assert.assertFalse(testInstanceofIntl("RegExp", new TestTruffleString()));
+        Assert.assertFalse(testInstanceofIntl("RegExp", new TestTruffleBoolean()));
+        Assert.assertFalse(testInstanceofIntl("RegExp", new TestTruffleNumber()));
+        Assert.assertFalse(testInstanceofIntl("RegExp", (ProxyExecutable) v -> true));
+        Assert.assertFalse(testInstanceofIntl("RegExp", new Object()));
     }
 
-    private static void testInstanceofIntl(String prototype, Object obj) {
-        String code = "(obj) => { return (obj instanceof " + prototype + "); }";
+    private static boolean testInstanceofIntl(String prototype, Object obj) {
+        String code = "(obj) => { return (obj instanceof " + prototype + ") && (obj instanceof Object); }";
         try (Context context = JSTest.newContextBuilder(ID).build()) {
             Value result = context.eval(ID, code).execute(obj);
-            Assert.assertTrue(result.asBoolean());
+            return result.asBoolean();
         }
     }
 
+    @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

@@ -239,29 +239,44 @@ protected boolean doIsBound(Object obj, JSDynamicObject check,
 
         @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("getPrototype1Node") GetPrototypeNode getPrototype1Node,
-                        @Cached @Shared("invalidPrototypeBranch") BranchProfile invalidPrototypeBranch) {
+                        @Cached @Shared("foreignPrototypeNode") ForeignObjectPrototypeNode getForeignPrototypeNode,
+                        @Cached @Shared("invalidPrototypeBranch") BranchProfile invalidPrototypeBranch,
+                        @Cached("create(context)") @Shared("ordinaryHasInstance") OrdinaryHasInstanceNode ordinaryHasInstanceNode) {
             if (context.isOptionForeignObjectPrototype()) {
-                Object rightProto = getConstructorPrototype(right, invalidPrototypeBranch);
-                if (rightProto == getRealm().getDatePrototype()) {
-                    return false;
-                }
-                Object foreignProto = getForeignPrototypeNode.execute(left);
-                Object foreignProtoProto = getPrototype1Node.execute(foreignProto);
-                return rightProto == foreignProtoProto;
+                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;
         }