Expose construction capabilities with code for JsArrayBuffer (#1890)

* Expose construction capabilities with code for JsArrayBuffer
* improve write/read performance for byte[]

Jint.Tests.PublicInterface/ArrayBufferTests.cs

@@ -0,0 +1,73 @@
+using Jint.Native;
+using Jint.Runtime.Interop;
+
+namespace Jint.Tests.Runtime;
+
+public class ArrayBufferTests
+{
+    [Fact]
+    public void CanConvertByteArrayToArrayBuffer()
+    {
+        var engine = new Engine(o => o.AddObjectConverter(new BytesToArrayBufferConverter()));
+
+        var bytes = new byte[] { 17 };
+        engine.SetValue("buffer", bytes);
+
+        engine.Evaluate("var a = new Uint8Array(buffer)");
+
+        var typedArray = (JsTypedArray) engine.GetValue("a");
+        Assert.Equal((uint) 1, typedArray.Length);
+        Assert.Equal(17, typedArray[0]);
+        Assert.Equal(JsValue.Undefined, typedArray[1]);
+
+        Assert.Equal(1, engine.Evaluate("a.length"));
+        Assert.Equal(17, engine.Evaluate("a[0]"));
+        Assert.Equal(JsValue.Undefined, engine.Evaluate("a[1]"));
+
+        bytes[0] = 42;
+        Assert.Equal(42, engine.Evaluate("a[0]"));
+    }
+
+    [Fact]
+    public void CanCreateArrayBufferAndTypedArrayUsingCode()
+    {
+        var engine = new Engine();
+
+        var jsArrayBuffer = engine.Intrinsics.ArrayBuffer.Construct(1);
+        var jsTypedArray = engine.Intrinsics.Uint8Array.Construct(jsArrayBuffer);
+        jsTypedArray[0] = 17;
+
+        engine.SetValue("buffer", jsArrayBuffer);
+        engine.SetValue("a", jsTypedArray);
+
+        var typedArray = (JsTypedArray) engine.GetValue("a");
+        Assert.Equal((uint) 1, typedArray.Length);
+        Assert.Equal(17, typedArray[0]);
+        Assert.Equal(JsValue.Undefined, typedArray[1]);
+
+        Assert.Equal(1, engine.Evaluate("a.length"));
+        Assert.Equal(17, engine.Evaluate("a[0]"));
+        Assert.Equal(JsValue.Undefined, engine.Evaluate("a[1]"));
+    }
+
+    /// <summary>
+    /// Converts a byte array to an ArrayBuffer.
+    /// </summary>
+    private sealed class BytesToArrayBufferConverter : IObjectConverter
+    {
+        public bool TryConvert(Engine engine, object value, out JsValue result)
+        {
+            if (value is byte[] bytes)
+            {
+                var buffer = engine.Intrinsics.ArrayBuffer.Construct(bytes);
+                result = buffer;
+                return true;
+            }
+
+            // TODO: provide similar implementation for Memory<byte> that will affect how ArrayBufferInstance works (offset)
+
+            result = JsValue.Null;
+            return false;
+        }
+    }
+}

Jint/Native/ArrayBuffer/ArrayBufferConstructor.cs

@@ -11,7 +11,7 @@ namespace Jint.Native.ArrayBuffer;
 /// <summary>
 /// https://tc39.es/ecma262/#sec-properties-of-the-arraybuffer-constructor
 /// </summary>
-internal sealed class ArrayBufferConstructor : Constructor
+public sealed class ArrayBufferConstructor : Constructor
 {
     private static readonly JsString _functionName = new("ArrayBuffer");
 
@@ -47,20 +47,19 @@ protected override void Initialize()
     }
 
     /// <summary>
-    /// https://tc39.es/ecma262/#sec-arraybuffer.isview
+    /// Constructs a new JsArrayBuffer instance and takes ownership of the given byte array and uses it as backing store.
     /// </summary>
-    private static JsValue IsView(JsValue thisObject, JsValue[] arguments)
+    public JsArrayBuffer Construct(byte[] data)
     {
-        var arg = arguments.At(0);
-        return arg is JsDataView or JsTypedArray;
+        return CreateJsArrayBuffer(this, data, byteLength: (ulong) data.Length, maxByteLength: null);
     }
 
     /// <summary>
-    /// https://tc39.es/ecma262/#sec-get-arraybuffer-@@species
+    /// Constructs a new JsArrayBuffer with given byte length and optional max byte length.
     /// </summary>
-    private static JsValue Species(JsValue thisObject, JsValue[] arguments)
+    public JsArrayBuffer Construct(ulong byteLength, uint? maxByteLength = null)
     {
-        return thisObject;
+        return AllocateArrayBuffer(this, byteLength, maxByteLength);
     }
 
     public override ObjectInstance Construct(JsValue[] arguments, JsValue newTarget)
@@ -78,6 +77,23 @@ public override ObjectInstance Construct(JsValue[] arguments, JsValue newTarget)
         return AllocateArrayBuffer(newTarget, byteLength, requestedMaxByteLength);
     }
 
+    /// <summary>
+    /// https://tc39.es/ecma262/#sec-get-arraybuffer-@@species
+    /// </summary>
+    private static JsValue Species(JsValue thisObject, JsValue[] arguments)
+    {
+        return thisObject;
+    }
+
+    /// <summary>
+    /// https://tc39.es/ecma262/#sec-arraybuffer.isview
+    /// </summary>
+    private static JsValue IsView(JsValue thisObject, JsValue[] arguments)
+    {
+        var arg = arguments.At(0);
+        return arg is JsDataView or JsTypedArray;
+    }
+
     /// <summary>
     /// https://tc39.es/ecma262/#sec-allocatearraybuffer
     /// </summary>
@@ -90,15 +106,27 @@ internal JsArrayBuffer AllocateArrayBuffer(JsValue constructor, ulong byteLength
             ExceptionHelper.ThrowRangeError(_realm);
         }
 
+        return CreateJsArrayBuffer(constructor, block: null, byteLength, maxByteLength);
+    }
+
+    private JsArrayBuffer CreateJsArrayBuffer(JsValue constructor, byte[]? block, ulong byteLength, uint? maxByteLength)
+    {
         var obj = OrdinaryCreateFromConstructor(
             constructor,
             static intrinsics => intrinsics.ArrayBuffer.PrototypeObject,
-            static (engine, _, state) => new JsArrayBuffer(engine, state!.Item1),
-            new Tuple<uint?>(maxByteLength));
+            static (engine, _, state) =>
+            {
+                var buffer = new JsArrayBuffer(engine, [], state.MaxByteLength)
+                {
+                    _arrayBufferData = state.Block ?? (state.ByteLength > 0 ? JsArrayBuffer.CreateByteDataBlock(engine.Realm, state.ByteLength) : []),
+                };
 
-        var block = byteLength > 0 ? JsArrayBuffer.CreateByteDataBlock(_realm, byteLength) : System.Array.Empty<byte>();
-        obj._arrayBufferData = block;
+                return buffer;
+            },
+            new ConstructState(block, byteLength, maxByteLength));
 
         return obj;
     }
+
+    private readonly record struct ConstructState(byte[]? Block, ulong ByteLength, uint? MaxByteLength);
 }

Jint/Native/JsArrayBuffer.cs

@@ -20,13 +20,15 @@ public class JsArrayBuffer : ObjectInstance
 
     internal JsArrayBuffer(
         Engine engine,
+        byte[] data,
         uint? arrayBufferMaxByteLength = null) : base(engine)
     {
         if (arrayBufferMaxByteLength is > int.MaxValue)
         {
             ExceptionHelper.ThrowRangeError(engine.Realm, "arrayBufferMaxByteLength cannot be larger than int32.MaxValue");
         }
 
+        _arrayBufferData = data;
         _arrayBufferMaxByteLength = (int?) arrayBufferMaxByteLength;
     }
 
@@ -104,6 +106,11 @@ internal TypedArrayValue GetValueFromBuffer(
     /// </summary>
     internal TypedArrayValue RawBytesToNumeric(TypedArrayElementType type, int byteIndex, bool isLittleEndian)
     {
+        if (type is TypedArrayElementType.Uint8 or TypedArrayElementType.Uint8C)
+        {
+            return new TypedArrayValue(Types.Number, _arrayBufferData![byteIndex], default);
+        }
+
         var elementSize = type.GetElementSize();
         var rawBytes = _arrayBufferData!;
 
@@ -176,8 +183,6 @@ internal TypedArrayValue RawBytesToNumeric(TypedArrayElementType type, int byteI
         TypedArrayValue? arrayValue = type switch
         {
             TypedArrayElementType.Int8 => (sbyte) rawBytes[byteIndex],
-            TypedArrayElementType.Uint8 => rawBytes[byteIndex],
-            TypedArrayElementType.Uint8C =>rawBytes[byteIndex],
             TypedArrayElementType.Int16 => isLittleEndian
                 ? (short) (rawBytes[byteIndex] | (rawBytes[byteIndex + 1] << 8))
                 : (short) (rawBytes[byteIndex + 1] | (rawBytes[byteIndex] << 8)),
@@ -212,10 +217,21 @@ internal void SetValueInBuffer(
         ArrayBufferOrder order,
         bool? isLittleEndian = null)
     {
+        if (type is TypedArrayElementType.Uint8)
+        {
+            var doubleValue = value.DoubleValue;
+            var intValue = double.IsNaN(doubleValue) || doubleValue == 0 || double.IsInfinity(doubleValue)
+                ? 0
+                : (long) doubleValue;
+
+            _arrayBufferData![byteIndex] = (byte) intValue;
+            return;
+        }
+
         var block = _arrayBufferData!;
         // If isLittleEndian is not present, set isLittleEndian to the value of the [[LittleEndian]] field of the surrounding agent's Agent Record.
         var rawBytes = NumericToRawBytes(type, value, isLittleEndian ?? BitConverter.IsLittleEndian);
-        System.Array.Copy(rawBytes, 0, block,  byteIndex, type.GetElementSize());
+        System.Array.Copy(rawBytes, 0, block, byteIndex, type.GetElementSize());
     }
 
     private byte[] NumericToRawBytes(TypedArrayElementType type, TypedArrayValue value, bool isLittleEndian)
@@ -266,7 +282,7 @@ private byte[] NumericToRawBytes(TypedArrayElementType type, TypedArrayValue val
                     rawBytes[0] = (byte) intValue;
                     break;
                 case TypedArrayElementType.Uint8C:
-                    rawBytes[0] = (byte) TypeConverter.ToUint8Clamp(value.DoubleValue);
+                    rawBytes[0] = TypeConverter.ToUint8Clamp(value.DoubleValue);
                     break;
                 case TypedArrayElementType.Int16:
 #if !NETSTANDARD2_1

Jint/Native/JsSharedArrayBuffer.cs

@@ -11,8 +11,9 @@ internal sealed class JsSharedArrayBuffer : JsArrayBuffer
 
     internal JsSharedArrayBuffer(
         Engine engine,
+        byte[] data,
         uint? arrayBufferMaxByteLength,
-        uint arrayBufferByteLengthData) : base(engine, arrayBufferMaxByteLength)
+        uint arrayBufferByteLengthData) : base(engine, data, arrayBufferMaxByteLength)
     {
         if (arrayBufferByteLengthData > int.MaxValue)
         {

Jint/Native/JsTypedArray.cs

@@ -28,10 +28,7 @@ internal JsTypedArray(
             uint length) : base(engine)
         {
             _intrinsics = intrinsics;
-            _viewedArrayBuffer = new JsArrayBuffer(engine)
-            {
-                _arrayBufferData = System.Array.Empty<byte>()
-            };
+            _viewedArrayBuffer = new JsArrayBuffer(engine, []);
 
             _arrayElementType = type;
             _contentType = type != TypedArrayElementType.BigInt64 && type != TypedArrayElementType.BigUint64

Jint/Native/SharedArrayBuffer/SharedArrayBufferConstructor.cs

@@ -94,16 +94,23 @@ private JsSharedArrayBuffer AllocateSharedArrayBuffer(JsValue constructor, uint
             ExceptionHelper.ThrowRangeError(_realm);
         }
 
+        var allocLength = maxByteLength.GetValueOrDefault(byteLength);
+
         var obj = OrdinaryCreateFromConstructor(
             constructor,
             static intrinsics => intrinsics.SharedArrayBuffer.PrototypeObject,
-            static (engine, _, state) => new JsSharedArrayBuffer(engine, state!.Item1, state.Item2),
-            new Tuple<uint?, uint>(maxByteLength, byteLength));
-
-        var allocLength = maxByteLength.GetValueOrDefault(byteLength);
-        var block = JsSharedArrayBuffer.CreateSharedByteDataBlock(_realm, allocLength);
-        obj._arrayBufferData = block;
+            static (engine, _, state) =>
+            {
+                var buffer = new JsSharedArrayBuffer(engine, [], state.MaxByteLength, state.ArrayBufferByteLengthData)
+                {
+                    _arrayBufferData = state.Block ?? (state.ByteLength > 0 ? JsSharedArrayBuffer.CreateSharedByteDataBlock(engine.Realm, state.ByteLength) : []),
+                };
+                return buffer;
+            },
+            new ConstructState(Block: null, allocLength, maxByteLength, byteLength));
 
         return obj;
     }
+
+    private readonly record struct ConstructState(byte[]? Block, uint ByteLength, uint? MaxByteLength, uint ArrayBufferByteLengthData);
 }