fix foreign instanceof to check prototype hierarchy and extend testing

Author: wirthi

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

@@ -206,21 +206,32 @@ public void testJSBuiltinCanBeOverwritten() {
 
     @Test
     public void testForeignInstanceof() {
-        testInstanceofIntl("Array", ProxyArray.fromArray("fun", "with", "proxy", "array"));
-        testInstanceofIntl("Date", Instant.now());
-        testInstanceofIntl("Map", new TestTruffleHash());
-        testInstanceofIntl("String", new TestTruffleString());
-        testInstanceofIntl("Boolean", new TestTruffleBoolean());
-        testInstanceofIntl("Number", new TestTruffleNumber());
-        testInstanceofIntl("Function", (ProxyExecutable) v -> true);
-        testInstanceofIntl("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();
         }
     }
 

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

@@ -232,24 +232,24 @@ protected boolean doNotCallable(Object obj, Object check) {
 
         @Specialization(guards = {"isJSFunction(check)", "isBoundFunction(check)"})
         protected boolean doIsBound(Object obj, JSDynamicObject check,
-                        @Cached("create(context)") InstanceofNode instanceofNode) {
+                        @Cached("create(context)") @Shared("instanceofNode") 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("getPrototype1Node") GetPrototypeNode getPrototype1Node,
-                        @Cached @Shared("invalidPrototypeBranch") BranchProfile invalidPrototypeBranch) {
+                        @Cached @Shared("invalidPrototypeBranch") BranchProfile invalidPrototypeBranch,
+                        @Cached("create(context)") @Shared("instanceofNode") InstanceofNode instanceofNode) {
             if (context.isOptionForeignObjectPrototype()) {
                 Object rightProto = getConstructorPrototype(right, invalidPrototypeBranch);
                 if (rightProto == getRealm().getDatePrototype()) {
+                    // necessary because of GR-39319
                     return false;
                 }
                 Object foreignProto = getForeignPrototypeNode.execute(left);
-                Object foreignProtoProto = getPrototype1Node.execute(foreignProto);
-                return rightProto == foreignProtoProto;
+                return instanceofNode.executeBoolean(foreignProto, right);
             } else {
                 return false;
             }