[GR-44198] Adopt BigInteger Interop Support.

PullRequest: js/2725

Author: woess

CHANGELOG.md

@@ -15,6 +15,12 @@ See [version roadmap](https://www.graalvm.org/release-notes/version-roadmap/) fo
 * Implemented the [Symbols as WeakMap keys](https://github.com/tc39/proposal-symbols-as-weakmap-keys) proposal. It is available in ECMAScript staging mode (`--js.ecmascript-version=staging`).
 * Implemented the [ArrayBuffer.prototype.transfer and friends](https://github.com/tc39/proposal-arraybuffer-transfer) proposal. It is available in ECMAScript staging mode (`--js.ecmascript-version=staging`).
 * Implemented the [Change Array by copy](https://github.com/tc39/proposal-change-array-by-copy) proposal. It is available in ECMAScript staging mode (`--js.ecmascript-version=staging`).
+* Added BigInteger interop support.
+  Note that foreign BigIntegers require an explicit type cast using the `BigInt` function to opt into JS BigInt semantics.
+  The default semantics is to treat all foreign numbers like JS Number values, regardless of the original value or type.
+  Arithmetic operators perform an implicit lossy conversion to double; mixing a JS BigInt with any non-JS number always throws.
+  Comparison operators attempt to do a precise value comparison where possible.
+  JS BigInt values can now be converted to `java.math.BigInteger` host objects, although a [target type mapping](https://www.graalvm.org/sdk/javadoc/org/graalvm/polyglot/HostAccess.Builder.html#targetTypeMapping-java.lang.Class-java.lang.Class-java.util.function.Predicate-java.util.function.Function-) may still be necessary to ensure consistent type mapping if the target type is ambiguous or absent.
 
 ## Version 22.3.0
 * Implemented the [WebAssembly multi-value](https://github.com/WebAssembly/multi-value) proposal.

graal-js/src/com.oracle.truffle.js.parser/src/com/oracle/truffle/js/parser/GraalJSTranslator.java

@@ -3668,7 +3668,7 @@ public JavaScriptNode enterWithNode(com.oracle.js.parser.ir.WithNode withNode) {
         Environment withParentEnv = (function.hasClosures() || function.hasEval()) ? new BlockEnvironment(environment, factory, context) : environment;
         try (EnvironmentCloseable withParent = new EnvironmentCloseable(withParentEnv)) {
             JavaScriptNode withExpression = transform(withNode.getExpression());
-            JavaScriptNode toObject = factory.createToObjectFromWith(context, withExpression, true);
+            JavaScriptNode toObject = factory.createToObjectForWithStatement(context, withExpression);
             InternalSlotId withVarName = makeUniqueTempVarNameForStatement(Strings.WITH, withNode.getLineNumber());
             environment.declareInternalSlot(withVarName);
             JavaScriptNode writeWith = environment.findInternalSlot(withVarName).createWriteNode(toObject);

graal-js/src/com.oracle.truffle.js.snapshot/src/com/oracle/truffle/js/snapshot/Recording.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018, 2022, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2023, 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
@@ -1110,9 +1110,10 @@ private static class VarIdTable {
         private final Map<Object, Integer> varIndexMap = new HashMap<>();
 
         private static Object getKey(Object node) {
-            if (node == null || JSRuntime.isJSPrimitive(node) || node.getClass().isEnum()) {
+            if (node == null || JSRuntime.isJSPrimitive(node) || node instanceof Long || node.getClass().isEnum()) {
                 return node;
             } else {
+                assert !JSRuntime.isJavaPrimitive(node) : node;
                 class IdentityKey {
                     private final Object obj;
 
@@ -1295,7 +1296,7 @@ private Inst dumpSourceSection(SourceSection arg) {
 
     private Inst encode(Object arg, Class<?> declaredType, Type genericType) {
         Inst enc;
-        if (arg == null || JSRuntime.isJSPrimitive(arg) || arg == Dead.instance()) {
+        if (arg == null || JSRuntime.isJSPrimitive(arg) || arg instanceof Long || arg == Dead.instance()) {
             enc = dumpConst(arg, unboxedType(arg, declaredType));
         } else if (arg.getClass().isEnum()) {
             enc = dumpConst(arg, declaredType);

graal-js/src/com.oracle.truffle.js.test.sdk/src/com/oracle/truffle/js/test/sdk/tck/JavaScriptTCKLanguageProvider.java

@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) 2023, 2023, 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.
+ */
+
+/*
+ * Test java.math.BigInteger interop.
+ */
+
+load('../assert.js');
+
+const BigInteger = java.math.BigInteger;
+
+let zero = BigInteger.ZERO;
+let small= BigInteger.valueOf(42);
+let long = new BigInteger("9223372036854775807"); // Long.MAX_VALUE
+let big  = new BigInteger("100000000000000000000"); // 10n ** 20n
+let huge = BigInteger.valueOf(2).pow(1000);
+let bigIntegers = [zero, small, long, big, huge];
+
+function nonStrictThis() {
+    return this;
+}
+
+function int64(b) {
+    return b.longValue();
+}
+
+function uint64(b) {
+    return b.mod(BigInteger.ONE.shiftLeft(64));
+}
+
+for (let b of bigIntegers) {
+    // typeof value is 'number' for java.math.BigInteger
+    assertSame('number', typeof b);
+    assertTrue(typeof b == 'number');
+    assertSame('number', typeof Object(b));
+    assertTrue(typeof Object(b) == 'number');
+    assertSame('number', typeof nonStrictThis.call(b));
+    assertTrue(typeof nonStrictThis.call(b) == 'number');
+
+    assertTrue(b == b.multiply(BigInteger.ONE));
+    // ToObject should keep foreign members
+    assertTrue(b == Object(b).multiply(BigInteger.ONE));
+    assertTrue(b == nonStrictThis.call(b).multiply(BigInteger.ONE));
+
+    assertTrue(b == Object(b));
+    assertTrue(Object(b) == b);
+    assertTrue(b == BigInt(b));
+    assertTrue(BigInt(b) == b);
+
+    // ToObject does not wrap BigInteger.
+    assertTrue(b === Object(b));
+
+    // Number (double) coercion
+    assertSame(Number(b), Number.prototype.valueOf.call(b));
+    assertSame(String(+b), Number.prototype.toString.call(b));
+
+    // Avoid double coercion in ToString.
+    assertSame(b.toString(), String(b));
+
+    // ToBigInt does not accept Number, require explicit conversion for now.
+    let i64a = new BigInt64Array(1);
+    let u64a = new BigUint64Array(1);
+    let cast = BigInt(b);
+    i64a[0] = cast;
+    u64a[0] = cast;
+    assertSame(i64a[0], BigInt.asIntN(64, cast));
+    assertSame(u64a[0], BigInt.asUintN(64, cast));
+    assertTrue(i64a[0] == int64(b));
+    assertTrue(u64a[0] == uint64(b));
+}

graal-js/src/com.oracle.truffle.js.test/js/interop/java_math_biginteger.js

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019, 2022, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2019, 2023, 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
@@ -40,16 +40,30 @@
  */
 package com.oracle.truffle.js.test;
 
-import com.oracle.truffle.js.runtime.Strings;
+import static org.hamcrest.CoreMatchers.startsWith;
+import static org.junit.Assert.assertThat;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import java.util.function.Consumer;
+
 import org.graalvm.polyglot.Context;
 import org.graalvm.polyglot.Engine;
+import org.graalvm.polyglot.PolyglotException;
 import org.junit.After;
 import org.junit.Assert;
 import org.junit.Before;
 
 import com.oracle.truffle.js.lang.JavaScriptLanguage;
+import com.oracle.truffle.js.runtime.JSErrorType;
+import com.oracle.truffle.js.runtime.Strings;
 
 public abstract class JSTest {
+
+    static {
+        System.setProperty("polyglot.engine.WarnInterpreterOnly", "false");
+    }
+
     protected TestHelper testHelper;
 
     @Before
@@ -73,4 +87,23 @@ public static Engine.Builder newEngineBuilder() {
     public static void assertTStringEquals(String a, Object b) {
         Assert.assertEquals(Strings.fromJavaString(a), b);
     }
+
+    public static void assertThrows(Runnable test, Consumer<PolyglotException> exceptionVerifier) {
+        try {
+            test.run();
+            fail("should have thrown");
+        } catch (PolyglotException e) {
+            exceptionVerifier.accept(e);
+        }
+    }
+
+    public static void assertThrows(Runnable test, JSErrorType expectedJSError) {
+        try {
+            test.run();
+            fail("should have thrown " + expectedJSError.name());
+        } catch (PolyglotException e) {
+            assertTrue(e.isGuestException());
+            assertThat(e.getMessage(), startsWith(expectedJSError.name()));
+        }
+    }
 }