Cover mutating TypedArray methods backed by an immutable ArrayBuffer

Author: gibson042

test/built-ins/TypedArray/prototype/copyWithin/immutable-buffer.js

@@ -0,0 +1,59 @@
+// Copyright (C) 2025 Richard Gibson. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-%typedarray%.prototype.copywithin
+description: Throws a TypeError exception when the backing buffer is immutable
+info: |
+  %TypedArray%.prototype.copyWithin ( target, start [ , end ] )
+  1. Let O be the this value.
+  2. Let taRecord be ? ValidateTypedArray(O, ~seq-cst~, ~write~).
+  3. Let len be TypedArrayLength(taRecord).
+  4. Let relativeTarget be ? ToIntegerOrInfinity(target).
+  5. If relativeTarget = -∞, let targetIndex be 0.
+  6. Else if relativeTarget < 0, let targetIndex be max(len + relativeTarget, 0).
+  7. Else, let targetIndex be min(relativeTarget, len).
+  8. Let relativeStart be ? ToIntegerOrInfinity(start).
+  9. If relativeStart = -∞, let startIndex be 0.
+  10. Else if relativeStart < 0, let startIndex be max(len + relativeStart, 0).
+  11. Else, let startIndex be min(relativeStart, len).
+  12. If end is undefined, let relativeEnd be len; else let relativeEnd be ? ToIntegerOrInfinity(end).
+
+  ValidateTypedArray ( O, order [ , accessMode ] )
+  1. If accessMode is not present, set accessMode to read.
+  2. Perform ? RequireInternalSlot(O, [[TypedArrayName]]).
+  3. Assert: O has a [[ViewedArrayBuffer]] internal slot.
+  4. If accessMode is ~write~ and IsImmutableBuffer(O.[[ViewedArrayBuffer]]) is true, throw a TypeError exception.
+features: [TypedArray, immutable-arraybuffer]
+includes: [testTypedArray.js, compareArray.js]
+---*/
+
+testWithAllTypedArrayConstructors((TA, makeCtorArg) => {
+  var calls = [];
+
+  var ta = new TA(makeCtorArg(["1", "2", "3", "4"]));
+  var target = {
+    valueOf() {
+      calls.push("target.valueOf");
+      return 1;
+    }
+  };
+  var start = {
+    valueOf() {
+      calls.push("start.valueOf");
+      return 2;
+    }
+  };
+  var end = {
+    valueOf() {
+      calls.push("end.valueOf");
+      return 2;
+    }
+  };
+
+  assert.throws(TypeError, function() {
+    ta.copyWithin(target, start, end);
+  });
+  assert.compareArray(calls, [], "Must verify mutability before reading arguments.");
+  assert.compareArray(ta, new TA(["1", "2", "3", "4"]), "Must not mutate contents.");
+}, null, ["immutable"]);

test/built-ins/TypedArray/prototype/fill/immutable-buffer.js

@@ -0,0 +1,57 @@
+// Copyright (C) 2025 Richard Gibson. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-%typedarray%.prototype.fill
+description: Throws a TypeError exception when the backing buffer is immutable
+info: |
+  %TypedArray%.prototype.fill ( value [ , start [ , end ] ] )
+  1. Let O be the this value.
+  2. Let taRecord be ? ValidateTypedArray(O, ~seq-cst~, ~write~).
+  3. Let len be TypedArrayLength(taRecord).
+  4. If O.[[ContentType]] is bigint, set value to ? ToBigInt(value).
+  5. Otherwise, set value to ? ToNumber(value).
+  6. Let relativeStart be ? ToIntegerOrInfinity(start).
+  7. If relativeStart = -∞, let startIndex be 0.
+  8. Else if relativeStart < 0, let startIndex be max(len + relativeStart, 0).
+  9. Else, let startIndex be min(relativeStart, len).
+  10. If end is undefined, let relativeEnd be len; else let relativeEnd be ? ToIntegerOrInfinity(end).
+
+  ValidateTypedArray ( O, order [ , accessMode ] )
+  1. If accessMode is not present, set accessMode to read.
+  2. Perform ? RequireInternalSlot(O, [[TypedArrayName]]).
+  3. Assert: O has a [[ViewedArrayBuffer]] internal slot.
+  4. If accessMode is ~write~ and IsImmutableBuffer(O.[[ViewedArrayBuffer]]) is true, throw a TypeError exception.
+features: [TypedArray, immutable-arraybuffer]
+includes: [testTypedArray.js, compareArray.js]
+---*/
+
+testWithAllTypedArrayConstructors((TA, makeCtorArg) => {
+  var calls = [];
+
+  var ta = new TA(makeCtorArg(["1", "2", "3", "4"]));
+  var value = {
+    valueOf() {
+      calls.push("value.valueOf");
+      return "8";
+    }
+  };
+  var start = {
+    valueOf() {
+      calls.push("start.valueOf");
+      return 1;
+    }
+  };
+  var end = {
+    valueOf() {
+      calls.push("end.valueOf");
+      return 1;
+    }
+  };
+
+  assert.throws(TypeError, function() {
+    ta.fill(value, start, end);
+  });
+  assert.compareArray(calls, [], "Must verify mutability before reading arguments.");
+  assert.compareArray(ta, new TA(["1", "2", "3", "4"]), "Must not mutate contents.");
+}, null, ["immutable"]);

test/built-ins/TypedArray/prototype/reverse/immutable-buffer.js

@@ -0,0 +1,31 @@
+// Copyright (C) 2025 Richard Gibson. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-%typedarray%.prototype.reverse
+description: Throws a TypeError exception when the backing buffer is immutable
+info: |
+  %TypedArray%.prototype.reverse ( )
+  1. Let O be the this value.
+  2. Let taRecord be ? ValidateTypedArray(O, ~seq-cst~, ~write~).
+
+  ValidateTypedArray ( O, order [ , accessMode ] )
+  1. If accessMode is not present, set accessMode to read.
+  2. Perform ? RequireInternalSlot(O, [[TypedArrayName]]).
+  3. Assert: O has a [[ViewedArrayBuffer]] internal slot.
+  4. If accessMode is ~write~ and IsImmutableBuffer(O.[[ViewedArrayBuffer]]) is true, throw a TypeError exception.
+features: [TypedArray, immutable-arraybuffer]
+includes: [testTypedArray.js, compareArray.js]
+---*/
+
+testWithAllTypedArrayConstructors((TA, makeCtorArg) => {
+  var calls = [];
+
+  var ta = new TA(makeCtorArg(["1", "2", "3", "4"]));
+
+  assert.throws(TypeError, function() {
+    ta.reverse();
+  });
+  assert.compareArray(calls, [], "Must verify mutability before reading arguments.");
+  assert.compareArray(ta, new TA(["1", "2", "3", "4"]), "Must not mutate contents.");
+}, null, ["immutable"]);

test/built-ins/TypedArray/prototype/set/immutable-buffer.js

@@ -0,0 +1,45 @@
+// Copyright (C) 2025 Richard Gibson. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-%typedarray%.prototype.set
+description: Throws a TypeError exception when the backing buffer is immutable
+info: |
+  %TypedArray%.prototype.set ( source [ , offset ] )
+  1. Let target be the this value.
+  ...
+  3. Perform ? RequireInternalSlot(target, [[TypedArrayName]]).
+  4. Assert: target has a [[ViewedArrayBuffer]] internal slot.
+  5. If IsImmutableBuffer(target.[[ViewedArrayBuffer]]) is true, throw a TypeError exception.
+  6. Let targetOffset be ? ToIntegerOrInfinity(offset).
+features: [TypedArray, immutable-arraybuffer]
+includes: [testTypedArray.js, compareArray.js]
+---*/
+
+testWithAllTypedArrayConstructors((TA, makeCtorArg) => {
+  var calls = [];
+
+  var ta = new TA(makeCtorArg(["1", "2", "3", "4"]));
+  var source = {
+    get length() {
+      calls.push("get source.length");
+      return 1;
+    },
+    get 0() {
+      calls.push("get source[0]");
+      return "8";
+    },
+  };
+  var offset = {
+    valueOf() {
+      calls.push("offset.valueOf");
+      return 1;
+    }
+  };
+
+  assert.throws(TypeError, function() {
+    ta.set(source, offset);
+  });
+  assert.compareArray(calls, [], "Must verify mutability before reading arguments.");
+  assert.compareArray(ta, new TA(["1", "2", "3", "4"]), "Must not mutate contents.");
+}, null, ["immutable"]);

test/built-ins/TypedArray/prototype/sort/immutable-buffer.js

@@ -0,0 +1,47 @@
+// Copyright (C) 2025 Richard Gibson. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-%typedarray%.prototype.sort
+description: Throws a TypeError exception when the backing buffer is immutable
+info: |
+  %TypedArray%.prototype.sort ( comparator )
+  1. If comparator is not undefined and IsCallable(comparator) is false, throw a TypeError exception.
+  2. Let obj be the this value.
+  3. Let taRecord be ? ValidateTypedArray(obj, ~seq-cst~, ~write~).
+  4. Let len be TypedArrayLength(taRecord).
+  5. NOTE: The following closure performs a numeric comparison rather than the string comparison used in 23.1.3.30.
+  6. Let SortCompare be a new Abstract Closure with parameters (x, y) that captures comparator and performs the following steps when called:
+     a. Return ? CompareTypedArrayElements(x, y, comparator).
+  7. Let sortedList be ? SortIndexedProperties(obj, len, SortCompare, ~read-through-holes~).
+
+  ValidateTypedArray ( O, order [ , accessMode ] )
+  1. If accessMode is not present, set accessMode to read.
+  2. Perform ? RequireInternalSlot(O, [[TypedArrayName]]).
+  3. Assert: O has a [[ViewedArrayBuffer]] internal slot.
+  4. If accessMode is ~write~ and IsImmutableBuffer(O.[[ViewedArrayBuffer]]) is true, throw a TypeError exception.
+features: [TypedArray, immutable-arraybuffer]
+includes: [testTypedArray.js, compareArray.js]
+---*/
+
+testWithAllTypedArrayConstructors((TA, makeCtorArg) => {
+  var calls = [];
+
+  var ta = new TA(makeCtorArg(["1", "2", "3", "4"]));
+  function comparator() {
+    calls.push("compare");
+    return 0;
+  }
+
+  assert.throws(TypeError, function() {
+    ta.sort(comparator);
+  });
+  assert.compareArray(calls, [], "Must verify mutability before comparing.");
+  assert.compareArray(ta, new TA(["1", "2", "3", "4"]), "Must not mutate contents.");
+
+  calls = [];
+  var empty = new TA(makeCtorArg(0));
+  assert.throws(TypeError, function() {
+    empty.sort(comparator);
+  }, "Must verify mutability even when receiver is length 0");
+}, null, ["immutable"]);