[GR-59335] Backport to 24.1: Handle mixing overloaded operators with non-numeric primitives

PullRequest: js/3350

Author: hadryyassine

Diff for: graal-js/src/com.oracle.truffle.js.test/js/operator_overloading.js

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021, 2021, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2021, 2024, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * Licensed under the Universal Permissive License v 1.0 as shown at http://oss.oracle.com/licenses/upl.
@@ -155,6 +155,12 @@ const VectorOperators = Operators({
             }
         }
         return false;
+    },
+    "pos"(a) {
+        return new Vector(a.contents.slice());
+    },
+    "neg"(a) {
+        return new Vector(a.contents.map(e => -e));
     }
 }, {
     right: Number,
@@ -239,9 +245,10 @@ function STR(string) {
 }
 
 
-// Basic tests on vectors: addition, subtraction, equality
+// Basic tests on vectors: addition, subtraction, unary negation, equality
 assertEqual(V(1, 2, 3) + V(2, 3, 4), V(3, 5, 7));
 assertEqual(V(1, 2, 3) - V(2, 3, 4), V(-1, -1, -1));
+assertTrue(-V(1, 2, 3) == V(-1, -2, -3))
 
 // Update operators should work too
 let A = V(1, 2, 3);
@@ -347,25 +354,31 @@ assertThrows(() => V(1, 2, 3) / V(2, 3, 4), TypeError);
 assertThrows(() => 1 + V(1, 2, 3), TypeError);
 assertThrows(() => S(1) + V(1, 2, 3), TypeError);
 assertThrows(() => V(1, 2, 3) + STR("a"), TypeError);
+assertThrows(() => { let v = V(1, 2, 3); v++; }, TypeError);
+assertThrows(() => { let v = V(1, 2, 3); v--; }, TypeError);
+
+
+// Handle null, undefined and non-numeric primitives when dispatching operators that use ToOperand
+// (ToPrimitive) internally.
+// The cases below are not covered explicitly by the operator overloading proposal, but this
+// behavior implied by the proposal spec.
+
+function illegalValueThrowsTypeError(illegalValue) {
+    assertThrows(() => S(1) + illegalValue, TypeError);
+    // For equality checks, a missing operator is interpreted as a negative result.
+    assertFalse(S(1) == illegalValue);
+    assertTrue(S(1) != illegalValue);
+    assertThrows(() => S(1) < illegalValue, TypeError);
+    assertThrows(() => S(1) <= illegalValue, TypeError);
+    assertThrows(() => S(1) > illegalValue, TypeError);
+    assertThrows(() => S(1) >= illegalValue, TypeError);
+}
 
-
-// Handle null and undefined when dispatching operators that use ToOperand (ToPrimitive) internally
-// the cases below are not covered by the operator overloading proposal
-assertThrows(() => S(1) + undefined, TypeError);
-assertFalse(S(1) == undefined);
-assertTrue(S(1) != undefined);
-assertThrows(() => S(1) < undefined, TypeError);
-assertThrows(() => S(1) <= undefined, TypeError);
-assertThrows(() => S(1) > undefined, TypeError);
-assertThrows(() => S(1) >= undefined, TypeError);
-
-assertThrows(() => S(1) + null, TypeError);
-assertFalse(S(1) == null);
-assertTrue(S(1) != null);
-assertThrows(() => S(1) < null, TypeError);
-assertThrows(() => S(1) <= null, TypeError);
-assertThrows(() => S(1) > null, TypeError);
-assertThrows(() => S(1) >= null, TypeError);
+illegalValueThrowsTypeError(undefined);
+illegalValueThrowsTypeError(null);
+illegalValueThrowsTypeError(false);
+illegalValueThrowsTypeError(true);
+illegalValueThrowsTypeError(Symbol("foo"));
 
 
 // The Operators function can reject junk input

Diff for: graal-js/src/com.oracle.truffle.js/src/com/oracle/truffle/js/nodes/binary/JSOverloadedBinaryNode.java

@@ -77,6 +77,7 @@
  * Check {@link JSAddNode} for an example of using this node.
  * </p>
  */
+@ImportStatic(OperatorSet.class)
 public abstract class JSOverloadedBinaryNode extends JavaScriptBaseNode {
 
     /**
@@ -295,8 +296,8 @@ protected Object doOverloadedString(JSOverloadedOperatorsObject left,
             return performOverloaded(callNode, operatorImplementation, left, right);
         }
 
-        @Specialization(guards = "isNullOrUndefined(right)")
-        protected Object doOverloadedNullish(@SuppressWarnings("unused") JSOverloadedOperatorsObject left, @SuppressWarnings("unused") Object right) {
+        @Specialization(guards = "isUnsupportedPrimitive(right)")
+        protected Object doOverloadedUnsupportedPrimitive(@SuppressWarnings("unused") JSOverloadedOperatorsObject left, @SuppressWarnings("unused") Object right) {
             return missingImplementation();
         }
 
@@ -327,8 +328,8 @@ protected Object doStringOverloaded(Object left,
             return performOverloaded(callNode, operatorImplementation, left, right);
         }
 
-        @Specialization(guards = "isNullOrUndefined(left)")
-        protected Object doNullishOverloaded(@SuppressWarnings("unused") Object left, @SuppressWarnings("unused") JSOverloadedOperatorsObject right) {
+        @Specialization(guards = "isUnsupportedPrimitive(left)")
+        protected Object doUnsupportedPrimitiveOverloaded(@SuppressWarnings("unused") Object left, @SuppressWarnings("unused") JSOverloadedOperatorsObject right) {
             return missingImplementation();
         }
 

Diff for: graal-js/src/com.oracle.truffle.js/src/com/oracle/truffle/js/runtime/objects/OperatorSet.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021, 2021, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2021, 2024, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * The Universal Permissive License (UPL), Version 1.0
@@ -43,6 +43,7 @@
 import java.util.Arrays;
 import java.util.List;
 
+import com.oracle.truffle.js.runtime.Symbol;
 import org.graalvm.collections.EconomicMap;
 import org.graalvm.collections.EconomicSet;
 
@@ -140,7 +141,7 @@ public static Object getOperatorImplementation(JSOverloadedOperatorsObject opera
 
     @TruffleBoundary
     public static Object getOperatorImplementation(Object left, Object right, TruffleString operatorName) {
-        if (JSRuntime.isNullOrUndefined(left) || JSRuntime.isNullOrUndefined(right)) {
+        if (isUnsupportedPrimitive(left) || isUnsupportedPrimitive(right)) {
             return null;
         }
         OperatorSet leftOperatorSet = getOperatorSet(left);
@@ -164,4 +165,8 @@ public static Object getOperatorImplementation(Object left, Object right, Truffl
             }
         }
     }
+
+    public static boolean isUnsupportedPrimitive(Object value) {
+        return JSRuntime.isNullOrUndefined(value) || value instanceof Boolean || value instanceof Symbol;
+    }
 }