Add ArrayBuffer detach

This passes pretty much every test related to detached array buffers, with the only ones failing being methods we don't support yet.

Author: camnwalter

rhino/src/main/java/org/mozilla/javascript/AbstractEcmaObjectOperations.java

@@ -361,7 +361,7 @@ static List<Object> createListFromArrayLike(
      * <p><a href="https://262.ecma-international.org/12.0/#sec-lengthofarraylike">7.3.18
      * LengthOfArrayLike (obj)</a>
      */
-    static long lengthOfArrayLike(Context cx, Scriptable o) {
+    public static long lengthOfArrayLike(Context cx, Scriptable o) {
         Object value = ScriptableObject.getProperty(o, "length");
         long len = ScriptRuntime.toLength(new Object[] {value}, 0);
         return len;

rhino/src/main/java/org/mozilla/javascript/NativeArrayIterator.java

@@ -6,6 +6,8 @@
 
 package org.mozilla.javascript;
 
+import org.mozilla.javascript.typedarrays.NativeTypedArrayView;
+
 public final class NativeArrayIterator extends ES6Iterator {
     public enum ARRAY_ITERATOR_TYPE {
         ENTRIES,
@@ -41,6 +43,12 @@ public String getClassName() {
 
     @Override
     protected boolean isDone(Context cx, Scriptable scope) {
+        if (arrayLike instanceof NativeTypedArrayView) {
+            NativeTypedArrayView<?> typedArray = (NativeTypedArrayView<?>) arrayLike;
+            if (typedArray.isTypedArrayOutOfBounds()) {
+                throw ScriptRuntime.typeErrorById("msg.typed.array.out.of.bounds");
+            }
+        }
         return index >= NativeArray.getLengthProperty(cx, arrayLike);
     }
 

rhino/src/main/java/org/mozilla/javascript/NativeReflect.java

@@ -216,8 +216,18 @@ private static Object defineProperty(
         ScriptableObject target = checkTarget(args);
         ScriptableObject desc = ScriptableObject.ensureScriptableObject(args[2]);
 
+        Object key = args[1];
+
         try {
-            return target.defineOwnProperty(cx, args[1], desc);
+            if (key instanceof Symbol) {
+                return target.defineOwnProperty(cx, key, desc);
+            } else {
+                String propertyKey =
+                        ScriptRuntime.toString(
+                                ScriptRuntime.toPrimitive(key, ScriptRuntime.StringClass));
+                return target.defineOwnProperty(cx, propertyKey, desc);
+            }
+
         } catch (EcmaError e) {
             return false;
         }

rhino/src/main/java/org/mozilla/javascript/ScriptRuntime.java

@@ -821,12 +821,12 @@ public static int toIndex(Object val) {
         }
         double integerIndex = toInteger(val);
         if (integerIndex < 0) {
-            throw rangeError("index out of range");
+            throw rangeErrorById("msg.out.of.range.index", integerIndex);
         }
         // ToLength
         double index = Math.min(integerIndex, NativeNumber.MAX_SAFE_INTEGER);
         if (integerIndex != index) {
-            throw rangeError("index out of range");
+            throw rangeErrorById("msg.out.of.range.index", integerIndex);
         }
         return (int) index;
     }

rhino/src/main/java/org/mozilla/javascript/typedarrays/NativeArrayBuffer.java

@@ -27,7 +27,7 @@ public class NativeArrayBuffer extends ScriptableObject {
 
     private static final byte[] EMPTY_BUF = new byte[0];
 
-    final byte[] buffer;
+    byte[] buffer;
 
     @Override
     public String getClassName() {
@@ -56,6 +56,8 @@ public static Object init(Context cx, Scriptable scope, boolean sealed) {
                 DONTENUM | READONLY);
         constructor.definePrototypeProperty(
                 cx, "byteLength", NativeArrayBuffer::js_byteLength, DONTENUM | READONLY);
+        constructor.definePrototypeProperty(
+                cx, "detached", NativeArrayBuffer::js_detached, DONTENUM | READONLY);
         constructor.definePrototypeProperty(
                 SymbolKey.TO_STRING_TAG, "ArrayBuffer", DONTENUM | READONLY);
 
@@ -97,7 +99,7 @@ public NativeArrayBuffer(double len) {
 
     /** Get the number of bytes in the buffer. */
     public int getLength() {
-        return buffer.length;
+        return buffer != null ? buffer.length : 0;
     }
 
     /**
@@ -108,6 +110,14 @@ public byte[] getBuffer() {
         return buffer;
     }
 
+    public void detach() {
+        buffer = null;
+    }
+
+    public boolean isDetached() {
+        return buffer == null;
+    }
+
     /**
      * Return a new buffer that represents a slice of this buffer's content, starting at position
      * "start" and ending at position "end". Both values will be "clamped" as per the JavaScript
@@ -123,9 +133,9 @@ public NativeArrayBuffer slice(double s, double e) {
         // Clamp as per the spec to between 0 and length
         int end =
                 ScriptRuntime.toInt32(
-                        Math.max(0, Math.min(buffer.length, (e < 0 ? buffer.length + e : e))));
+                        Math.max(0, Math.min(getLength(), (e < 0 ? getLength() + e : e))));
         int start =
-                ScriptRuntime.toInt32(Math.min(end, Math.max(0, (s < 0 ? buffer.length + s : s))));
+                ScriptRuntime.toInt32(Math.min(end, Math.max(0, (s < 0 ? getLength() + s : s))));
         int len = end - start;
 
         NativeArrayBuffer newBuf = new NativeArrayBuffer(len);
@@ -154,6 +164,11 @@ private static NativeArrayBuffer js_slice(
             LambdaConstructor defaultConstructor,
             Object[] args) {
         NativeArrayBuffer self = getSelf(thisObj);
+
+        if (self.isDetached()) {
+            throw ScriptRuntime.typeErrorById("msg.arraybuf.detached");
+        }
+
         double start = isArg(args, 0) ? ScriptRuntime.toNumber(args[0]) : 0;
         double end = isArg(args, 1) ? ScriptRuntime.toNumber(args[1]) : self.getLength();
         int endI =
@@ -194,6 +209,10 @@ private static Object js_byteLength(Scriptable thisObj) {
         return getSelf(thisObj).getLength();
     }
 
+    private static Object js_detached(Scriptable thisObj) {
+        return getSelf(thisObj).isDetached();
+    }
+
     private static boolean isArg(Object[] args, int i) {
         return ((args.length > i) && !Undefined.instance.equals(args[i]));
     }

rhino/src/main/java/org/mozilla/javascript/typedarrays/NativeArrayBufferView.java

@@ -29,16 +29,24 @@ public abstract class NativeArrayBufferView extends ScriptableObject {
     /** The length, in bytes, of the portion of the backing array that we use */
     protected final int byteLength;
 
+    protected final boolean outOfRange;
+
     public NativeArrayBufferView() {
         arrayBuffer = new NativeArrayBuffer();
         offset = 0;
         byteLength = 0;
+        outOfRange = false;
     }
 
     protected NativeArrayBufferView(NativeArrayBuffer ab, int offset, int byteLength) {
         this.offset = offset;
         this.byteLength = byteLength;
         this.arrayBuffer = ab;
+
+        int bufferByteLength = arrayBuffer.getLength();
+        int byteOffsetEnd = offset + byteLength;
+
+        outOfRange = offset > bufferByteLength || byteOffsetEnd > bufferByteLength;
     }
 
     /** Return the buffer that backs this view. */

rhino/src/main/java/org/mozilla/javascript/typedarrays/NativeBigInt64Array.java

@@ -18,7 +18,7 @@
  * An array view that stores 64-bit quantities and implements the JavaScript "Float64Array"
  * interface. It also implements List<Double> for direct manipulation in Java.
  */
-public class NativeBigInt64Array extends NativeTypedArrayView<BigInteger> {
+public class NativeBigInt64Array extends NativeBigIntArrayView {
     private static final long serialVersionUID = -1255405650050639335L;
 
     private static final String CLASS_NAME = "BigInt64Array";
@@ -91,10 +91,10 @@ protected Object js_get(int index) {
 
     @Override
     protected Object js_set(int index, Object c) {
+        var val = ScriptRuntime.toBigInt(c);
         if (checkIndex(index)) {
             return Undefined.instance;
         }
-        var val = ScriptRuntime.toBigInt(c);
 
         long base = val.longValue();
 

rhino/src/main/java/org/mozilla/javascript/typedarrays/NativeBigIntArrayView.java

@@ -0,0 +1,19 @@
+package org.mozilla.javascript.typedarrays;
+
+import java.math.BigInteger;
+import org.mozilla.javascript.ScriptRuntime;
+
+public abstract class NativeBigIntArrayView extends NativeTypedArrayView<BigInteger> {
+    private static final long serialVersionUID = -3349222145964894609L;
+
+    protected NativeBigIntArrayView() {}
+
+    protected NativeBigIntArrayView(NativeArrayBuffer ab, int off, int len, int byteLen) {
+        super(ab, off, len, byteLen);
+    }
+
+    @Override
+    protected Object toNumeric(Object num) {
+        return ScriptRuntime.toBigInt(num);
+    }
+}

rhino/src/main/java/org/mozilla/javascript/typedarrays/NativeBigUint64Array.java

@@ -18,7 +18,7 @@
  * An array view that stores 64-bit quantities and implements the JavaScript "Float64Array"
  * interface. It also implements List<Double> for direct manipulation in Java.
  */
-public class NativeBigUint64Array extends NativeTypedArrayView<BigInteger> {
+public class NativeBigUint64Array extends NativeBigIntArrayView {
     private static final long serialVersionUID = -1255405650050639335L;
 
     private static final String CLASS_NAME = "BigUint64Array";
@@ -98,10 +98,10 @@ protected Object js_get(int index) {
 
     @Override
     protected Object js_set(int index, Object c) {
+        var val = ScriptRuntime.toBigInt(c);
         if (checkIndex(index)) {
             return Undefined.instance;
         }
-        var val = ScriptRuntime.toBigInt(c);
 
         long base = val.longValue();