[rab/gsab] Add RAB / GSAB support to various TA.prototype functions

Functions affected:
filter
find
findIndex
findLast
findLastIndex
forEach
reduce
reduceRight

Bug: v8:11111
Change-Id: Ifb40143e5b6ed4a3eb30cb25332e2387009e3274
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/3205421
Commit-Queue: Marja Hölttä <marja@chromium.org>
Reviewed-by: Shu-yu Guo <syg@chromium.org>
Reviewed-by: Jakob Kummerow <jkummerow@chromium.org>
Cr-Commit-Position: refs/heads/main@{#77422}

src/builtins/typed-array-every.tq

@@ -9,13 +9,14 @@ const kBuiltinNameEvery: constexpr string = '%TypedArray%.prototype.every';
 
 // https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.every
 transitioning macro EveryAllElements(implicit context: Context)(
-    array: typed_array::AttachedJSTypedArray, length: uintptr,
+    attachedArrayAndLength: typed_array::AttachedJSTypedArrayAndLength,
     callbackfn: Callable, thisArg: JSAny): Boolean {
-  let witness = typed_array::NewAttachedJSTypedArrayWitness(array);
+  let witness =
+      typed_array::NewAttachedJSTypedArrayWitness(attachedArrayAndLength.array);
 
   // 5. Let k be 0.
   // 6. Repeat, while k < len
-  for (let k: uintptr = 0; k < length; k++) {
+  for (let k: uintptr = 0; k < attachedArrayAndLength.length; k++) {
     // 6a. Let Pk be ! ToString(𝔽(k)).
     // There is no need to cast ToString to load elements.
 
@@ -59,13 +60,12 @@ TypedArrayPrototypeEvery(
     // 3. Let len be IntegerIndexedObjectLength(O).
     const array: JSTypedArray = Cast<JSTypedArray>(receiver)
         otherwise NotTypedArray;
-    const length = LoadJSTypedArrayLengthAndCheckDetached(array)
+    const attachedArrayAndLength = EnsureAttachedAndReadLength(array)
         otherwise IsDetachedOrOutOfBounds;
     // 4. If IsCallable(callbackfn) is false, throw a TypeError exception.
     const callbackfn = Cast<Callable>(arguments[0]) otherwise NotCallable;
     const thisArg = arguments[1];
-    return EveryAllElements(
-        %RawDownCast<AttachedJSTypedArray>(array), length, callbackfn, thisArg);
+    return EveryAllElements(attachedArrayAndLength, callbackfn, thisArg);
   } label NotTypedArray deferred {
     ThrowTypeError(MessageTemplate::kNotTypedArray, kBuiltinNameEvery);
   } label IsDetachedOrOutOfBounds deferred {

src/builtins/typed-array-filter.tq

@@ -13,14 +13,13 @@ transitioning javascript builtin TypedArrayPrototypeFilter(
   try {
     // 1. Let O be the this value.
     // 2. Perform ? ValidateTypedArray(O).
+    // 3. Let len be IntegerIndexedObjectLength(O).
     const array: JSTypedArray = Cast<JSTypedArray>(receiver)
         otherwise ThrowTypeError(
         MessageTemplate::kNotTypedArray, kBuiltinNameFilter);
-    const src = typed_array::EnsureAttached(array) otherwise IsDetached;
-
-    // 3. Let len be O.[[ArrayLength]].
-    const len: uintptr = src.length;
 
+    const attachedArrayAndLength = EnsureAttachedAndReadLength(array)
+        otherwise IsDetachedOrOutOfBounds;
     // 4. If IsCallable(callbackfn) is false, throw a TypeError exception.
     const callbackfn = Cast<Callable>(arguments[0])
         otherwise ThrowTypeError(MessageTemplate::kCalledNonCallable, arguments[0]);
@@ -32,19 +31,20 @@ transitioning javascript builtin TypedArrayPrototypeFilter(
     // TODO(v8:4153): Support huge TypedArrays here. (growable fixed arrays
     // can't be longer than kMaxSmiValue).
     let kept = growable_fixed_array::NewGrowableFixedArray();
-    let witness = typed_array::NewAttachedJSTypedArrayWitness(src);
+    let witness = typed_array::NewAttachedJSTypedArrayWitness(
+        attachedArrayAndLength.array);
 
     // 7. Let k be 0.
     // 8. Let captured be 0.
     // 9. Repeat, while k < len
-    for (let k: uintptr = 0; k < len; k++) {
+    for (let k: uintptr = 0; k < attachedArrayAndLength.length; k++) {
       let value: JSAny;
       // a. Let Pk be ! ToString(k).
       // b. Let kValue be ? Get(O, Pk).
       try {
-        witness.Recheck() otherwise goto IsDetached;
+        witness.RecheckIndex(k) otherwise goto IsDetachedOrOutOfBounds;
         value = witness.Load(k);
-      } label IsDetached deferred {
+      } label IsDetachedOrOutOfBounds deferred {
         value = Undefined;
       }
 
@@ -80,7 +80,7 @@ transitioning javascript builtin TypedArrayPrototypeFilter(
 
     // 13. Return A.
     return typedArray;
-  } label IsDetached deferred {
+  } label IsDetachedOrOutOfBounds deferred {
     ThrowTypeError(MessageTemplate::kDetachedOperation, kBuiltinNameFilter);
   }
 }

src/builtins/typed-array-find.tq

@@ -9,13 +9,14 @@ const kBuiltinNameFind: constexpr string = '%TypedArray%.prototype.find';
 
 // https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.find
 transitioning macro FindAllElements(implicit context: Context)(
-    array: typed_array::AttachedJSTypedArray, predicate: Callable,
-    thisArg: JSAny): JSAny {
-  let witness = typed_array::NewAttachedJSTypedArrayWitness(array);
-  const length: uintptr = witness.Get().length;
+    attachedArrayAndLength: typed_array::AttachedJSTypedArrayAndLength,
+    predicate: Callable, thisArg: JSAny): JSAny {
+  let witness =
+      typed_array::NewAttachedJSTypedArrayWitness(attachedArrayAndLength.array);
 
+  // 5. Let k be 0.
   // 6. Repeat, while k < len
-  for (let k: uintptr = 0; k < length; k++) {
+  for (let k: uintptr = 0; k < attachedArrayAndLength.length; k++) {
     // 6a. Let Pk be ! ToString(𝔽(k)).
     // There is no need to cast ToString to load elements.
 
@@ -23,9 +24,9 @@ transitioning macro FindAllElements(implicit context: Context)(
     // kValue must be undefined when the buffer is detached.
     let value: JSAny;
     try {
-      witness.Recheck() otherwise goto IsDetached;
+      witness.RecheckIndex(k) otherwise goto IsDetachedOrOutOfBounds;
       value = witness.Load(k);
-    } label IsDetached deferred {
+    } label IsDetachedOrOutOfBounds deferred {
       value = Undefined;
     }
 
@@ -56,18 +57,22 @@ TypedArrayPrototypeFind(
   // arguments[0] = callback
   // arguments[1] = thisArg
   try {
+    // 1. Let O be the this value.
+    // 2. Perform ? ValidateTypedArray(O).
+    // 3. Let len be IntegerIndexedObjectLength(O).
     const array: JSTypedArray = Cast<JSTypedArray>(receiver)
         otherwise NotTypedArray;
-    const uarray = typed_array::EnsureAttached(array) otherwise IsDetached;
-
+    const attachedArrayAndLength = EnsureAttachedAndReadLength(array)
+        otherwise IsDetachedOrOutOfBounds;
+    // 4. If IsCallable(predicate) is false, throw a TypeError exception.
     const predicate = Cast<Callable>(arguments[0]) otherwise NotCallable;
     const thisArg = arguments[1];
-    return FindAllElements(uarray, predicate, thisArg);
+    return FindAllElements(attachedArrayAndLength, predicate, thisArg);
   } label NotCallable deferred {
     ThrowTypeError(MessageTemplate::kCalledNonCallable, arguments[0]);
   } label NotTypedArray deferred {
     ThrowTypeError(MessageTemplate::kNotTypedArray, kBuiltinNameFind);
-  } label IsDetached deferred {
+  } label IsDetachedOrOutOfBounds deferred {
     ThrowTypeError(MessageTemplate::kDetachedOperation, kBuiltinNameFind);
   }
 }

src/builtins/typed-array-findindex.tq

@@ -9,13 +9,14 @@ const kBuiltinNameFindIndex: constexpr string =
     '%TypedArray%.prototype.findIndex';
 
 transitioning macro FindIndexAllElements(implicit context: Context)(
-    array: typed_array::AttachedJSTypedArray, predicate: Callable,
-    thisArg: JSAny): Number {
-  let witness = typed_array::NewAttachedJSTypedArrayWitness(array);
-  const length: uintptr = witness.Get().length;
+    attachedArrayAndLength: typed_array::AttachedJSTypedArrayAndLength,
+    predicate: Callable, thisArg: JSAny): Number {
+  let witness =
+      typed_array::NewAttachedJSTypedArrayWitness(attachedArrayAndLength.array);
 
+  // 5. Let k be 0.
   // 6. Repeat, while k < len
-  for (let k: uintptr = 0; k < length; k++) {
+  for (let k: uintptr = 0; k < attachedArrayAndLength.length; k++) {
     // 6a. Let Pk be ! ToString(𝔽(k)).
     // There is no need to cast ToString to load elements.
 
@@ -23,9 +24,9 @@ transitioning macro FindIndexAllElements(implicit context: Context)(
     // kValue must be undefined when the buffer is detached.
     let value: JSAny;
     try {
-      witness.Recheck() otherwise goto IsDetached;
+      witness.RecheckIndex(k) otherwise goto IsDetachedOrOutOfBounds;
       value = witness.Load(k);
-    } label IsDetached deferred {
+    } label IsDetachedOrOutOfBounds deferred {
       value = Undefined;
     }
 
@@ -47,21 +48,25 @@ transitioning macro FindIndexAllElements(implicit context: Context)(
 transitioning javascript builtin
 TypedArrayPrototypeFindIndex(
     js-implicit context: NativeContext, receiver: JSAny)(...arguments): JSAny {
-  // arguments[0] = callback
+  // arguments[0] = predicate
   // arguments[1] = thisArg.
   try {
+    // 1. Let O be the this value.
+    // 2. Perform ? ValidateTypedArray(O).
+    // 3. Let len be IntegerIndexedObjectLength(O).
     const array: JSTypedArray = Cast<JSTypedArray>(receiver)
         otherwise NotTypedArray;
-    const uarray = typed_array::EnsureAttached(array) otherwise IsDetached;
-
+    const attachedArrayAndLength = EnsureAttachedAndReadLength(array)
+        otherwise IsDetachedOrOutOfBounds;
+    // 4. If IsCallable(predicate) is false, throw a TypeError exception.
     const predicate = Cast<Callable>(arguments[0]) otherwise NotCallable;
     const thisArg = arguments[1];
-    return FindIndexAllElements(uarray, predicate, thisArg);
+    return FindIndexAllElements(attachedArrayAndLength, predicate, thisArg);
   } label NotCallable deferred {
     ThrowTypeError(MessageTemplate::kCalledNonCallable, arguments[0]);
   } label NotTypedArray deferred {
     ThrowTypeError(MessageTemplate::kNotTypedArray, kBuiltinNameFindIndex);
-  } label IsDetached deferred {
+  } label IsDetachedOrOutOfBounds deferred {
     ThrowTypeError(MessageTemplate::kDetachedOperation, kBuiltinNameFindIndex);
   }
 }

src/builtins/typed-array-findlast.tq

@@ -10,14 +10,13 @@ const kBuiltinNameFindLast: constexpr string =
 
 // https://tc39.es/proposal-array-find-from-last/index.html#sec-%typedarray%.prototype.findlast
 transitioning macro FindLastAllElements(implicit context: Context)(
-    array: typed_array::AttachedJSTypedArray, predicate: Callable,
-    thisArg: JSAny): JSAny {
-  let witness = typed_array::NewAttachedJSTypedArrayWitness(array);
-  // 3. Let len be O.[[ArrayLength]].
-  const length: uintptr = witness.Get().length;
+    attachedArrayAndLength: typed_array::AttachedJSTypedArrayAndLength,
+    predicate: Callable, thisArg: JSAny): JSAny {
+  let witness =
+      typed_array::NewAttachedJSTypedArrayWitness(attachedArrayAndLength.array);
   // 5. Let k be len - 1.
   // 6. Repeat, while k ≥ 0
-  for (let k: uintptr = length; k-- > 0;) {
+  for (let k: uintptr = attachedArrayAndLength.length; k-- > 0;) {
     // 6a. Let Pk be ! ToString(𝔽(k)).
     // There is no need to cast ToString to load elements.
 
@@ -25,9 +24,9 @@ transitioning macro FindLastAllElements(implicit context: Context)(
     // kValue must be undefined when the buffer was detached.
     let value: JSAny;
     try {
-      witness.Recheck() otherwise goto IsDetached;
+      witness.RecheckIndex(k) otherwise goto IsDetachedOrOutOfBounds;
       value = witness.Load(k);
-    } label IsDetached deferred {
+    } label IsDetachedOrOutOfBounds deferred {
       value = Undefined;
     }
 
@@ -54,24 +53,25 @@ transitioning macro FindLastAllElements(implicit context: Context)(
 transitioning javascript builtin
 TypedArrayPrototypeFindLast(
     js-implicit context: NativeContext, receiver: JSAny)(...arguments): JSAny {
-  // arguments[0] = callback
+  // arguments[0] = predicate
   // arguments[1] = thisArg
   try {
     // 1. Let O be the this value.
+    // 2. Perform ? ValidateTypedArray(O).
+    // 3. Let len be IntegerIndexedObjectLength(O).
     const array: JSTypedArray = Cast<JSTypedArray>(receiver)
         otherwise NotTypedArray;
-    // 2. Perform ? ValidateTypedArray(O).
-    const uarray = typed_array::EnsureAttached(array) otherwise IsDetached;
-
+    const attachedArrayAndLength = EnsureAttachedAndReadLength(array)
+        otherwise IsDetachedOrOutOfBounds;
     // 4. If IsCallable(predicate) is false, throw a TypeError exception.
     const predicate = Cast<Callable>(arguments[0]) otherwise NotCallable;
     const thisArg = arguments[1];
-    return FindLastAllElements(uarray, predicate, thisArg);
+    return FindLastAllElements(attachedArrayAndLength, predicate, thisArg);
   } label NotCallable deferred {
     ThrowTypeError(MessageTemplate::kCalledNonCallable, arguments[0]);
   } label NotTypedArray deferred {
     ThrowTypeError(MessageTemplate::kNotTypedArray, kBuiltinNameFindLast);
-  } label IsDetached deferred {
+  } label IsDetachedOrOutOfBounds deferred {
     ThrowTypeError(MessageTemplate::kDetachedOperation, kBuiltinNameFindLast);
   }
 }

src/builtins/typed-array-findlastindex.tq

@@ -10,14 +10,13 @@ const kBuiltinNameFindLastIndex: constexpr string =
 
 // https://tc39.es/proposal-array-find-from-last/index.html#sec-%typedarray%.prototype.findlastindex
 transitioning macro FindLastIndexAllElements(implicit context: Context)(
-    array: typed_array::AttachedJSTypedArray, predicate: Callable,
-    thisArg: JSAny): Number {
-  let witness = typed_array::NewAttachedJSTypedArrayWitness(array);
-  // 3. Let len be O.[[ArrayLength]].
-  const length: uintptr = witness.Get().length;
+    attachedArrayAndLength: typed_array::AttachedJSTypedArrayAndLength,
+    predicate: Callable, thisArg: JSAny): Number {
+  let witness =
+      typed_array::NewAttachedJSTypedArrayWitness(attachedArrayAndLength.array);
   // 5. Let k be len - 1.
   // 6. Repeat, while k ≥ 0
-  for (let k: uintptr = length; k-- > 0;) {
+  for (let k: uintptr = attachedArrayAndLength.length; k-- > 0;) {
     // 6a. Let Pk be ! ToString(𝔽(k)).
     // There is no need to cast ToString to load elements.
 
@@ -25,9 +24,9 @@ transitioning macro FindLastIndexAllElements(implicit context: Context)(
     // kValue must be undefined when the buffer was detached.
     let value: JSAny;
     try {
-      witness.Recheck() otherwise goto IsDetached;
+      witness.RecheckIndex(k) otherwise goto IsDetachedOrOutOfBounds;
       value = witness.Load(k);
-    } label IsDetached deferred {
+    } label IsDetachedOrOutOfBounds deferred {
       value = Undefined;
     }
 
@@ -54,25 +53,25 @@ transitioning macro FindLastIndexAllElements(implicit context: Context)(
 transitioning javascript builtin
 TypedArrayPrototypeFindLastIndex(
     js-implicit context: NativeContext, receiver: JSAny)(...arguments): JSAny {
-  // arguments[0] = callback
-  // arguments[1] = thisArg.
+  // arguments[0] = predicate
+  // arguments[1] = thisArg
   try {
     // 1. Let O be the this value.
+    // 2. Perform ? ValidateTypedArray(O).
+    // 3. Let len be IntegerIndexedObjectLength(O).
     const array: JSTypedArray = Cast<JSTypedArray>(receiver)
         otherwise NotTypedArray;
-    // 2. Perform ? ValidateTypedArray(O).
-    const uarray = typed_array::EnsureAttached(array) otherwise IsDetached;
-
+    const attachedArrayAndLength = EnsureAttachedAndReadLength(array)
+        otherwise IsDetachedOrOutOfBounds;
     // 4. If IsCallable(predicate) is false, throw a TypeError exception.
     const predicate = Cast<Callable>(arguments[0]) otherwise NotCallable;
     const thisArg = arguments[1];
-
-    return FindLastIndexAllElements(uarray, predicate, thisArg);
+    return FindLastIndexAllElements(attachedArrayAndLength, predicate, thisArg);
   } label NotCallable deferred {
     ThrowTypeError(MessageTemplate::kCalledNonCallable, arguments[0]);
   } label NotTypedArray deferred {
     ThrowTypeError(MessageTemplate::kNotTypedArray, kBuiltinNameFindLastIndex);
-  } label IsDetached deferred {
+  } label IsDetachedOrOutOfBounds deferred {
     ThrowTypeError(
         MessageTemplate::kDetachedOperation, kBuiltinNameFindLastIndex);
   }

src/builtins/typed-array-foreach.tq

@@ -8,13 +8,14 @@ namespace typed_array {
 const kBuiltinNameForEach: constexpr string = '%TypedArray%.prototype.forEach';
 
 transitioning macro ForEachAllElements(implicit context: Context)(
-    array: typed_array::AttachedJSTypedArray, callbackfn: Callable,
-    thisArg: JSAny): Undefined {
-  let witness = typed_array::NewAttachedJSTypedArrayWitness(array);
-  const length: uintptr = witness.Get().length;
+    attachedArrayAndLength: typed_array::AttachedJSTypedArrayAndLength,
+    callbackfn: Callable, thisArg: JSAny): Undefined {
+  let witness =
+      typed_array::NewAttachedJSTypedArrayWitness(attachedArrayAndLength.array);
 
+  // 5. Let k be 0.
   // 6. Repeat, while k < len
-  for (let k: uintptr = 0; k < length; k++) {
+  for (let k: uintptr = 0; k < attachedArrayAndLength.length; k++) {
     // 6a. Let Pk be ! ToString(𝔽(k)).
     // There is no need to cast ToString to load elements.
 
@@ -22,9 +23,9 @@ transitioning macro ForEachAllElements(implicit context: Context)(
     // kValue must be undefined when the buffer is detached.
     let value: JSAny;
     try {
-      witness.Recheck() otherwise goto IsDetached;
+      witness.RecheckIndex(k) otherwise goto IsDetachedOrOutOfBounds;
       value = witness.Load(k);
-    } label IsDetached deferred {
+    } label IsDetachedOrOutOfBounds deferred {
       value = Undefined;
     }
 
@@ -50,18 +51,22 @@ TypedArrayPrototypeForEach(js-implicit context: NativeContext, receiver: JSAny)(
   // arguments[1] = this_arg.
 
   try {
+    // 1. Let O be the this value.
+    // 2. Perform ? ValidateTypedArray(O).
+    // 3. Let len be IntegerIndexedObjectLength(O).
     const array: JSTypedArray = Cast<JSTypedArray>(receiver)
         otherwise NotTypedArray;
-    const uarray = typed_array::EnsureAttached(array) otherwise IsDetached;
-
+    const attachedArrayAndLength = EnsureAttachedAndReadLength(array)
+        otherwise IsDetachedOrOutOfBounds;
+    // 4. If IsCallable(callbackfn) is false, throw a TypeError exception.
     const callbackfn = Cast<Callable>(arguments[0]) otherwise NotCallable;
     const thisArg = arguments[1];
-    return ForEachAllElements(uarray, callbackfn, thisArg);
+    return ForEachAllElements(attachedArrayAndLength, callbackfn, thisArg);
   } label NotCallable deferred {
     ThrowTypeError(MessageTemplate::kCalledNonCallable, arguments[0]);
   } label NotTypedArray deferred {
     ThrowTypeError(MessageTemplate::kNotTypedArray, kBuiltinNameForEach);
-  } label IsDetached deferred {
+  } label IsDetachedOrOutOfBounds deferred {
     ThrowTypeError(MessageTemplate::kDetachedOperation, kBuiltinNameForEach);
   }
 }

src/builtins/typed-array-reduce.tq

@@ -8,19 +8,19 @@ namespace typed_array {
 const kBuiltinNameReduce: constexpr string = '%TypedArray%.prototype.reduce';
 
 transitioning macro ReduceAllElements(implicit context: Context)(
-    array: typed_array::AttachedJSTypedArray, callbackfn: Callable,
-    initialValue: JSAny|TheHole): JSAny {
-  let witness = typed_array::NewAttachedJSTypedArrayWitness(array);
-  const length: uintptr = witness.Get().length;
+    attachedArrayAndLength: typed_array::AttachedJSTypedArrayAndLength,
+    callbackfn: Callable, initialValue: JSAny|TheHole): JSAny {
+  let witness =
+      typed_array::NewAttachedJSTypedArrayWitness(attachedArrayAndLength.array);
 
   let accumulator = initialValue;
-  for (let k: uintptr = 0; k < length; k++) {
+  for (let k: uintptr = 0; k < attachedArrayAndLength.length; k++) {
     let value: JSAny;
     try {
-      witness.Recheck()
-          otherwise goto IsDetached;
+      witness.RecheckIndex(k)
+          otherwise goto IsDetachedOrOutOfBounds;
       value = witness.Load(k);
-    } label IsDetached deferred {
+    } label IsDetachedOrOutOfBounds deferred {
       value = Undefined;
     }
     typeswitch (accumulator) {
@@ -53,18 +53,22 @@ TypedArrayPrototypeReduce(
   // arguments[0] = callback
   // arguments[1] = initialValue.
   try {
+    // 1. Let O be the this value.
+    // 2. Perform ? ValidateTypedArray(O).
+    // 3. Let len be IntegerIndexedObjectLength(O).
     const array: JSTypedArray = Cast<JSTypedArray>(receiver)
         otherwise NotTypedArray;
-    const uarray = typed_array::EnsureAttached(array) otherwise IsDetached;
-
+    const attachedArrayAndLength = EnsureAttachedAndReadLength(array)
+        otherwise IsDetachedOrOutOfBounds;
+    // 4. If IsCallable(callbackfn) is false, throw a TypeError exception.
     const callbackfn = Cast<Callable>(arguments[0]) otherwise NotCallable;
     const initialValue = arguments.length >= 2 ? arguments[1] : TheHole;
-    return ReduceAllElements(uarray, callbackfn, initialValue);
+    return ReduceAllElements(attachedArrayAndLength, callbackfn, initialValue);
   } label NotCallable deferred {
     ThrowTypeError(MessageTemplate::kCalledNonCallable, arguments[0]);
   } label NotTypedArray deferred {
     ThrowTypeError(MessageTemplate::kNotTypedArray, kBuiltinNameReduce);
-  } label IsDetached deferred {
+  } label IsDetachedOrOutOfBounds deferred {
     ThrowTypeError(MessageTemplate::kDetachedOperation, kBuiltinNameReduce);
   }
 }

src/builtins/typed-array-reduceright.tq

@@ -10,18 +10,18 @@ const kBuiltinNameReduceRight: constexpr string =
 
 // https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.reduceright
 transitioning macro ReduceRightAllElements(implicit context: Context)(
-    array: typed_array::AttachedJSTypedArray, callbackfn: Callable,
-    initialValue: JSAny|TheHole): JSAny {
-  let witness = typed_array::NewAttachedJSTypedArrayWitness(array);
-  const length: uintptr = witness.Get().length;
+    attachedArrayAndLength: typed_array::AttachedJSTypedArrayAndLength,
+    callbackfn: Callable, initialValue: JSAny|TheHole): JSAny {
+  let witness =
+      typed_array::NewAttachedJSTypedArrayWitness(attachedArrayAndLength.array);
   let accumulator = initialValue;
-  for (let k: uintptr = length; k-- > 0;) {
+  for (let k: uintptr = attachedArrayAndLength.length; k-- > 0;) {
     let value: JSAny;
     try {
-      witness.Recheck()
-          otherwise goto IsDetached;
+      witness.RecheckIndex(k)
+          otherwise goto IsDetachedOrOutOfBounds;
       value = witness.Load(k);
-    } label IsDetached deferred {
+    } label IsDetachedOrOutOfBounds deferred {
       value = Undefined;
     }
     typeswitch (accumulator) {
@@ -55,19 +55,24 @@ TypedArrayPrototypeReduceRight(
   // arguments[0] = callback
   // arguments[1] = initialValue.
   try {
+    // 1. Let O be the this value.
+    // 2. Perform ? ValidateTypedArray(O).
+    // 3. Let len be IntegerIndexedObjectLength(O).
     const array: JSTypedArray = Cast<JSTypedArray>(receiver)
         otherwise NotTypedArray;
-    const uarray = typed_array::EnsureAttached(array) otherwise IsDetached;
-
+    const attachedArrayAndLength = EnsureAttachedAndReadLength(array)
+        otherwise IsDetachedOrOutOfBounds;
+    // 4. If IsCallable(callbackfn) is false, throw a TypeError exception.
     const callbackfn = Cast<Callable>(arguments[0]) otherwise NotCallable;
     const initialValue = arguments.length >= 2 ? arguments[1] : TheHole;
 
-    return ReduceRightAllElements(uarray, callbackfn, initialValue);
+    return ReduceRightAllElements(
+        attachedArrayAndLength, callbackfn, initialValue);
   } label NotCallable deferred {
     ThrowTypeError(MessageTemplate::kCalledNonCallable, arguments[0]);
   } label NotTypedArray deferred {
     ThrowTypeError(MessageTemplate::kNotTypedArray, kBuiltinNameReduceRight);
-  } label IsDetached deferred {
+  } label IsDetachedOrOutOfBounds deferred {
     ThrowTypeError(
         MessageTemplate::kDetachedOperation, kBuiltinNameReduceRight);
   }

src/builtins/typed-array-some.tq

@@ -9,13 +9,14 @@ const kBuiltinNameSome: constexpr string = '%TypedArray%.prototype.some';
 
 // https://tc39.es/ecma262/#sec-%typedarray%.prototype.some
 transitioning macro SomeAllElements(implicit context: Context)(
-    array: typed_array::AttachedJSTypedArray, length: uintptr,
+    attachedArrayAndLength: typed_array::AttachedJSTypedArrayAndLength,
     callbackfn: Callable, thisArg: JSAny): Boolean {
-  let witness = typed_array::NewAttachedJSTypedArrayWitness(array);
+  let witness =
+      typed_array::NewAttachedJSTypedArrayWitness(attachedArrayAndLength.array);
 
   // 5. Let k be 0.
   // 6. Repeat, while k < len
-  for (let k: uintptr = 0; k < length; k++) {
+  for (let k: uintptr = 0; k < attachedArrayAndLength.length; k++) {
     // 6a. Let Pk be ! ToString(𝔽(k)).
     // There is no need to cast ToString to load elements.
 
@@ -61,13 +62,12 @@ TypedArrayPrototypeSome(
     // 3. Let len be IntegerIndexedObjectLength(O).
     const array: JSTypedArray = Cast<JSTypedArray>(receiver)
         otherwise NotTypedArray;
-    const length = LoadJSTypedArrayLengthAndCheckDetached(array)
+    const attachedArrayAndLength = EnsureAttachedAndReadLength(array)
         otherwise IsDetachedOrOutOfBounds;
     // 4. If IsCallable(callbackfn) is false, throw a TypeError exception.
     const callbackfn = Cast<Callable>(arguments[0]) otherwise NotCallable;
     const thisArg = arguments[1];
-    return SomeAllElements(
-        %RawDownCast<AttachedJSTypedArray>(array), length, callbackfn, thisArg);
+    return SomeAllElements(attachedArrayAndLength, callbackfn, thisArg);
   } label NotTypedArray deferred {
     ThrowTypeError(MessageTemplate::kNotTypedArray, kBuiltinNameSome);
   } label IsDetachedOrOutOfBounds deferred {

src/builtins/typed-array.tq

@@ -195,21 +195,27 @@ macro EnsureAttached(array: JSTypedArray): AttachedJSTypedArray
   }
 }
 
-struct AttachedJSTypedArrayWitness {
-  macro Get(): AttachedJSTypedArray {
-    return this.unstable;
-  }
+struct AttachedJSTypedArrayAndLength {
+  array: AttachedJSTypedArray;
+  length: uintptr;
+}
+
+macro EnsureAttachedAndReadLength(array: JSTypedArray):
+    AttachedJSTypedArrayAndLength
+    labels DetachedOrOutOfBounds {
+  const length = LoadJSTypedArrayLengthAndCheckDetached(array)
+      otherwise DetachedOrOutOfBounds;
+  return AttachedJSTypedArrayAndLength{
+    array: %RawDownCast<AttachedJSTypedArray>(array),
+    length: length
+  };
+}
 
+struct AttachedJSTypedArrayWitness {
   macro GetStable(): JSTypedArray {
     return this.stable;
   }
 
-  // TODO(v8:11111): Migrate users to use RecheckIndex.
-  macro Recheck(): void labels Detached {
-    if (IsDetachedBuffer(this.stable.buffer)) goto Detached;
-    this.unstable = %RawDownCast<AttachedJSTypedArray>(this.stable);
-  }
-
   macro RecheckIndex(index: uintptr): void labels DetachedOrOutOfBounds {
     const length = LoadJSTypedArrayLengthAndCheckDetached(this.stable)
         otherwise DetachedOrOutOfBounds;

test/mjsunit/typedarray-growablesharedarraybuffer.js

@@ -3,7 +3,7 @@
 // found in the LICENSE file.
 
 // Flags: --harmony-rab-gsab --allow-natives-syntax
-// Flags: --harmony-relative-indexing-methods
+// Flags: --harmony-relative-indexing-methods --harmony-array-find-last
 
 "use strict";
 
@@ -1249,7 +1249,7 @@ function TestIterationAndGrow(ta, expected, gsab, grow_after,
   let gsab;
   let growAfter;
   let growTo;
-  function myFunc(n) {
+  function CollectValuesAndGrow(n) {
     if (n == undefined) {
       values.push(n);
     } else {
@@ -1267,7 +1267,7 @@ function TestIterationAndGrow(ta, expected, gsab, grow_after,
     values = [];
     growAfter = 2;
     growTo = 5 * ctor.BYTES_PER_ELEMENT;
-    assertTrue(fixedLength.every(myFunc));
+    assertTrue(fixedLength.every(CollectValuesAndGrow));
     assertEquals([0, 2, 4, 6], values);
   }
 
@@ -1277,7 +1277,7 @@ function TestIterationAndGrow(ta, expected, gsab, grow_after,
     values = [];
     growAfter = 1;
     growTo = 5 * ctor.BYTES_PER_ELEMENT;
-    assertTrue(fixedLengthWithOffset.every(myFunc));
+    assertTrue(fixedLengthWithOffset.every(CollectValuesAndGrow));
     assertEquals([4, 6], values);
   }
 
@@ -1287,7 +1287,7 @@ function TestIterationAndGrow(ta, expected, gsab, grow_after,
     values = [];
     growAfter = 2;
     growTo = 5 * ctor.BYTES_PER_ELEMENT;
-    assertTrue(lengthTracking.every(myFunc));
+    assertTrue(lengthTracking.every(CollectValuesAndGrow));
     assertEquals([0, 2, 4, 6], values);
   }
 
@@ -1297,7 +1297,7 @@ function TestIterationAndGrow(ta, expected, gsab, grow_after,
     values = [];
     growAfter = 1;
     growTo = 5 * ctor.BYTES_PER_ELEMENT;
-    assertTrue(lengthTrackingWithOffset.every(myFunc));
+    assertTrue(lengthTrackingWithOffset.every(CollectValuesAndGrow));
     assertEquals([4, 6], values);
   }
 })();
@@ -1323,7 +1323,7 @@ function TestIterationAndGrow(ta, expected, gsab, grow_after,
   let gsab;
   let growAfter;
   let growTo;
-  function myFunc(n) {
+  function CollectValuesAndGrow(n) {
     if (n == undefined) {
       values.push(n);
     } else {
@@ -1341,7 +1341,7 @@ function TestIterationAndGrow(ta, expected, gsab, grow_after,
     values = [];
     growAfter = 2;
     growTo = 5 * ctor.BYTES_PER_ELEMENT;
-    assertFalse(fixedLength.some(myFunc));
+    assertFalse(fixedLength.some(CollectValuesAndGrow));
     assertEquals([0, 2, 4, 6], values);
   }
 
@@ -1352,7 +1352,7 @@ function TestIterationAndGrow(ta, expected, gsab, grow_after,
     gsab = gsab;
     growAfter = 1;
     growTo = 5 * ctor.BYTES_PER_ELEMENT;
-    assertFalse(fixedLengthWithOffset.some(myFunc));
+    assertFalse(fixedLengthWithOffset.some(CollectValuesAndGrow));
     assertEquals([4, 6], values);
   }
 
@@ -1362,7 +1362,7 @@ function TestIterationAndGrow(ta, expected, gsab, grow_after,
     values = [];
     growAfter = 2;
     growTo = 5 * ctor.BYTES_PER_ELEMENT;
-    assertFalse(lengthTracking.some(myFunc));
+    assertFalse(lengthTracking.some(CollectValuesAndGrow));
     assertEquals([0, 2, 4, 6], values);
   }
 
@@ -1372,7 +1372,728 @@ function TestIterationAndGrow(ta, expected, gsab, grow_after,
     values = [];
     growAfter = 1;
     growTo = 5 * ctor.BYTES_PER_ELEMENT;
-    assertFalse(lengthTrackingWithOffset.some(myFunc));
+    assertFalse(lengthTrackingWithOffset.some(CollectValuesAndGrow));
     assertEquals([4, 6], values);
   }
 })();
+
+(function FindFindIndexFindLastFindLastIndex() {
+  for (let ctor of ctors) {
+    const gsab = CreateGrowableSharedArrayBuffer(4 * ctor.BYTES_PER_ELEMENT,
+                                                 8 * ctor.BYTES_PER_ELEMENT);
+    const fixedLength = new ctor(gsab, 0, 4);
+    const fixedLengthWithOffset = new ctor(gsab, 2 * ctor.BYTES_PER_ELEMENT, 2);
+    const lengthTracking = new ctor(gsab, 0);
+    const lengthTrackingWithOffset = new ctor(gsab, 2 * ctor.BYTES_PER_ELEMENT);
+
+    // Write some data into the array.
+    const taWrite = new ctor(gsab);
+    for (let i = 0; i < 4; ++i) {
+      WriteToTypedArray(taWrite, i, 2 * i);
+    }
+
+    // Orig. array: [0, 2, 4, 6]
+    //              [0, 2, 4, 6] << fixedLength
+    //                    [4, 6] << fixedLengthWithOffset
+    //              [0, 2, 4, 6, ...] << lengthTracking
+    //                    [4, 6, ...] << lengthTrackingWithOffset
+
+    function isTwoOrFour(n) {
+      return n == 2 || n == 4;
+    }
+
+    assertEquals(2, Number(fixedLength.find(isTwoOrFour)));
+    assertEquals(4, Number(fixedLengthWithOffset.find(isTwoOrFour)));
+    assertEquals(2, Number(lengthTracking.find(isTwoOrFour)));
+    assertEquals(4, Number(lengthTrackingWithOffset.find(isTwoOrFour)));
+
+    assertEquals(1, fixedLength.findIndex(isTwoOrFour));
+    assertEquals(0, fixedLengthWithOffset.findIndex(isTwoOrFour));
+    assertEquals(1, lengthTracking.findIndex(isTwoOrFour));
+    assertEquals(0, lengthTrackingWithOffset.findIndex(isTwoOrFour));
+
+    assertEquals(4, Number(fixedLength.findLast(isTwoOrFour)));
+    assertEquals(4, Number(fixedLengthWithOffset.findLast(isTwoOrFour)));
+    assertEquals(4, Number(lengthTracking.findLast(isTwoOrFour)));
+    assertEquals(4, Number(lengthTrackingWithOffset.findLast(isTwoOrFour)));
+
+    assertEquals(2, fixedLength.findLastIndex(isTwoOrFour));
+    assertEquals(0, fixedLengthWithOffset.findLastIndex(isTwoOrFour));
+    assertEquals(2, lengthTracking.findLastIndex(isTwoOrFour));
+    assertEquals(0, lengthTrackingWithOffset.findLastIndex(isTwoOrFour));
+
+    // Grow.
+    gsab.grow(6 * ctor.BYTES_PER_ELEMENT);
+    for (let i = 0; i < 4; ++i) {
+      WriteToTypedArray(taWrite, i, 0);
+    }
+    WriteToTypedArray(taWrite, 4, 2);
+    WriteToTypedArray(taWrite, 5, 4);
+
+    // Orig. array: [0, 0, 0, 0, 2, 4]
+    //              [0, 0, 0, 0] << fixedLength
+    //                    [0, 0] << fixedLengthWithOffset
+    //              [0, 0, 0, 0, 2, 4, ...] << lengthTracking
+    //                    [0, 0, 2, 4, ...] << lengthTrackingWithOffset
+
+    assertEquals(undefined, fixedLength.find(isTwoOrFour));
+    assertEquals(undefined, fixedLengthWithOffset.find(isTwoOrFour));
+    assertEquals(2, Number(lengthTracking.find(isTwoOrFour)));
+    assertEquals(2, Number(lengthTrackingWithOffset.find(isTwoOrFour)));
+
+    assertEquals(-1, fixedLength.findIndex(isTwoOrFour));
+    assertEquals(-1, fixedLengthWithOffset.findIndex(isTwoOrFour));
+    assertEquals(4, lengthTracking.findIndex(isTwoOrFour));
+    assertEquals(2, lengthTrackingWithOffset.findIndex(isTwoOrFour));
+
+    assertEquals(undefined, fixedLength.findLast(isTwoOrFour));
+    assertEquals(undefined, fixedLengthWithOffset.findLast(isTwoOrFour));
+    assertEquals(4, Number(lengthTracking.findLast(isTwoOrFour)));
+    assertEquals(4, Number(lengthTrackingWithOffset.findLast(isTwoOrFour)));
+
+    assertEquals(-1, fixedLength.findLastIndex(isTwoOrFour));
+    assertEquals(-1, fixedLengthWithOffset.findLastIndex(isTwoOrFour));
+    assertEquals(5, lengthTracking.findLastIndex(isTwoOrFour));
+    assertEquals(3, lengthTrackingWithOffset.findLastIndex(isTwoOrFour));
+  }
+})();
+
+(function FindGrowMidIteration() {
+  // Orig. array: [0, 2, 4, 6]
+  //              [0, 2, 4, 6] << fixedLength
+  //                    [4, 6] << fixedLengthWithOffset
+  //              [0, 2, 4, 6, ...] << lengthTracking
+  //                    [4, 6, ...] << lengthTrackingWithOffset
+  function CreateGsabForTest(ctor) {
+    const gsab = CreateGrowableSharedArrayBuffer(4 * ctor.BYTES_PER_ELEMENT,
+                                                 8 * ctor.BYTES_PER_ELEMENT);
+    // Write some data into the array.
+    const taWrite = new ctor(gsab);
+    for (let i = 0; i < 4; ++i) {
+      WriteToTypedArray(taWrite, i, 2 * i);
+    }
+    return gsab;
+  }
+
+  let values;
+  let gsab;
+  let growAfter;
+  let growTo;
+  function CollectValuesAndGrow(n) {
+    if (n == undefined) {
+      values.push(n);
+    } else {
+      values.push(Number(n));
+    }
+    if (values.length == growAfter) {
+      gsab.grow(growTo);
+    }
+    return false;
+  }
+
+  for (let ctor of ctors) {
+    gsab = CreateGsabForTest(ctor);
+    const fixedLength = new ctor(gsab, 0, 4);
+    values = [];
+    growAfter = 2;
+    growTo = 5 * ctor.BYTES_PER_ELEMENT;
+    assertEquals(undefined, fixedLength.find(CollectValuesAndGrow));
+    assertEquals([0, 2, 4, 6], values);
+  }
+
+  for (let ctor of ctors) {
+    gsab = CreateGsabForTest(ctor);
+    const fixedLengthWithOffset = new ctor(gsab, 2 * ctor.BYTES_PER_ELEMENT, 2);
+    values = [];
+    growAfter = 1;
+    growTo = 5 * ctor.BYTES_PER_ELEMENT;
+    assertEquals(undefined, fixedLengthWithOffset.find(CollectValuesAndGrow));
+    assertEquals([4, 6], values);
+  }
+
+  for (let ctor of ctors) {
+    gsab = CreateGsabForTest(ctor);
+    const lengthTracking = new ctor(gsab, 0);
+    values = [];
+    growAfter = 2;
+    growTo = 5 * ctor.BYTES_PER_ELEMENT;
+    assertEquals(undefined, lengthTracking.find(CollectValuesAndGrow));
+    assertEquals([0, 2, 4, 6], values);
+  }
+
+  for (let ctor of ctors) {
+    gsab = CreateGsabForTest(ctor);
+    const lengthTrackingWithOffset = new ctor(gsab, 2 * ctor.BYTES_PER_ELEMENT);
+    values = [];
+    growAfter = 1;
+    growTo = 5 * ctor.BYTES_PER_ELEMENT;
+    assertEquals(undefined, lengthTrackingWithOffset.find(CollectValuesAndGrow));
+    assertEquals([4, 6], values);
+  }
+})();
+
+(function FindIndexGrowMidIteration() {
+  // Orig. array: [0, 2, 4, 6]
+  //              [0, 2, 4, 6] << fixedLength
+  //                    [4, 6] << fixedLengthWithOffset
+  //              [0, 2, 4, 6, ...] << lengthTracking
+  //                    [4, 6, ...] << lengthTrackingWithOffset
+  function CreateGsabForTest(ctor) {
+    const gsab = CreateGrowableSharedArrayBuffer(4 * ctor.BYTES_PER_ELEMENT,
+                                                 8 * ctor.BYTES_PER_ELEMENT);
+    // Write some data into the array.
+    const taWrite = new ctor(gsab);
+    for (let i = 0; i < 4; ++i) {
+      WriteToTypedArray(taWrite, i, 2 * i);
+    }
+    return gsab;
+  }
+
+  let values;
+  let gsab;
+  let growAfter;
+  let growTo;
+  function CollectValuesAndGrow(n) {
+    if (n == undefined) {
+      values.push(n);
+    } else {
+      values.push(Number(n));
+    }
+    if (values.length == growAfter) {
+      gsab.grow(growTo);
+    }
+    return false;
+  }
+
+  for (let ctor of ctors) {
+    gsab = CreateGsabForTest(ctor);
+    const fixedLength = new ctor(gsab, 0, 4);
+    values = [];
+    growAfter = 2;
+    growTo = 5 * ctor.BYTES_PER_ELEMENT;
+    assertEquals(-1, fixedLength.findIndex(CollectValuesAndGrow));
+    assertEquals([0, 2, 4, 6], values);
+  }
+
+  for (let ctor of ctors) {
+    gsab = CreateGsabForTest(ctor);
+    const fixedLengthWithOffset = new ctor(gsab, 2 * ctor.BYTES_PER_ELEMENT, 2);
+    values = [];
+    growAfter = 1;
+    growTo = 5 * ctor.BYTES_PER_ELEMENT;
+    assertEquals(-1, fixedLengthWithOffset.findIndex(CollectValuesAndGrow));
+    assertEquals([4, 6], values);
+  }
+
+  for (let ctor of ctors) {
+    gsab = CreateGsabForTest(ctor);
+    const lengthTracking = new ctor(gsab, 0);
+    values = [];
+    growAfter = 2;
+    growTo = 5 * ctor.BYTES_PER_ELEMENT;
+    assertEquals(-1, lengthTracking.findIndex(CollectValuesAndGrow));
+    assertEquals([0, 2, 4, 6], values);
+  }
+
+  for (let ctor of ctors) {
+    gsab = CreateGsabForTest(ctor);
+    const lengthTrackingWithOffset = new ctor(gsab, 2 * ctor.BYTES_PER_ELEMENT);
+    values = [];
+    growAfter = 1;
+    growTo = 5 * ctor.BYTES_PER_ELEMENT;
+    assertEquals(-1, lengthTrackingWithOffset.findIndex(CollectValuesAndGrow));
+    assertEquals([4, 6], values);
+  }
+})();
+
+(function FindLastGrowMidIteration() {
+  // Orig. array: [0, 2, 4, 6]
+  //              [0, 2, 4, 6] << fixedLength
+  //                    [4, 6] << fixedLengthWithOffset
+  //              [0, 2, 4, 6, ...] << lengthTracking
+  //                    [4, 6, ...] << lengthTrackingWithOffset
+  function CreateGsabForTest(ctor) {
+    const gsab = CreateGrowableSharedArrayBuffer(4 * ctor.BYTES_PER_ELEMENT,
+                                                 8 * ctor.BYTES_PER_ELEMENT);
+    // Write some data into the array.
+    const taWrite = new ctor(gsab);
+    for (let i = 0; i < 4; ++i) {
+      WriteToTypedArray(taWrite, i, 2 * i);
+    }
+    return gsab;
+  }
+
+  let values;
+  let gsab;
+  let growAfter;
+  let growTo;
+  function CollectValuesAndGrow(n) {
+    if (n == undefined) {
+      values.push(n);
+    } else {
+      values.push(Number(n));
+    }
+    if (values.length == growAfter) {
+      gsab.grow(growTo);
+    }
+    return false;
+  }
+
+  for (let ctor of ctors) {
+    gsab = CreateGsabForTest(ctor);
+    const fixedLength = new ctor(gsab, 0, 4);
+    values = [];
+    growAfter = 2;
+    growTo = 5 * ctor.BYTES_PER_ELEMENT;
+    assertEquals(undefined, fixedLength.findLast(CollectValuesAndGrow));
+    assertEquals([6, 4, 2, 0], values);
+  }
+
+  for (let ctor of ctors) {
+    gsab = CreateGsabForTest(ctor);
+    const fixedLengthWithOffset = new ctor(gsab, 2 * ctor.BYTES_PER_ELEMENT, 2);
+    values = [];
+    growAfter = 1;
+    growTo = 5 * ctor.BYTES_PER_ELEMENT;
+    assertEquals(undefined, fixedLengthWithOffset.findLast(CollectValuesAndGrow));
+    assertEquals([6, 4], values);
+  }
+
+  for (let ctor of ctors) {
+    gsab = CreateGsabForTest(ctor);
+    const lengthTracking = new ctor(gsab, 0);
+    values = [];
+    growAfter = 2;
+    growTo = 5 * ctor.BYTES_PER_ELEMENT;
+    assertEquals(undefined, lengthTracking.findLast(CollectValuesAndGrow));
+    assertEquals([6, 4, 2, 0], values);
+  }
+
+  for (let ctor of ctors) {
+    gsab = CreateGsabForTest(ctor);
+    const lengthTrackingWithOffset = new ctor(gsab, 2 * ctor.BYTES_PER_ELEMENT);
+    values = [];
+    growAfter = 1;
+    growTo = 5 * ctor.BYTES_PER_ELEMENT;
+    assertEquals(undefined, lengthTrackingWithOffset.findLast(CollectValuesAndGrow));
+    assertEquals([6, 4], values);
+  }
+})();
+
+(function FindLastIndexGrowMidIteration() {
+  // Orig. array: [0, 2, 4, 6]
+  //              [0, 2, 4, 6] << fixedLength
+  //                    [4, 6] << fixedLengthWithOffset
+  //              [0, 2, 4, 6, ...] << lengthTracking
+  //                    [4, 6, ...] << lengthTrackingWithOffset
+  function CreateGsabForTest(ctor) {
+    const gsab = CreateGrowableSharedArrayBuffer(4 * ctor.BYTES_PER_ELEMENT,
+                                                 8 * ctor.BYTES_PER_ELEMENT);
+    // Write some data into the array.
+    const taWrite = new ctor(gsab);
+    for (let i = 0; i < 4; ++i) {
+      WriteToTypedArray(taWrite, i, 2 * i);
+    }
+    return gsab;
+  }
+
+  let values;
+  let gsab;
+  let growAfter;
+  let growTo;
+  function CollectValuesAndGrow(n) {
+    if (n == undefined) {
+      values.push(n);
+    } else {
+      values.push(Number(n));
+    }
+    if (values.length == growAfter) {
+      gsab.grow(growTo);
+    }
+    return false;
+  }
+
+  for (let ctor of ctors) {
+    gsab = CreateGsabForTest(ctor);
+    const fixedLength = new ctor(gsab, 0, 4);
+    values = [];
+    growAfter = 2;
+    growTo = 5 * ctor.BYTES_PER_ELEMENT;
+    assertEquals(-1, fixedLength.findLastIndex(CollectValuesAndGrow));
+    assertEquals([6, 4, 2, 0], values);
+  }
+
+  for (let ctor of ctors) {
+    gsab = CreateGsabForTest(ctor);
+    const fixedLengthWithOffset = new ctor(gsab, 2 * ctor.BYTES_PER_ELEMENT, 2);
+    values = [];
+    growAfter = 1;
+    growTo = 5 * ctor.BYTES_PER_ELEMENT;
+    assertEquals(-1, fixedLengthWithOffset.findLastIndex(CollectValuesAndGrow));
+    assertEquals([6, 4], values);
+  }
+
+  for (let ctor of ctors) {
+    gsab = CreateGsabForTest(ctor);
+    const lengthTracking = new ctor(gsab, 0);
+    values = [];
+    growAfter = 2;
+    growTo = 5 * ctor.BYTES_PER_ELEMENT;
+    assertEquals(-1, lengthTracking.findLastIndex(CollectValuesAndGrow));
+    assertEquals([6, 4, 2, 0], values);
+  }
+
+  for (let ctor of ctors) {
+    gsab = CreateGsabForTest(ctor);
+    const lengthTrackingWithOffset = new ctor(gsab, 2 * ctor.BYTES_PER_ELEMENT);
+    values = [];
+    growAfter = 1;
+    growTo = 5 * ctor.BYTES_PER_ELEMENT;
+    assertEquals(-1, lengthTrackingWithOffset.findLastIndex(CollectValuesAndGrow));
+    assertEquals([6, 4], values);
+  }
+})();
+
+(function Filter() {
+  for (let ctor of ctors) {
+    const gsab = CreateGrowableSharedArrayBuffer(4 * ctor.BYTES_PER_ELEMENT,
+                                                 8 * ctor.BYTES_PER_ELEMENT);
+    const fixedLength = new ctor(gsab, 0, 4);
+    const fixedLengthWithOffset = new ctor(gsab, 2 * ctor.BYTES_PER_ELEMENT, 2);
+    const lengthTracking = new ctor(gsab, 0);
+    const lengthTrackingWithOffset = new ctor(gsab, 2 * ctor.BYTES_PER_ELEMENT);
+
+    // Write some data into the array.
+    const taWrite = new ctor(gsab);
+    for (let i = 0; i < 4; ++i) {
+      WriteToTypedArray(taWrite, i, i);
+    }
+
+    // Orig. array: [0, 1, 2, 3]
+    //              [0, 1, 2, 3] << fixedLength
+    //                    [2, 3] << fixedLengthWithOffset
+    //              [0, 1, 2, 3, ...] << lengthTracking
+    //                    [2, 3, ...] << lengthTrackingWithOffset
+
+    function isEven(n) {
+      return n != undefined && Number(n) % 2 == 0;
+    }
+
+    assertEquals([0, 2], ToNumbers(fixedLength.filter(isEven)));
+    assertEquals([2], ToNumbers(fixedLengthWithOffset.filter(isEven)));
+    assertEquals([0, 2], ToNumbers(lengthTracking.filter(isEven)));
+    assertEquals([2], ToNumbers(lengthTrackingWithOffset.filter(isEven)));
+
+    // Grow.
+    gsab.grow(6 * ctor.BYTES_PER_ELEMENT);
+    for (let i = 0; i < 6; ++i) {
+      WriteToTypedArray(taWrite, i, i);
+    }
+
+    // Orig. array: [0, 1, 2, 3, 4, 5]
+    //              [0, 1, 2, 3] << fixedLength
+    //                    [2, 3] << fixedLengthWithOffset
+    //              [0, 1, 2, 3, 4, 5, ...] << lengthTracking
+    //                    [2, 3, 4, 5, ...] << lengthTrackingWithOffset
+
+    assertEquals([0, 2], ToNumbers(fixedLength.filter(isEven)));
+    assertEquals([2], ToNumbers(fixedLengthWithOffset.filter(isEven)));
+    assertEquals([0, 2, 4], ToNumbers(lengthTracking.filter(isEven)));
+    assertEquals([2, 4], ToNumbers(lengthTrackingWithOffset.filter(isEven)));
+  }
+})();
+
+(function FilterGrowMidIteration() {
+  // Orig. array: [0, 2, 4, 6]
+  //              [0, 2, 4, 6] << fixedLength
+  //                    [4, 6] << fixedLengthWithOffset
+  //              [0, 2, 4, 6, ...] << lengthTracking
+  //                    [4, 6, ...] << lengthTrackingWithOffset
+  function CreateGsabForTest(ctor) {
+    const gsab = CreateGrowableSharedArrayBuffer(4 * ctor.BYTES_PER_ELEMENT,
+                                                 8 * ctor.BYTES_PER_ELEMENT);
+    // Write some data into the array.
+    const taWrite = new ctor(gsab);
+    for (let i = 0; i < 4; ++i) {
+      WriteToTypedArray(taWrite, i, 2 * i);
+    }
+    return gsab;
+  }
+
+  let values;
+  let gsab;
+  let growAfter;
+  let growTo;
+  function CollectValuesAndGrow(n) {
+    if (n == undefined) {
+      values.push(n);
+    } else {
+      values.push(Number(n));
+    }
+    if (values.length == growAfter) {
+      gsab.grow(growTo);
+    }
+    return false;
+  }
+
+  for (let ctor of ctors) {
+    gsab = CreateGsabForTest(ctor);
+    const fixedLength = new ctor(gsab, 0, 4);
+    values = [];
+    growAfter = 2;
+    growTo = 5 * ctor.BYTES_PER_ELEMENT;
+    assertEquals([], ToNumbers(fixedLength.filter(CollectValuesAndGrow)));
+    assertEquals([0, 2, 4, 6], values);
+  }
+
+  for (let ctor of ctors) {
+    gsab = CreateGsabForTest(ctor);
+    const fixedLengthWithOffset = new ctor(gsab, 2 * ctor.BYTES_PER_ELEMENT, 2);
+    values = [];
+    growAfter = 1;
+    growTo = 5 * ctor.BYTES_PER_ELEMENT;
+    assertEquals([], ToNumbers(fixedLengthWithOffset.filter(CollectValuesAndGrow)));
+    assertEquals([4, 6], values);
+  }
+
+  for (let ctor of ctors) {
+    gsab = CreateGsabForTest(ctor);
+    const lengthTracking = new ctor(gsab, 0);
+    values = [];
+    growAfter = 2;
+    growTo = 5 * ctor.BYTES_PER_ELEMENT;
+    assertEquals([], ToNumbers(lengthTracking.filter(CollectValuesAndGrow)));
+    assertEquals([0, 2, 4, 6], values);
+  }
+
+  for (let ctor of ctors) {
+    gsab = CreateGsabForTest(ctor);
+    const lengthTrackingWithOffset = new ctor(gsab, 2 * ctor.BYTES_PER_ELEMENT);
+    values = [];
+    growAfter = 1;
+    growTo = 5 * ctor.BYTES_PER_ELEMENT;
+    assertEquals([], ToNumbers(lengthTrackingWithOffset.filter(CollectValuesAndGrow)));
+    assertEquals([4, 6], values);
+  }
+})();
+
+(function ForEachReduceReduceRight() {
+  for (let ctor of ctors) {
+    const gsab = CreateGrowableSharedArrayBuffer(4 * ctor.BYTES_PER_ELEMENT,
+                                                 8 * ctor.BYTES_PER_ELEMENT);
+    const fixedLength = new ctor(gsab, 0, 4);
+    const fixedLengthWithOffset = new ctor(gsab, 2 * ctor.BYTES_PER_ELEMENT, 2);
+    const lengthTracking = new ctor(gsab, 0);
+    const lengthTrackingWithOffset = new ctor(gsab, 2 * ctor.BYTES_PER_ELEMENT);
+
+    // Write some data into the array.
+    const taWrite = new ctor(gsab);
+    for (let i = 0; i < 4; ++i) {
+      WriteToTypedArray(taWrite, i, 2 * i);
+    }
+
+    // Orig. array: [0, 2, 4, 6]
+    //              [0, 2, 4, 6] << fixedLength
+    //                    [4, 6] << fixedLengthWithOffset
+    //              [0, 2, 4, 6, ...] << lengthTracking
+    //                    [4, 6, ...] << lengthTrackingWithOffset
+
+    function Helper(array) {
+      const forEachValues = [];
+      const reduceValues = [];
+      const reduceRightValues = [];
+
+      array.forEach((n) => { forEachValues.push(n);});
+
+      array.reduce((acc, n) => {
+        reduceValues.push(n);
+      }, "initial value");
+
+      array.reduceRight((acc, n) => {
+        reduceRightValues.push(n);
+      }, "initial value");
+
+      assertEquals(reduceValues, forEachValues);
+      reduceRightValues.reverse();
+      assertEquals(reduceValues, reduceRightValues);
+      return ToNumbers(forEachValues);
+    }
+
+    assertEquals([0, 2, 4, 6], Helper(fixedLength));
+    assertEquals([4, 6], Helper(fixedLengthWithOffset));
+    assertEquals([0, 2, 4, 6], Helper(lengthTracking));
+    assertEquals([4, 6], Helper(lengthTrackingWithOffset));
+
+    // Grow.
+    gsab.grow(6 * ctor.BYTES_PER_ELEMENT);
+    for (let i = 0; i < 6; ++i) {
+      WriteToTypedArray(taWrite, i, 2 * i);
+    }
+
+    // Orig. array: [0, 2, 4, 6, 8, 10]
+    //              [0, 2, 4, 6] << fixedLength
+    //                    [4, 6] << fixedLengthWithOffset
+    //              [0, 2, 4, 6, 8, 10, ...] << lengthTracking
+    //                    [4, 6, 8, 10, ...] << lengthTrackingWithOffset
+
+    assertEquals([0, 2, 4, 6], Helper(fixedLength));
+    assertEquals([4, 6], Helper(fixedLengthWithOffset));
+    assertEquals([0, 2, 4, 6, 8, 10], Helper(lengthTracking));
+    assertEquals([4, 6, 8, 10], Helper(lengthTrackingWithOffset));
+  }
+})();
+
+(function ForEachReduceReduceRightGrowMidIteration() {
+  // Orig. array: [0, 2, 4, 6]
+  //              [0, 2, 4, 6] << fixedLength
+  //                    [4, 6] << fixedLengthWithOffset
+  //              [0, 2, 4, 6, ...] << lengthTracking
+  //                    [4, 6, ...] << lengthTrackingWithOffset
+  function CreateGsabForTest(ctor) {
+    const gsab = CreateGrowableSharedArrayBuffer(4 * ctor.BYTES_PER_ELEMENT,
+                                                 8 * ctor.BYTES_PER_ELEMENT);
+    // Write some data into the array.
+    const taWrite = new ctor(gsab);
+    for (let i = 0; i < 4; ++i) {
+      WriteToTypedArray(taWrite, i, 2 * i);
+    }
+    return gsab;
+  }
+
+  let values;
+  let gsab;
+  let growAfter;
+  let growTo;
+  function CollectValuesAndResize(n) {
+    if (typeof n == 'bigint') {
+      values.push(Number(n));
+    } else {
+      values.push(n);
+    }
+    if (values.length == growAfter) {
+      gsab.grow(growTo);
+    }
+    return true;
+  }
+
+  function ForEachHelper(array) {
+    values = [];
+    array.forEach(CollectValuesAndResize);
+    return values;
+  }
+
+  function ReduceHelper(array) {
+    values = [];
+    array.reduce((acc, n) => { CollectValuesAndResize(n); }, "initial value");
+    return values;
+  }
+
+  function ReduceRightHelper(array) {
+    values = [];
+    array.reduceRight((acc, n) => { CollectValuesAndResize(n); },
+                      "initial value");
+    return values;
+  }
+
+  // Test for forEach.
+
+  for (let ctor of ctors) {
+    gsab = CreateGsabForTest(ctor);
+    const fixedLength = new ctor(gsab, 0, 4);
+    growAfter = 2;
+    growTo = 5 * ctor.BYTES_PER_ELEMENT;
+    assertEquals([0, 2, 4, 6], ForEachHelper(fixedLength));
+  }
+
+  for (let ctor of ctors) {
+    gsab = CreateGsabForTest(ctor);
+    const fixedLengthWithOffset = new ctor(gsab, 2 * ctor.BYTES_PER_ELEMENT, 2);
+    growAfter = 1;
+    growTo = 5 * ctor.BYTES_PER_ELEMENT;
+    assertEquals([4, 6], ForEachHelper(fixedLengthWithOffset));
+  }
+
+  for (let ctor of ctors) {
+    gsab = CreateGsabForTest(ctor);
+    const lengthTracking = new ctor(gsab, 0);
+    growAfter = 2;
+    growTo = 5 * ctor.BYTES_PER_ELEMENT;
+    assertEquals([0, 2, 4, 6], ForEachHelper(lengthTracking));
+  }
+
+  for (let ctor of ctors) {
+    gsab = CreateGsabForTest(ctor);
+    const lengthTrackingWithOffset = new ctor(gsab, 2 * ctor.BYTES_PER_ELEMENT);
+    growAfter = 1;
+    growTo = 5 * ctor.BYTES_PER_ELEMENT;
+    assertEquals([4, 6], ForEachHelper(lengthTrackingWithOffset));
+  }
+
+  // Test for reduce.
+
+  for (let ctor of ctors) {
+    gsab = CreateGsabForTest(ctor);
+    const fixedLength = new ctor(gsab, 0, 4);
+    growAfter = 2;
+    growTo = 5 * ctor.BYTES_PER_ELEMENT;
+    assertEquals([0, 2, 4, 6], ReduceHelper(fixedLength));
+  }
+
+  for (let ctor of ctors) {
+    gsab = CreateGsabForTest(ctor);
+    const fixedLengthWithOffset = new ctor(gsab, 2 * ctor.BYTES_PER_ELEMENT, 2);
+    growAfter = 1;
+    growTo = 5 * ctor.BYTES_PER_ELEMENT;
+    assertEquals([4, 6], ReduceHelper(fixedLengthWithOffset));
+  }
+
+  for (let ctor of ctors) {
+    gsab = CreateGsabForTest(ctor);
+    const lengthTracking = new ctor(gsab, 0);
+    growAfter = 2;
+    growTo = 5 * ctor.BYTES_PER_ELEMENT;
+    assertEquals([0, 2, 4, 6], ReduceHelper(lengthTracking));
+  }
+
+  for (let ctor of ctors) {
+    gsab = CreateGsabForTest(ctor);
+    const lengthTrackingWithOffset = new ctor(gsab, 2 * ctor.BYTES_PER_ELEMENT);
+    growAfter = 1;
+    growTo = 5 * ctor.BYTES_PER_ELEMENT;
+    assertEquals([4, 6], ReduceHelper(lengthTrackingWithOffset));
+  }
+
+  // Test for reduceRight.
+
+  for (let ctor of ctors) {
+    gsab = CreateGsabForTest(ctor);
+    const fixedLength = new ctor(gsab, 0, 4);
+    growAfter = 2;
+    growTo = 5 * ctor.BYTES_PER_ELEMENT;
+    assertEquals([6, 4, 2, 0], ReduceRightHelper(fixedLength));
+  }
+
+  for (let ctor of ctors) {
+    gsab = CreateGsabForTest(ctor);
+    const fixedLengthWithOffset = new ctor(gsab, 2 * ctor.BYTES_PER_ELEMENT, 2);
+    growAfter = 1;
+    growTo = 5 * ctor.BYTES_PER_ELEMENT;
+    assertEquals([6, 4], ReduceRightHelper(fixedLengthWithOffset));
+  }
+
+  for (let ctor of ctors) {
+    gsab = CreateGsabForTest(ctor);
+    const lengthTracking = new ctor(gsab, 0);
+    growAfter = 2;
+    growTo = 5 * ctor.BYTES_PER_ELEMENT;
+    assertEquals([6, 4, 2, 0], ReduceRightHelper(lengthTracking));
+  }
+
+  for (let ctor of ctors) {
+    gsab = CreateGsabForTest(ctor);
+    const lengthTrackingWithOffset = new ctor(gsab, 2 * ctor.BYTES_PER_ELEMENT);
+    growAfter = 1;
+    growTo = 5 * ctor.BYTES_PER_ELEMENT;
+    assertEquals([6, 4], ReduceRightHelper(lengthTrackingWithOffset));
+  }
+})();

test/mjsunit/typedarray-helpers.js

@@ -45,7 +45,11 @@ function WriteToTypedArray(array, index, value) {
 function ToNumbers(array) {
   let result = [];
   for (let item of array) {
-    result.push(Number(item));
+    if (typeof item == 'bigint') {
+      result.push(Number(item));
+    } else {
+      result.push(item);
+    }
   }
   return result;
 }

test/mjsunit/typedarray-resizablearraybuffer-detach.js

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-// Flags: --harmony-rab-gsab --allow-natives-syntax
+// Flags: --harmony-rab-gsab --allow-natives-syntax --harmony-array-find-last
 
 "use strict";
 
@@ -171,7 +171,7 @@ d8.file.execute('test/mjsunit/typedarray-helpers.js');
   let values = [];
   let rab;
   let detachAfter;
-  function myFunc(n) {
+  function CollectValuesAndDetach(n) {
     if (n == undefined) {
       values.push(n);
     } else {
@@ -188,7 +188,7 @@ d8.file.execute('test/mjsunit/typedarray-helpers.js');
     const fixedLength = new ctor(rab, 0, 4);
     values = [];
     detachAfter = 2;
-    assertTrue(fixedLength.every(myFunc));
+    assertTrue(fixedLength.every(CollectValuesAndDetach));
     assertEquals([0, 2, undefined, undefined], values);
   }
 
@@ -197,7 +197,7 @@ d8.file.execute('test/mjsunit/typedarray-helpers.js');
     const fixedLengthWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT, 2);
     values = [];
     detachAfter = 1;
-    assertTrue(fixedLengthWithOffset.every(myFunc));
+    assertTrue(fixedLengthWithOffset.every(CollectValuesAndDetach));
     assertEquals([4, undefined], values);
   }
 
@@ -206,7 +206,7 @@ d8.file.execute('test/mjsunit/typedarray-helpers.js');
     const lengthTracking = new ctor(rab, 0);
     values = [];
     detachAfter = 2;
-    assertTrue(lengthTracking.every(myFunc));
+    assertTrue(lengthTracking.every(CollectValuesAndDetach));
     assertEquals([0, 2, undefined, undefined], values);
   }
 
@@ -215,7 +215,7 @@ d8.file.execute('test/mjsunit/typedarray-helpers.js');
     const lengthTrackingWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT);
     values = [];
     detachAfter = 1;
-    assertTrue(lengthTrackingWithOffset.every(myFunc));
+    assertTrue(lengthTrackingWithOffset.every(CollectValuesAndDetach));
     assertEquals([4, undefined], values);
   }
 })();
@@ -240,7 +240,7 @@ d8.file.execute('test/mjsunit/typedarray-helpers.js');
   let values;
   let rab;
   let detachAfter;
-  function myFunc(n) {
+  function CollectValuesAndDetach(n) {
     if (n == undefined) {
       values.push(n);
     } else {
@@ -257,7 +257,7 @@ d8.file.execute('test/mjsunit/typedarray-helpers.js');
     const fixedLength = new ctor(rab, 0, 4);
     values = [];
     detachAfter = 2;
-    assertFalse(fixedLength.some(myFunc));
+    assertFalse(fixedLength.some(CollectValuesAndDetach));
     assertEquals([0, 2, undefined, undefined], values);
   }
 
@@ -266,7 +266,7 @@ d8.file.execute('test/mjsunit/typedarray-helpers.js');
     const fixedLengthWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT, 2);
     values = [];
     detachAfter = 1;
-    assertFalse(fixedLengthWithOffset.some(myFunc));
+    assertFalse(fixedLengthWithOffset.some(CollectValuesAndDetach));
     assertEquals([4, undefined], values);
   }
 
@@ -275,7 +275,7 @@ d8.file.execute('test/mjsunit/typedarray-helpers.js');
     const lengthTracking = new ctor(rab, 0);
     values = [];
     detachAfter = 2;
-    assertFalse(lengthTracking.some(myFunc));
+    assertFalse(lengthTracking.some(CollectValuesAndDetach));
     assertEquals([0, 2, undefined, undefined], values);
   }
 
@@ -284,7 +284,494 @@ d8.file.execute('test/mjsunit/typedarray-helpers.js');
     const lengthTrackingWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT);
     values = [];
     detachAfter = 1;
-    assertFalse(lengthTrackingWithOffset.some(myFunc));
+    assertFalse(lengthTrackingWithOffset.some(CollectValuesAndDetach));
     assertEquals([4, undefined], values);
   }
 })();
+
+(function FindDetachMidIteration() {
+  // Orig. array: [0, 2, 4, 6]
+  //              [0, 2, 4, 6] << fixedLength
+  //                    [4, 6] << fixedLengthWithOffset
+  //              [0, 2, 4, 6, ...] << lengthTracking
+  //                    [4, 6, ...] << lengthTrackingWithOffset
+  function CreateRabForTest(ctor) {
+    const rab = CreateResizableArrayBuffer(4 * ctor.BYTES_PER_ELEMENT,
+                                           8 * ctor.BYTES_PER_ELEMENT);
+    // Write some data into the array.
+    const taWrite = new ctor(rab);
+    for (let i = 0; i < 4; ++i) {
+      WriteToTypedArray(taWrite, i, 2 * i);
+    }
+    return rab;
+  }
+
+  let values;
+  let rab;
+  let detachAfter;
+  function CollectValuesAndDetach(n) {
+    if (n == undefined) {
+      values.push(n);
+    } else {
+      values.push(Number(n));
+    }
+    if (values.length == detachAfter) {
+      %ArrayBufferDetach(rab);
+    }
+    return false;
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const fixedLength = new ctor(rab, 0, 4);
+    values = [];
+    detachAfter = 2;
+    assertEquals(undefined, fixedLength.find(CollectValuesAndDetach));
+    assertEquals([0, 2, undefined, undefined], values);
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const fixedLengthWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT, 2);
+    values = [];
+    detachAfter = 1;
+    assertEquals(undefined, fixedLengthWithOffset.find(CollectValuesAndDetach));
+    assertEquals([4, undefined], values);
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const lengthTracking = new ctor(rab, 0);
+    values = [];
+    detachAfter = 2;
+    assertEquals(undefined, lengthTracking.find(CollectValuesAndDetach));
+    assertEquals([0, 2, undefined, undefined], values);
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const lengthTrackingWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT);
+    values = [];
+    detachAfter = 1;
+    assertEquals(undefined, lengthTrackingWithOffset.find(CollectValuesAndDetach));
+    assertEquals([4, undefined], values);
+  }
+})();
+
+(function FindIndexDetachMidIteration() {
+  // Orig. array: [0, 2, 4, 6]
+  //              [0, 2, 4, 6] << fixedLength
+  //                    [4, 6] << fixedLengthWithOffset
+  //              [0, 2, 4, 6, ...] << lengthTracking
+  //                    [4, 6, ...] << lengthTrackingWithOffset
+  function CreateRabForTest(ctor) {
+    const rab = CreateResizableArrayBuffer(4 * ctor.BYTES_PER_ELEMENT,
+                                           8 * ctor.BYTES_PER_ELEMENT);
+    // Write some data into the array.
+    const taWrite = new ctor(rab);
+    for (let i = 0; i < 4; ++i) {
+      WriteToTypedArray(taWrite, i, 2 * i);
+    }
+    return rab;
+  }
+
+  let values;
+  let rab;
+  let detachAfter;
+  function CollectValuesAndDetach(n) {
+    if (n == undefined) {
+      values.push(n);
+    } else {
+      values.push(Number(n));
+    }
+    if (values.length == detachAfter) {
+      %ArrayBufferDetach(rab);
+    }
+    return false;
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const fixedLength = new ctor(rab, 0, 4);
+    values = [];
+    detachAfter = 2;
+    assertEquals(-1, fixedLength.findIndex(CollectValuesAndDetach));
+    assertEquals([0, 2, undefined, undefined], values);
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const fixedLengthWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT, 2);
+    values = [];
+    detachAfter = 1;
+    assertEquals(-1, fixedLengthWithOffset.findIndex(CollectValuesAndDetach));
+    assertEquals([4, undefined], values);
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const lengthTracking = new ctor(rab, 0);
+    values = [];
+    detachAfter = 2;
+    assertEquals(-1, lengthTracking.findIndex(CollectValuesAndDetach));
+    assertEquals([0, 2, undefined, undefined], values);
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const lengthTrackingWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT);
+    values = [];
+    detachAfter = 1;
+    assertEquals(-1, lengthTrackingWithOffset.findIndex(CollectValuesAndDetach));
+    assertEquals([4, undefined], values);
+  }
+})();
+
+(function FindLastDetachMidIteration() {
+  // Orig. array: [0, 2, 4, 6]
+  //              [0, 2, 4, 6] << fixedLength
+  //                    [4, 6] << fixedLengthWithOffset
+  //              [0, 2, 4, 6, ...] << lengthTracking
+  //                    [4, 6, ...] << lengthTrackingWithOffset
+  function CreateRabForTest(ctor) {
+    const rab = CreateResizableArrayBuffer(4 * ctor.BYTES_PER_ELEMENT,
+                                           8 * ctor.BYTES_PER_ELEMENT);
+    // Write some data into the array.
+    const taWrite = new ctor(rab);
+    for (let i = 0; i < 4; ++i) {
+      WriteToTypedArray(taWrite, i, 2 * i);
+    }
+    return rab;
+  }
+
+  let values;
+  let rab;
+  let detachAfter;
+  function CollectValuesAndDetach(n) {
+    if (n == undefined) {
+      values.push(n);
+    } else {
+      values.push(Number(n));
+    }
+    if (values.length == detachAfter) {
+      %ArrayBufferDetach(rab);
+    }
+    return false;
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const fixedLength = new ctor(rab, 0, 4);
+    values = [];
+    detachAfter = 2;
+    assertEquals(undefined, fixedLength.findLast(CollectValuesAndDetach));
+    assertEquals([6, 4, undefined, undefined], values);
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const fixedLengthWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT, 2);
+    values = [];
+    detachAfter = 1;
+    assertEquals(undefined, fixedLengthWithOffset.findLast(CollectValuesAndDetach));
+    assertEquals([6, undefined], values);
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const lengthTracking = new ctor(rab, 0);
+    values = [];
+    detachAfter = 2;
+    assertEquals(undefined, lengthTracking.findLast(CollectValuesAndDetach));
+    assertEquals([6, 4, undefined, undefined], values);
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const lengthTrackingWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT);
+    values = [];
+    detachAfter = 1;
+    assertEquals(undefined, lengthTrackingWithOffset.findLast(CollectValuesAndDetach));
+    assertEquals([6, undefined], values);
+  }
+})();
+
+(function FindLastIndexDetachMidIteration() {
+  // Orig. array: [0, 2, 4, 6]
+  //              [0, 2, 4, 6] << fixedLength
+  //                    [4, 6] << fixedLengthWithOffset
+  //              [0, 2, 4, 6, ...] << lengthTracking
+  //                    [4, 6, ...] << lengthTrackingWithOffset
+  function CreateRabForTest(ctor) {
+    const rab = CreateResizableArrayBuffer(4 * ctor.BYTES_PER_ELEMENT,
+                                           8 * ctor.BYTES_PER_ELEMENT);
+    // Write some data into the array.
+    const taWrite = new ctor(rab);
+    for (let i = 0; i < 4; ++i) {
+      WriteToTypedArray(taWrite, i, 2 * i);
+    }
+    return rab;
+  }
+
+  let values;
+  let rab;
+  let detachAfter;
+  function CollectValuesAndDetach(n) {
+    if (n == undefined) {
+      values.push(n);
+    } else {
+      values.push(Number(n));
+    }
+    if (values.length == detachAfter) {
+      %ArrayBufferDetach(rab);
+    }
+    return false;
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const fixedLength = new ctor(rab, 0, 4);
+    values = [];
+    detachAfter = 2;
+    assertEquals(-1, fixedLength.findLastIndex(CollectValuesAndDetach));
+    assertEquals([6, 4, undefined, undefined], values);
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const fixedLengthWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT, 2);
+    values = [];
+    detachAfter = 1;
+    assertEquals(-1, fixedLengthWithOffset.findLastIndex(CollectValuesAndDetach));
+    assertEquals([6, undefined], values);
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const lengthTracking = new ctor(rab, 0);
+    values = [];
+    detachAfter = 2;
+    assertEquals(-1, lengthTracking.findLastIndex(CollectValuesAndDetach));
+    assertEquals([6, 4, undefined, undefined], values);
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const lengthTrackingWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT);
+    values = [];
+    detachAfter = 1;
+    assertEquals(-1, lengthTrackingWithOffset.findLastIndex(CollectValuesAndDetach));
+    assertEquals([6, undefined], values);
+  }
+})();
+
+(function FilterShrinkMidIteration() {
+  // Orig. array: [0, 2, 4, 6]
+  //              [0, 2, 4, 6] << fixedLength
+  //                    [4, 6] << fixedLengthWithOffset
+  //              [0, 2, 4, 6, ...] << lengthTracking
+  //                    [4, 6, ...] << lengthTrackingWithOffset
+  function CreateRabForTest(ctor) {
+    const rab = CreateResizableArrayBuffer(4 * ctor.BYTES_PER_ELEMENT,
+                                           8 * ctor.BYTES_PER_ELEMENT);
+    // Write some data into the array.
+    const taWrite = new ctor(rab);
+    for (let i = 0; i < 4; ++i) {
+      WriteToTypedArray(taWrite, i, 2 * i);
+    }
+    return rab;
+  }
+
+  let values;
+  let rab;
+  let detachAfter;
+  function CollectValuesAndDetach(n) {
+    if (n == undefined) {
+      values.push(n);
+    } else {
+      values.push(Number(n));
+    }
+    if (values.length == detachAfter) {
+       %ArrayBufferDetach(rab);
+    }
+    return false;
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const fixedLength = new ctor(rab, 0, 4);
+    values = [];
+    detachAfter = 2;
+    assertEquals([], ToNumbers(fixedLength.filter(CollectValuesAndDetach)));
+    assertEquals([0, 2, undefined, undefined], values);
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const fixedLengthWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT, 2);
+    values = [];
+    detachAfter = 1;
+    assertEquals([], ToNumbers(fixedLengthWithOffset.filter(CollectValuesAndDetach)));
+    assertEquals([4, undefined], values);
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const lengthTracking = new ctor(rab, 0);
+    values = [];
+    detachAfter = 2;
+    assertEquals([], ToNumbers(lengthTracking.filter(CollectValuesAndDetach)));
+    assertEquals([0, 2, undefined, undefined], values);
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const lengthTrackingWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT);
+    values = [];
+    detachAfter = 1;
+    assertEquals([], ToNumbers(lengthTrackingWithOffset.filter(CollectValuesAndDetach)));
+    assertEquals([4, undefined], values);
+  }
+})();
+
+(function ForEachReduceReduceRightDetachMidIteration() {
+  // Orig. array: [0, 2, 4, 6]
+  //              [0, 2, 4, 6] << fixedLength
+  //                    [4, 6] << fixedLengthWithOffset
+  //              [0, 2, 4, 6, ...] << lengthTracking
+  //                    [4, 6, ...] << lengthTrackingWithOffset
+  function CreateRabForTest(ctor) {
+    const rab = CreateResizableArrayBuffer(4 * ctor.BYTES_PER_ELEMENT,
+                                           8 * ctor.BYTES_PER_ELEMENT);
+    // Write some data into the array.
+    const taWrite = new ctor(rab);
+    for (let i = 0; i < 4; ++i) {
+      WriteToTypedArray(taWrite, i, 2 * i);
+    }
+    return rab;
+  }
+
+  let values;
+  let rab;
+  let detachAfter;
+  function CollectValuesAndResize(n) {
+    if (typeof n == 'bigint') {
+      values.push(Number(n));
+    } else {
+      values.push(n);
+    }
+    if (values.length == detachAfter) {
+      %ArrayBufferDetach(rab);
+    }
+    return true;
+  }
+
+  function ForEachHelper(array) {
+    values = [];
+    array.forEach(CollectValuesAndResize);
+    return values;
+  }
+
+  function ReduceHelper(array) {
+    values = [];
+    array.reduce((acc, n) => { CollectValuesAndResize(n); }, "initial value");
+    return values;
+  }
+
+  function ReduceRightHelper(array) {
+    values = [];
+    array.reduceRight((acc, n) => { CollectValuesAndResize(n); },
+                      "initial value");
+    return values;
+  }
+
+  // Test for forEach.
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const fixedLength = new ctor(rab, 0, 4);
+    detachAfter = 2;
+    assertEquals([0, 2, undefined, undefined], ForEachHelper(fixedLength));
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const fixedLengthWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT, 2);
+    detachAfter = 1;
+    assertEquals([4, undefined], ForEachHelper(fixedLengthWithOffset));
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const lengthTracking = new ctor(rab, 0);
+    detachAfter = 2;
+    assertEquals([0, 2, undefined, undefined], ForEachHelper(lengthTracking));
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const lengthTrackingWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT);
+    detachAfter = 1;
+    assertEquals([4, undefined], ForEachHelper(lengthTrackingWithOffset));
+  }
+
+  // Tests for reduce.
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const fixedLength = new ctor(rab, 0, 4);
+    detachAfter = 2;
+    assertEquals([0, 2, undefined, undefined], ReduceHelper(fixedLength));
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const fixedLengthWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT, 2);
+    detachAfter = 1;
+    assertEquals([4, undefined], ReduceHelper(fixedLengthWithOffset));
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const lengthTracking = new ctor(rab, 0);
+    detachAfter = 2;
+    assertEquals([0, 2, undefined, undefined], ReduceHelper(lengthTracking));
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const lengthTrackingWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT);
+    detachAfter = 1;
+    assertEquals([4, undefined], ReduceHelper(lengthTrackingWithOffset));
+  }
+
+  // Tests for reduceRight.
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const fixedLength = new ctor(rab, 0, 4);
+    detachAfter = 2;
+    assertEquals([6, 4, undefined, undefined], ReduceRightHelper(fixedLength));
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const fixedLengthWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT, 2);
+    detachAfter = 1;
+    assertEquals([6, undefined], ReduceRightHelper(fixedLengthWithOffset));
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const lengthTracking = new ctor(rab, 0);
+    detachAfter = 2;
+   assertEquals([6, 4, undefined, undefined], ReduceRightHelper(lengthTracking));
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const lengthTrackingWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT);
+    detachAfter = 1;
+    assertEquals([6, undefined], ReduceRightHelper(lengthTrackingWithOffset));
+  }
+})();

test/mjsunit/typedarray-resizablearraybuffer.js

@@ -3,7 +3,7 @@
 // found in the LICENSE file.
 
 // Flags: --harmony-rab-gsab --allow-natives-syntax
-// Flags: --harmony-relative-indexing-methods
+// Flags: --harmony-relative-indexing-methods --harmony-array-find-last
 
 "use strict";
 
@@ -2143,11 +2143,11 @@ function TestIterationAndResize(ta, expected, rab, resize_after,
   let rab;
   let resizeAfter;
   let resizeTo;
-  function myFunc(n) {
-    if (n == undefined) {
-      values.push(n);
-    } else {
+  function CollectValuesAndResize(n) {
+    if (typeof n == 'bigint') {
       values.push(Number(n));
+    } else {
+      values.push(n);
     }
     if (values.length == resizeAfter) {
       rab.resize(resizeTo);
@@ -2161,7 +2161,7 @@ function TestIterationAndResize(ta, expected, rab, resize_after,
     values = [];
     resizeAfter = 2;
     resizeTo = 3 * ctor.BYTES_PER_ELEMENT;
-    assertTrue(fixedLength.every(myFunc));
+    assertTrue(fixedLength.every(CollectValuesAndResize));
     assertEquals([0, 2, undefined, undefined], values);
   }
 
@@ -2171,7 +2171,7 @@ function TestIterationAndResize(ta, expected, rab, resize_after,
     values = [];
     resizeAfter = 1;
     resizeTo = 3 * ctor.BYTES_PER_ELEMENT;
-    assertTrue(fixedLengthWithOffset.every(myFunc));
+    assertTrue(fixedLengthWithOffset.every(CollectValuesAndResize));
     assertEquals([4, undefined], values);
   }
 
@@ -2181,7 +2181,7 @@ function TestIterationAndResize(ta, expected, rab, resize_after,
     values = [];
     resizeAfter = 2;
     resizeTo = 3 * ctor.BYTES_PER_ELEMENT;
-    assertTrue(lengthTracking.every(myFunc));
+    assertTrue(lengthTracking.every(CollectValuesAndResize));
     assertEquals([0, 2, 4, undefined], values);
   }
 
@@ -2191,7 +2191,7 @@ function TestIterationAndResize(ta, expected, rab, resize_after,
     values = [];
     resizeAfter = 1;
     resizeTo = 3 * ctor.BYTES_PER_ELEMENT;
-    assertTrue(lengthTrackingWithOffset.every(myFunc));
+    assertTrue(lengthTrackingWithOffset.every(CollectValuesAndResize));
     assertEquals([4, undefined], values);
   }
 })();
@@ -2217,11 +2217,11 @@ function TestIterationAndResize(ta, expected, rab, resize_after,
   let rab;
   let resizeAfter;
   let resizeTo;
-  function myFunc(n) {
-    if (n == undefined) {
-      values.push(n);
-    } else {
+  function CollectValuesAndResize(n) {
+    if (typeof n == 'bigint') {
       values.push(Number(n));
+    } else {
+      values.push(n);
     }
     if (values.length == resizeAfter) {
       rab.resize(resizeTo);
@@ -2235,7 +2235,7 @@ function TestIterationAndResize(ta, expected, rab, resize_after,
     values = [];
     resizeAfter = 2;
     resizeTo = 5 * ctor.BYTES_PER_ELEMENT;
-    assertTrue(fixedLength.every(myFunc));
+    assertTrue(fixedLength.every(CollectValuesAndResize));
     assertEquals([0, 2, 4, 6], values);
   }
 
@@ -2245,7 +2245,7 @@ function TestIterationAndResize(ta, expected, rab, resize_after,
     values = [];
     resizeAfter = 1;
     resizeTo = 5 * ctor.BYTES_PER_ELEMENT;
-    assertTrue(fixedLengthWithOffset.every(myFunc));
+    assertTrue(fixedLengthWithOffset.every(CollectValuesAndResize));
     assertEquals([4, 6], values);
   }
 
@@ -2255,7 +2255,7 @@ function TestIterationAndResize(ta, expected, rab, resize_after,
     values = [];
     resizeAfter = 2;
     resizeTo = 5 * ctor.BYTES_PER_ELEMENT;
-    assertTrue(lengthTracking.every(myFunc));
+    assertTrue(lengthTracking.every(CollectValuesAndResize));
     assertEquals([0, 2, 4, 6], values);
   }
 
@@ -2265,7 +2265,7 @@ function TestIterationAndResize(ta, expected, rab, resize_after,
     values = [];
     resizeAfter = 1;
     resizeTo = 5 * ctor.BYTES_PER_ELEMENT;
-    assertTrue(lengthTrackingWithOffset.every(myFunc));
+    assertTrue(lengthTrackingWithOffset.every(CollectValuesAndResize));
     assertEquals([4, 6], values);
   }
 })();
@@ -2291,11 +2291,11 @@ function TestIterationAndResize(ta, expected, rab, resize_after,
   let rab;
   let resizeAfter;
   let resizeTo;
-  function myFunc(n) {
-    if (n == undefined) {
-      values.push(n);
-    } else {
+  function CollectValuesAndResize(n) {
+    if (typeof n == 'bigint') {
       values.push(Number(n));
+    } else {
+      values.push(n);
     }
     if (values.length == resizeAfter) {
       rab.resize(resizeTo);
@@ -2309,7 +2309,7 @@ function TestIterationAndResize(ta, expected, rab, resize_after,
     values = [];
     resizeAfter = 2;
     resizeTo = 3 * ctor.BYTES_PER_ELEMENT;
-    assertFalse(fixedLength.some(myFunc));
+    assertFalse(fixedLength.some(CollectValuesAndResize));
     assertEquals([0, 2, undefined, undefined], values);
   }
 
@@ -2319,7 +2319,7 @@ function TestIterationAndResize(ta, expected, rab, resize_after,
     values = [];
     resizeAfter = 1;
     resizeTo = 3 * ctor.BYTES_PER_ELEMENT;
-    assertFalse(fixedLengthWithOffset.some(myFunc));
+    assertFalse(fixedLengthWithOffset.some(CollectValuesAndResize));
     assertEquals([4, undefined], values);
   }
 
@@ -2329,7 +2329,7 @@ function TestIterationAndResize(ta, expected, rab, resize_after,
     values = [];
     resizeAfter = 2;
     resizeTo = 3 * ctor.BYTES_PER_ELEMENT;
-    assertFalse(lengthTracking.some(myFunc));
+    assertFalse(lengthTracking.some(CollectValuesAndResize));
     assertEquals([0, 2, 4, undefined], values);
   }
 
@@ -2339,7 +2339,7 @@ function TestIterationAndResize(ta, expected, rab, resize_after,
     values = [];
     resizeAfter = 1;
     resizeTo = 3 * ctor.BYTES_PER_ELEMENT;
-    assertFalse(lengthTrackingWithOffset.some(myFunc));
+    assertFalse(lengthTrackingWithOffset.some(CollectValuesAndResize));
     assertEquals([4, undefined], values);
   }
 })();
@@ -2365,11 +2365,316 @@ function TestIterationAndResize(ta, expected, rab, resize_after,
   let rab;
   let resizeAfter;
   let resizeTo;
-  function myFunc(n) {
-    if (n == undefined) {
+  function CollectValuesAndResize(n) {
+    if (typeof n == 'bigint') {
+      values.push(Number(n));
+    } else {
       values.push(n);
+    }
+    if (values.length == resizeAfter) {
+      rab.resize(resizeTo);
+    }
+    return false;
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const fixedLength = new ctor(rab, 0, 4);
+    values = [];
+    resizeAfter = 2;
+    resizeTo = 5 * ctor.BYTES_PER_ELEMENT;
+    assertFalse(fixedLength.some(CollectValuesAndResize));
+    assertEquals([0, 2, 4, 6], values);
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const fixedLengthWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT, 2);
+    values = [];
+    resizeAfter = 1;
+    resizeTo = 5 * ctor.BYTES_PER_ELEMENT;
+    assertFalse(fixedLengthWithOffset.some(CollectValuesAndResize));
+    assertEquals([4, 6], values);
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const lengthTracking = new ctor(rab, 0);
+    values = [];
+    resizeAfter = 2;
+    resizeTo = 5 * ctor.BYTES_PER_ELEMENT;
+    assertFalse(lengthTracking.some(CollectValuesAndResize));
+    assertEquals([0, 2, 4, 6], values);
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const lengthTrackingWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT);
+    values = [];
+    rab = rab;
+    resizeAfter = 1;
+    resizeTo = 5 * ctor.BYTES_PER_ELEMENT;
+    assertFalse(lengthTrackingWithOffset.some(CollectValuesAndResize));
+    assertEquals([4, 6], values);
+  }
+})();
+
+(function FindFindIndexFindLastFindLastIndex() {
+  for (let ctor of ctors) {
+    const rab = CreateResizableArrayBuffer(4 * ctor.BYTES_PER_ELEMENT,
+                                           8 * ctor.BYTES_PER_ELEMENT);
+    const fixedLength = new ctor(rab, 0, 4);
+    const fixedLengthWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT, 2);
+    const lengthTracking = new ctor(rab, 0);
+    const lengthTrackingWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT);
+
+    // Write some data into the array.
+    const taWrite = new ctor(rab);
+    for (let i = 0; i < 4; ++i) {
+      WriteToTypedArray(taWrite, i, 2 * i);
+    }
+
+    // Orig. array: [0, 2, 4, 6]
+    //              [0, 2, 4, 6] << fixedLength
+    //                    [4, 6] << fixedLengthWithOffset
+    //              [0, 2, 4, 6, ...] << lengthTracking
+    //                    [4, 6, ...] << lengthTrackingWithOffset
+
+    function isTwoOrFour(n) {
+      return n == 2 || n == 4;
+    }
+
+    assertEquals(2, Number(fixedLength.find(isTwoOrFour)));
+    assertEquals(4, Number(fixedLengthWithOffset.find(isTwoOrFour)));
+    assertEquals(2, Number(lengthTracking.find(isTwoOrFour)));
+    assertEquals(4, Number(lengthTrackingWithOffset.find(isTwoOrFour)));
+
+    assertEquals(1, fixedLength.findIndex(isTwoOrFour));
+    assertEquals(0, fixedLengthWithOffset.findIndex(isTwoOrFour));
+    assertEquals(1, lengthTracking.findIndex(isTwoOrFour));
+    assertEquals(0, lengthTrackingWithOffset.findIndex(isTwoOrFour));
+
+    assertEquals(4, Number(fixedLength.findLast(isTwoOrFour)));
+    assertEquals(4, Number(fixedLengthWithOffset.findLast(isTwoOrFour)));
+    assertEquals(4, Number(lengthTracking.findLast(isTwoOrFour)));
+    assertEquals(4, Number(lengthTrackingWithOffset.findLast(isTwoOrFour)));
+
+    assertEquals(2, fixedLength.findLastIndex(isTwoOrFour));
+    assertEquals(0, fixedLengthWithOffset.findLastIndex(isTwoOrFour));
+    assertEquals(2, lengthTracking.findLastIndex(isTwoOrFour));
+    assertEquals(0, lengthTrackingWithOffset.findLastIndex(isTwoOrFour));
+
+    // Shrink so that fixed length TAs go out of bounds.
+    rab.resize(3 * ctor.BYTES_PER_ELEMENT);
+
+    // Orig. array: [0, 2, 4]
+    //              [0, 2, 4, ...] << lengthTracking
+    //                    [4, ...] << lengthTrackingWithOffset
+
+    assertThrows(() => { fixedLength.find(isTwoOrFour); });
+    assertThrows(() => { fixedLength.findIndex(isTwoOrFour); });
+    assertThrows(() => { fixedLength.findLast(isTwoOrFour); });
+    assertThrows(() => { fixedLength.findLastIndex(isTwoOrFour); });
+
+    assertThrows(() => { fixedLengthWithOffset.find(isTwoOrFour); });
+    assertThrows(() => { fixedLengthWithOffset.findIndex(isTwoOrFour); });
+    assertThrows(() => { fixedLengthWithOffset.findLast(isTwoOrFour); });
+    assertThrows(() => { fixedLengthWithOffset.findLastIndex(isTwoOrFour); });
+
+    assertEquals(2, Number(lengthTracking.find(isTwoOrFour)));
+    assertEquals(4, Number(lengthTrackingWithOffset.find(isTwoOrFour)));
+
+    assertEquals(1, lengthTracking.findIndex(isTwoOrFour));
+    assertEquals(0, lengthTrackingWithOffset.findIndex(isTwoOrFour));
+
+    assertEquals(4, Number(lengthTracking.findLast(isTwoOrFour)));
+    assertEquals(4, Number(lengthTrackingWithOffset.findLast(isTwoOrFour)));
+
+    assertEquals(2, lengthTracking.findLastIndex(isTwoOrFour));
+    assertEquals(0, lengthTrackingWithOffset.findLastIndex(isTwoOrFour));
+
+    // Shrink so that the TAs with offset go out of bounds.
+    rab.resize(1 * ctor.BYTES_PER_ELEMENT);
+
+    assertThrows(() => { fixedLength.find(isTwoOrFour); });
+    assertThrows(() => { fixedLength.findIndex(isTwoOrFour); });
+    assertThrows(() => { fixedLength.findLast(isTwoOrFour); });
+    assertThrows(() => { fixedLength.findLastIndex(isTwoOrFour); });
+
+    assertThrows(() => { fixedLengthWithOffset.find(isTwoOrFour); });
+    assertThrows(() => { fixedLengthWithOffset.findIndex(isTwoOrFour); });
+    assertThrows(() => { fixedLengthWithOffset.findLast(isTwoOrFour); });
+    assertThrows(() => { fixedLengthWithOffset.findLastIndex(isTwoOrFour); });
+
+    assertThrows(() => { lengthTrackingWithOffset.find(isTwoOrFour); });
+    assertThrows(() => { lengthTrackingWithOffset.findIndex(isTwoOrFour); });
+    assertThrows(() => { lengthTrackingWithOffset.findLast(isTwoOrFour); });
+    assertThrows(() => { lengthTrackingWithOffset.findLastIndex(isTwoOrFour); });
+
+    assertEquals(undefined, lengthTracking.find(isTwoOrFour));
+    assertEquals(-1, lengthTracking.findIndex(isTwoOrFour));
+    assertEquals(undefined, lengthTracking.findLast(isTwoOrFour));
+    assertEquals(-1, lengthTracking.findLastIndex(isTwoOrFour));
+
+    // Shrink to zero.
+    rab.resize(0);
+
+    assertThrows(() => { fixedLength.find(isTwoOrFour); });
+    assertThrows(() => { fixedLength.findIndex(isTwoOrFour); });
+    assertThrows(() => { fixedLength.findLast(isTwoOrFour); });
+    assertThrows(() => { fixedLength.findLastIndex(isTwoOrFour); });
+
+    assertThrows(() => { fixedLengthWithOffset.find(isTwoOrFour); });
+    assertThrows(() => { fixedLengthWithOffset.findIndex(isTwoOrFour); });
+    assertThrows(() => { fixedLengthWithOffset.findLast(isTwoOrFour); });
+    assertThrows(() => { fixedLengthWithOffset.findLastIndex(isTwoOrFour); });
+
+    assertThrows(() => { lengthTrackingWithOffset.find(isTwoOrFour); });
+    assertThrows(() => { lengthTrackingWithOffset.findIndex(isTwoOrFour); });
+    assertThrows(() => { lengthTrackingWithOffset.findLast(isTwoOrFour); });
+    assertThrows(() => { lengthTrackingWithOffset.findLastIndex(isTwoOrFour); });
+
+    assertEquals(undefined, lengthTracking.find(isTwoOrFour));
+    assertEquals(-1, lengthTracking.findIndex(isTwoOrFour));
+    assertEquals(undefined, lengthTracking.findLast(isTwoOrFour));
+    assertEquals(-1, lengthTracking.findLastIndex(isTwoOrFour));
+
+    // Grow so that all TAs are back in-bounds.
+    rab.resize(6 * ctor.BYTES_PER_ELEMENT);
+    for (let i = 0; i < 4; ++i) {
+      WriteToTypedArray(taWrite, i, 0);
+    }
+    WriteToTypedArray(taWrite, 4, 2);
+    WriteToTypedArray(taWrite, 5, 4);
+
+    // Orig. array: [0, 0, 0, 0, 2, 4]
+    //              [0, 0, 0, 0] << fixedLength
+    //                    [0, 0] << fixedLengthWithOffset
+    //              [0, 0, 0, 0, 2, 4, ...] << lengthTracking
+    //                    [0, 0, 2, 4, ...] << lengthTrackingWithOffset
+
+    assertEquals(undefined, fixedLength.find(isTwoOrFour));
+    assertEquals(undefined, fixedLengthWithOffset.find(isTwoOrFour));
+    assertEquals(2, Number(lengthTracking.find(isTwoOrFour)));
+    assertEquals(2, Number(lengthTrackingWithOffset.find(isTwoOrFour)));
+
+    assertEquals(-1, fixedLength.findIndex(isTwoOrFour));
+    assertEquals(-1, fixedLengthWithOffset.findIndex(isTwoOrFour));
+    assertEquals(4, lengthTracking.findIndex(isTwoOrFour));
+    assertEquals(2, lengthTrackingWithOffset.findIndex(isTwoOrFour));
+
+    assertEquals(undefined, fixedLength.findLast(isTwoOrFour));
+    assertEquals(undefined, fixedLengthWithOffset.findLast(isTwoOrFour));
+    assertEquals(4, Number(lengthTracking.findLast(isTwoOrFour)));
+    assertEquals(4, Number(lengthTrackingWithOffset.findLast(isTwoOrFour)));
+
+    assertEquals(-1, fixedLength.findLastIndex(isTwoOrFour));
+    assertEquals(-1, fixedLengthWithOffset.findLastIndex(isTwoOrFour));
+    assertEquals(5, lengthTracking.findLastIndex(isTwoOrFour));
+    assertEquals(3, lengthTrackingWithOffset.findLastIndex(isTwoOrFour));
+  }
+})();
+
+(function FindShrinkMidIteration() {
+  // Orig. array: [0, 2, 4, 6]
+  //              [0, 2, 4, 6] << fixedLength
+  //                    [4, 6] << fixedLengthWithOffset
+  //              [0, 2, 4, 6, ...] << lengthTracking
+  //                    [4, 6, ...] << lengthTrackingWithOffset
+  function CreateRabForTest(ctor) {
+    const rab = CreateResizableArrayBuffer(4 * ctor.BYTES_PER_ELEMENT,
+                                           8 * ctor.BYTES_PER_ELEMENT);
+    // Write some data into the array.
+    const taWrite = new ctor(rab);
+    for (let i = 0; i < 4; ++i) {
+      WriteToTypedArray(taWrite, i, 2 * i);
+    }
+    return rab;
+  }
+
+  let values;
+  let rab;
+  let resizeAfter;
+  let resizeTo;
+  function CollectValuesAndResize(n) {
+    if (typeof n == 'bigint') {
+      values.push(Number(n));
     } else {
+      values.push(n);
+    }
+    if (values.length == resizeAfter) {
+      rab.resize(resizeTo);
+    }
+    return false;
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const fixedLength = new ctor(rab, 0, 4);
+    values = [];
+    resizeAfter = 2;
+    resizeTo = 3 * ctor.BYTES_PER_ELEMENT;
+    assertEquals(undefined, fixedLength.find(CollectValuesAndResize));
+    assertEquals([0, 2, undefined, undefined], values);
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const fixedLengthWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT, 2);
+    values = [];
+    resizeAfter = 1;
+    resizeTo = 3 * ctor.BYTES_PER_ELEMENT;
+    assertEquals(undefined, fixedLengthWithOffset.find(CollectValuesAndResize));
+    assertEquals([4, undefined], values);
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const lengthTracking = new ctor(rab, 0);
+    values = [];
+    resizeAfter = 2;
+    resizeTo = 3 * ctor.BYTES_PER_ELEMENT;
+    assertEquals(undefined, lengthTracking.find(CollectValuesAndResize));
+    assertEquals([0, 2, 4, undefined], values);
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const lengthTrackingWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT);
+    values = [];
+    resizeAfter = 1;
+    resizeTo = 3 * ctor.BYTES_PER_ELEMENT;
+    assertEquals(undefined, lengthTrackingWithOffset.find(CollectValuesAndResize));
+    assertEquals([4, undefined], values);
+  }
+})();
+
+(function FindGrowMidIteration() {
+  // Orig. array: [0, 2, 4, 6]
+  //              [0, 2, 4, 6] << fixedLength
+  //                    [4, 6] << fixedLengthWithOffset
+  //              [0, 2, 4, 6, ...] << lengthTracking
+  //                    [4, 6, ...] << lengthTrackingWithOffset
+  function CreateRabForTest(ctor) {
+    const rab = CreateResizableArrayBuffer(4 * ctor.BYTES_PER_ELEMENT,
+                                           8 * ctor.BYTES_PER_ELEMENT);
+    // Write some data into the array.
+    const taWrite = new ctor(rab);
+    for (let i = 0; i < 4; ++i) {
+      WriteToTypedArray(taWrite, i, 2 * i);
+    }
+    return rab;
+  }
+
+  let values;
+  let rab;
+  let resizeAfter;
+  let resizeTo;
+  function CollectValuesAndResize(n) {
+    if (typeof n == 'bigint') {
       values.push(Number(n));
+    } else {
+      values.push(n);
     }
     if (values.length == resizeAfter) {
       rab.resize(resizeTo);
@@ -2383,7 +2688,7 @@ function TestIterationAndResize(ta, expected, rab, resize_after,
     values = [];
     resizeAfter = 2;
     resizeTo = 5 * ctor.BYTES_PER_ELEMENT;
-    assertFalse(fixedLength.some(myFunc));
+    assertEquals(undefined, fixedLength.find(CollectValuesAndResize));
     assertEquals([0, 2, 4, 6], values);
   }
 
@@ -2393,7 +2698,7 @@ function TestIterationAndResize(ta, expected, rab, resize_after,
     values = [];
     resizeAfter = 1;
     resizeTo = 5 * ctor.BYTES_PER_ELEMENT;
-    assertFalse(fixedLengthWithOffset.some(myFunc));
+    assertEquals(undefined, fixedLengthWithOffset.find(CollectValuesAndResize));
     assertEquals([4, 6], values);
   }
 
@@ -2403,7 +2708,7 @@ function TestIterationAndResize(ta, expected, rab, resize_after,
     values = [];
     resizeAfter = 2;
     resizeTo = 5 * ctor.BYTES_PER_ELEMENT;
-    assertFalse(lengthTracking.some(myFunc));
+    assertEquals(undefined, lengthTracking.find(CollectValuesAndResize));
     assertEquals([0, 2, 4, 6], values);
   }
 
@@ -2411,10 +2716,1108 @@ function TestIterationAndResize(ta, expected, rab, resize_after,
     rab = CreateRabForTest(ctor);
     const lengthTrackingWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT);
     values = [];
-    rab = rab;
     resizeAfter = 1;
     resizeTo = 5 * ctor.BYTES_PER_ELEMENT;
-    assertFalse(lengthTrackingWithOffset.some(myFunc));
+    assertEquals(undefined, lengthTrackingWithOffset.find(CollectValuesAndResize));
     assertEquals([4, 6], values);
   }
 })();
+
+(function FindIndexShrinkMidIteration() {
+  // Orig. array: [0, 2, 4, 6]
+  //              [0, 2, 4, 6] << fixedLength
+  //                    [4, 6] << fixedLengthWithOffset
+  //              [0, 2, 4, 6, ...] << lengthTracking
+  //                    [4, 6, ...] << lengthTrackingWithOffset
+  function CreateRabForTest(ctor) {
+    const rab = CreateResizableArrayBuffer(4 * ctor.BYTES_PER_ELEMENT,
+                                           8 * ctor.BYTES_PER_ELEMENT);
+    // Write some data into the array.
+    const taWrite = new ctor(rab);
+    for (let i = 0; i < 4; ++i) {
+      WriteToTypedArray(taWrite, i, 2 * i);
+    }
+    return rab;
+  }
+
+  let values;
+  let rab;
+  let resizeAfter;
+  let resizeTo;
+  function CollectValuesAndResize(n) {
+    if (typeof n == 'bigint') {
+      values.push(Number(n));
+    } else {
+      values.push(n);
+    }
+    if (values.length == resizeAfter) {
+      rab.resize(resizeTo);
+    }
+    return false;
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const fixedLength = new ctor(rab, 0, 4);
+    values = [];
+    resizeAfter = 2;
+    resizeTo = 3 * ctor.BYTES_PER_ELEMENT;
+    assertEquals(-1, fixedLength.findIndex(CollectValuesAndResize));
+    assertEquals([0, 2, undefined, undefined], values);
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const fixedLengthWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT, 2);
+    values = [];
+    resizeAfter = 1;
+    resizeTo = 3 * ctor.BYTES_PER_ELEMENT;
+    assertEquals(-1, fixedLengthWithOffset.findIndex(CollectValuesAndResize));
+    assertEquals([4, undefined], values);
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const lengthTracking = new ctor(rab, 0);
+    values = [];
+    resizeAfter = 2;
+    resizeTo = 3 * ctor.BYTES_PER_ELEMENT;
+    assertEquals(-1, lengthTracking.findIndex(CollectValuesAndResize));
+    assertEquals([0, 2, 4, undefined], values);
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const lengthTrackingWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT);
+    values = [];
+    resizeAfter = 1;
+    resizeTo = 3 * ctor.BYTES_PER_ELEMENT;
+    assertEquals(-1, lengthTrackingWithOffset.findIndex(CollectValuesAndResize));
+    assertEquals([4, undefined], values);
+  }
+})();
+
+(function FindIndexGrowMidIteration() {
+  // Orig. array: [0, 2, 4, 6]
+  //              [0, 2, 4, 6] << fixedLength
+  //                    [4, 6] << fixedLengthWithOffset
+  //              [0, 2, 4, 6, ...] << lengthTracking
+  //                    [4, 6, ...] << lengthTrackingWithOffset
+  function CreateRabForTest(ctor) {
+    const rab = CreateResizableArrayBuffer(4 * ctor.BYTES_PER_ELEMENT,
+                                           8 * ctor.BYTES_PER_ELEMENT);
+    // Write some data into the array.
+    const taWrite = new ctor(rab);
+    for (let i = 0; i < 4; ++i) {
+      WriteToTypedArray(taWrite, i, 2 * i);
+    }
+    return rab;
+  }
+
+  let values;
+  let rab;
+  let resizeAfter;
+  let resizeTo;
+  function CollectValuesAndResize(n) {
+    if (typeof n == 'bigint') {
+      values.push(Number(n));
+    } else {
+      values.push(n);
+    }
+    if (values.length == resizeAfter) {
+      rab.resize(resizeTo);
+    }
+    return false;
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const fixedLength = new ctor(rab, 0, 4);
+    values = [];
+    resizeAfter = 2;
+    resizeTo = 5 * ctor.BYTES_PER_ELEMENT;
+    assertEquals(-1, fixedLength.findIndex(CollectValuesAndResize));
+    assertEquals([0, 2, 4, 6], values);
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const fixedLengthWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT, 2);
+    values = [];
+    resizeAfter = 1;
+    resizeTo = 5 * ctor.BYTES_PER_ELEMENT;
+    assertEquals(-1, fixedLengthWithOffset.findIndex(CollectValuesAndResize));
+    assertEquals([4, 6], values);
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const lengthTracking = new ctor(rab, 0);
+    values = [];
+    resizeAfter = 2;
+    resizeTo = 5 * ctor.BYTES_PER_ELEMENT;
+    assertEquals(-1, lengthTracking.findIndex(CollectValuesAndResize));
+    assertEquals([0, 2, 4, 6], values);
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const lengthTrackingWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT);
+    values = [];
+    resizeAfter = 1;
+    resizeTo = 5 * ctor.BYTES_PER_ELEMENT;
+    assertEquals(-1, lengthTrackingWithOffset.findIndex(CollectValuesAndResize));
+    assertEquals([4, 6], values);
+  }
+})();
+
+(function FindLastShrinkMidIteration() {
+  // Orig. array: [0, 2, 4, 6]
+  //              [0, 2, 4, 6] << fixedLength
+  //                    [4, 6] << fixedLengthWithOffset
+  //              [0, 2, 4, 6, ...] << lengthTracking
+  //                    [4, 6, ...] << lengthTrackingWithOffset
+  function CreateRabForTest(ctor) {
+    const rab = CreateResizableArrayBuffer(4 * ctor.BYTES_PER_ELEMENT,
+                                           8 * ctor.BYTES_PER_ELEMENT);
+    // Write some data into the array.
+    const taWrite = new ctor(rab);
+    for (let i = 0; i < 4; ++i) {
+      WriteToTypedArray(taWrite, i, 2 * i);
+    }
+    return rab;
+  }
+
+  let values;
+  let rab;
+  let resizeAfter;
+  let resizeTo;
+  function CollectValuesAndResize(n) {
+    if (typeof n == 'bigint') {
+      values.push(Number(n));
+    } else {
+      values.push(n);
+    }
+    if (values.length == resizeAfter) {
+      rab.resize(resizeTo);
+    }
+    return false;
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const fixedLength = new ctor(rab, 0, 4);
+    values = [];
+    resizeAfter = 2;
+    resizeTo = 3 * ctor.BYTES_PER_ELEMENT;
+    assertEquals(undefined, fixedLength.findLast(CollectValuesAndResize));
+    assertEquals([6, 4, undefined, undefined], values);
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const fixedLengthWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT, 2);
+    values = [];
+    resizeAfter = 1;
+    resizeTo = 3 * ctor.BYTES_PER_ELEMENT;
+    assertEquals(undefined, fixedLengthWithOffset.findLast(CollectValuesAndResize));
+    assertEquals([6, undefined], values);
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const lengthTracking = new ctor(rab, 0);
+    values = [];
+    resizeAfter = 2;
+    resizeTo = 3 * ctor.BYTES_PER_ELEMENT;
+    assertEquals(undefined, lengthTracking.findLast(CollectValuesAndResize));
+    assertEquals([6, 4, 2, 0], values);
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const lengthTrackingWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT);
+    values = [];
+    resizeAfter = 1;
+    resizeTo = 3 * ctor.BYTES_PER_ELEMENT;
+    assertEquals(undefined, lengthTrackingWithOffset.findLast(CollectValuesAndResize));
+    assertEquals([6, 4], values);
+  }
+})();
+
+(function FindLastGrowMidIteration() {
+  // Orig. array: [0, 2, 4, 6]
+  //              [0, 2, 4, 6] << fixedLength
+  //                    [4, 6] << fixedLengthWithOffset
+  //              [0, 2, 4, 6, ...] << lengthTracking
+  //                    [4, 6, ...] << lengthTrackingWithOffset
+  function CreateRabForTest(ctor) {
+    const rab = CreateResizableArrayBuffer(4 * ctor.BYTES_PER_ELEMENT,
+                                           8 * ctor.BYTES_PER_ELEMENT);
+    // Write some data into the array.
+    const taWrite = new ctor(rab);
+    for (let i = 0; i < 4; ++i) {
+      WriteToTypedArray(taWrite, i, 2 * i);
+    }
+    return rab;
+  }
+
+  let values;
+  let rab;
+  let resizeAfter;
+  let resizeTo;
+  function CollectValuesAndResize(n) {
+    if (typeof n == 'bigint') {
+      values.push(Number(n));
+    } else {
+      values.push(n);
+    }
+    if (values.length == resizeAfter) {
+      rab.resize(resizeTo);
+    }
+    return false;
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const fixedLength = new ctor(rab, 0, 4);
+    values = [];
+    resizeAfter = 2;
+    resizeTo = 5 * ctor.BYTES_PER_ELEMENT;
+    assertEquals(undefined, fixedLength.findLast(CollectValuesAndResize));
+    assertEquals([6, 4, 2, 0], values);
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const fixedLengthWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT, 2);
+    values = [];
+    resizeAfter = 1;
+    resizeTo = 5 * ctor.BYTES_PER_ELEMENT;
+    assertEquals(undefined, fixedLengthWithOffset.findLast(CollectValuesAndResize));
+    assertEquals([6, 4], values);
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const lengthTracking = new ctor(rab, 0);
+    values = [];
+    resizeAfter = 2;
+    resizeTo = 5 * ctor.BYTES_PER_ELEMENT;
+    assertEquals(undefined, lengthTracking.findLast(CollectValuesAndResize));
+    assertEquals([6, 4, 2, 0], values);
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const lengthTrackingWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT);
+    values = [];
+    resizeAfter = 1;
+    resizeTo = 5 * ctor.BYTES_PER_ELEMENT;
+    assertEquals(undefined, lengthTrackingWithOffset.findLast(CollectValuesAndResize));
+    assertEquals([6, 4], values);
+  }
+})();
+
+(function FindLastIndexShrinkMidIteration() {
+  // Orig. array: [0, 2, 4, 6]
+  //              [0, 2, 4, 6] << fixedLength
+  //                    [4, 6] << fixedLengthWithOffset
+  //              [0, 2, 4, 6, ...] << lengthTracking
+  //                    [4, 6, ...] << lengthTrackingWithOffset
+  function CreateRabForTest(ctor) {
+    const rab = CreateResizableArrayBuffer(4 * ctor.BYTES_PER_ELEMENT,
+                                           8 * ctor.BYTES_PER_ELEMENT);
+    // Write some data into the array.
+    const taWrite = new ctor(rab);
+    for (let i = 0; i < 4; ++i) {
+      WriteToTypedArray(taWrite, i, 2 * i);
+    }
+    return rab;
+  }
+
+  let values;
+  let rab;
+  let resizeAfter;
+  let resizeTo;
+  function CollectValuesAndResize(n) {
+    if (typeof n == 'bigint') {
+      values.push(Number(n));
+    } else {
+      values.push(n);
+    }
+    if (values.length == resizeAfter) {
+      rab.resize(resizeTo);
+    }
+    return false;
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const fixedLength = new ctor(rab, 0, 4);
+    values = [];
+    resizeAfter = 2;
+    resizeTo = 3 * ctor.BYTES_PER_ELEMENT;
+    assertEquals(-1, fixedLength.findLastIndex(CollectValuesAndResize));
+    assertEquals([6, 4, undefined, undefined], values);
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const fixedLengthWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT, 2);
+    values = [];
+    resizeAfter = 1;
+    resizeTo = 3 * ctor.BYTES_PER_ELEMENT;
+    assertEquals(-1, fixedLengthWithOffset.findLastIndex(CollectValuesAndResize));
+    assertEquals([6, undefined], values);
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const lengthTracking = new ctor(rab, 0);
+    values = [];
+    resizeAfter = 2;
+    resizeTo = 3 * ctor.BYTES_PER_ELEMENT;
+    assertEquals(-1, lengthTracking.findLastIndex(CollectValuesAndResize));
+    assertEquals([6, 4, 2, 0], values);
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const lengthTracking = new ctor(rab, 0);
+    values = [];
+    resizeAfter = 1;
+    resizeTo = 2 * ctor.BYTES_PER_ELEMENT;
+    assertEquals(-1, lengthTracking.findLastIndex(CollectValuesAndResize));
+    assertEquals([6, undefined, 2, 0], values);
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const lengthTrackingWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT);
+    values = [];
+    resizeAfter = 1;
+    resizeTo = 3 * ctor.BYTES_PER_ELEMENT;
+    assertEquals(-1, lengthTrackingWithOffset.findLastIndex(CollectValuesAndResize));
+    assertEquals([6, 4], values);
+  }
+})();
+
+(function FindLastIndexGrowMidIteration() {
+  // Orig. array: [0, 2, 4, 6]
+  //              [0, 2, 4, 6] << fixedLength
+  //                    [4, 6] << fixedLengthWithOffset
+  //              [0, 2, 4, 6, ...] << lengthTracking
+  //                    [4, 6, ...] << lengthTrackingWithOffset
+  function CreateRabForTest(ctor) {
+    const rab = CreateResizableArrayBuffer(4 * ctor.BYTES_PER_ELEMENT,
+                                           8 * ctor.BYTES_PER_ELEMENT);
+    // Write some data into the array.
+    const taWrite = new ctor(rab);
+    for (let i = 0; i < 4; ++i) {
+      WriteToTypedArray(taWrite, i, 2 * i);
+    }
+    return rab;
+  }
+
+  let values;
+  let rab;
+  let resizeAfter;
+  let resizeTo;
+  function CollectValuesAndResize(n) {
+    if (typeof n == 'bigint') {
+      values.push(Number(n));
+    } else {
+      values.push(n);
+    }
+    if (values.length == resizeAfter) {
+      rab.resize(resizeTo);
+    }
+    return false;
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const fixedLength = new ctor(rab, 0, 4);
+    values = [];
+    resizeAfter = 2;
+    resizeTo = 5 * ctor.BYTES_PER_ELEMENT;
+    assertEquals(-1, fixedLength.findLastIndex(CollectValuesAndResize));
+    assertEquals([6, 4, 2, 0], values);
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const fixedLengthWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT, 2);
+    values = [];
+    resizeAfter = 1;
+    resizeTo = 5 * ctor.BYTES_PER_ELEMENT;
+    assertEquals(-1, fixedLengthWithOffset.findLastIndex(CollectValuesAndResize));
+    assertEquals([6, 4], values);
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const lengthTracking = new ctor(rab, 0);
+    values = [];
+    resizeAfter = 2;
+    resizeTo = 5 * ctor.BYTES_PER_ELEMENT;
+    assertEquals(-1, lengthTracking.findLastIndex(CollectValuesAndResize));
+    assertEquals([6, 4, 2, 0], values);
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const lengthTrackingWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT);
+    values = [];
+    resizeAfter = 1;
+    resizeTo = 5 * ctor.BYTES_PER_ELEMENT;
+    assertEquals(-1, lengthTrackingWithOffset.findLastIndex(CollectValuesAndResize));
+    assertEquals([6, 4], values);
+  }
+})();
+
+(function Filter() {
+  for (let ctor of ctors) {
+    const rab = CreateResizableArrayBuffer(4 * ctor.BYTES_PER_ELEMENT,
+                                           8 * ctor.BYTES_PER_ELEMENT);
+    const fixedLength = new ctor(rab, 0, 4);
+    const fixedLengthWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT, 2);
+    const lengthTracking = new ctor(rab, 0);
+    const lengthTrackingWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT);
+
+    // Write some data into the array.
+    const taWrite = new ctor(rab);
+    for (let i = 0; i < 4; ++i) {
+      WriteToTypedArray(taWrite, i, i);
+    }
+
+    // Orig. array: [0, 1, 2, 3]
+    //              [0, 1, 2, 3] << fixedLength
+    //                    [2, 3] << fixedLengthWithOffset
+    //              [0, 1, 2, 3, ...] << lengthTracking
+    //                    [2, 3, ...] << lengthTrackingWithOffset
+
+    function isEven(n) {
+      return n != undefined && Number(n) % 2 == 0;
+    }
+
+    assertEquals([0, 2], ToNumbers(fixedLength.filter(isEven)));
+    assertEquals([2], ToNumbers(fixedLengthWithOffset.filter(isEven)));
+    assertEquals([0, 2], ToNumbers(lengthTracking.filter(isEven)));
+    assertEquals([2], ToNumbers(lengthTrackingWithOffset.filter(isEven)));
+
+    // Shrink so that fixed length TAs go out of bounds.
+    rab.resize(3 * ctor.BYTES_PER_ELEMENT);
+
+    // Orig. array: [0, 1, 2]
+    //              [0, 1, 2, ...] << lengthTracking
+    //                    [2, ...] << lengthTrackingWithOffset
+
+    assertThrows(() => { fixedLength.filter(isEven); });
+    assertThrows(() => { fixedLengthWithOffset.filter(isEven); });
+
+    assertEquals([0, 2], ToNumbers(lengthTracking.filter(isEven)));
+    assertEquals([2], ToNumbers(lengthTrackingWithOffset.filter(isEven)));
+
+    // Shrink so that the TAs with offset go out of bounds.
+    rab.resize(1 * ctor.BYTES_PER_ELEMENT);
+
+    assertThrows(() => { fixedLength.filter(isEven); });
+    assertThrows(() => { fixedLengthWithOffset.filter(isEven); });
+    assertThrows(() => { lengthTrackingWithOffset.filter(isEven); });
+
+    assertEquals([0], ToNumbers(lengthTracking.filter(isEven)));
+
+    // Shrink to zero.
+    rab.resize(0);
+
+    assertThrows(() => { fixedLength.filter(isEven); });
+    assertThrows(() => { fixedLengthWithOffset.filter(isEven); });
+    assertThrows(() => { lengthTrackingWithOffset.filter(isEven); });
+
+    assertEquals([], ToNumbers(lengthTracking.filter(isEven)));
+
+    // Grow so that all TAs are back in-bounds.
+    rab.resize(6 * ctor.BYTES_PER_ELEMENT);
+    for (let i = 0; i < 6; ++i) {
+      WriteToTypedArray(taWrite, i, i);
+    }
+
+    // Orig. array: [0, 1, 2, 3, 4, 5]
+    //              [0, 1, 2, 3] << fixedLength
+    //                    [2, 3] << fixedLengthWithOffset
+    //              [0, 1, 2, 3, 4, 5, ...] << lengthTracking
+    //                    [2, 3, 4, 5, ...] << lengthTrackingWithOffset
+
+    assertEquals([0, 2], ToNumbers(fixedLength.filter(isEven)));
+    assertEquals([2], ToNumbers(fixedLengthWithOffset.filter(isEven)));
+    assertEquals([0, 2, 4], ToNumbers(lengthTracking.filter(isEven)));
+    assertEquals([2, 4], ToNumbers(lengthTrackingWithOffset.filter(isEven)));
+  }
+})();
+
+(function FilterShrinkMidIteration() {
+  // Orig. array: [0, 2, 4, 6]
+  //              [0, 2, 4, 6] << fixedLength
+  //                    [4, 6] << fixedLengthWithOffset
+  //              [0, 2, 4, 6, ...] << lengthTracking
+  //                    [4, 6, ...] << lengthTrackingWithOffset
+  function CreateRabForTest(ctor) {
+    const rab = CreateResizableArrayBuffer(4 * ctor.BYTES_PER_ELEMENT,
+                                           8 * ctor.BYTES_PER_ELEMENT);
+    // Write some data into the array.
+    const taWrite = new ctor(rab);
+    for (let i = 0; i < 4; ++i) {
+      WriteToTypedArray(taWrite, i, 2 * i);
+    }
+    return rab;
+  }
+
+  let values;
+  let rab;
+  let resizeAfter;
+  let resizeTo;
+  function CollectValuesAndResize(n) {
+    if (typeof n == 'bigint') {
+      values.push(Number(n));
+    } else {
+      values.push(n);
+    }
+    if (values.length == resizeAfter) {
+      rab.resize(resizeTo);
+    }
+    return false;
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const fixedLength = new ctor(rab, 0, 4);
+    values = [];
+    resizeAfter = 2;
+    resizeTo = 3 * ctor.BYTES_PER_ELEMENT;
+    assertEquals([], ToNumbers(fixedLength.filter(CollectValuesAndResize)));
+    assertEquals([0, 2, undefined, undefined], values);
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const fixedLengthWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT, 2);
+    values = [];
+    resizeAfter = 1;
+    resizeTo = 3 * ctor.BYTES_PER_ELEMENT;
+    assertEquals([], ToNumbers(fixedLengthWithOffset.filter(CollectValuesAndResize)));
+    assertEquals([4, undefined], values);
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const lengthTracking = new ctor(rab, 0);
+    values = [];
+    resizeAfter = 2;
+    resizeTo = 3 * ctor.BYTES_PER_ELEMENT;
+    assertEquals([], ToNumbers(lengthTracking.filter(CollectValuesAndResize)));
+    assertEquals([0, 2, 4, undefined], values);
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const lengthTrackingWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT);
+    values = [];
+    resizeAfter = 1;
+    resizeTo = 3 * ctor.BYTES_PER_ELEMENT;
+    assertEquals([], ToNumbers(lengthTrackingWithOffset.filter(CollectValuesAndResize)));
+    assertEquals([4, undefined], values);
+  }
+})();
+
+(function FilterGrowMidIteration() {
+  // Orig. array: [0, 2, 4, 6]
+  //              [0, 2, 4, 6] << fixedLength
+  //                    [4, 6] << fixedLengthWithOffset
+  //              [0, 2, 4, 6, ...] << lengthTracking
+  //                    [4, 6, ...] << lengthTrackingWithOffset
+  function CreateRabForTest(ctor) {
+    const rab = CreateResizableArrayBuffer(4 * ctor.BYTES_PER_ELEMENT,
+                                           8 * ctor.BYTES_PER_ELEMENT);
+    // Write some data into the array.
+    const taWrite = new ctor(rab);
+    for (let i = 0; i < 4; ++i) {
+      WriteToTypedArray(taWrite, i, 2 * i);
+    }
+    return rab;
+  }
+
+  let values;
+  let rab;
+  let resizeAfter;
+  let resizeTo;
+  function CollectValuesAndResize(n) {
+    if (typeof n == 'bigint') {
+      values.push(Number(n));
+    } else {
+      values.push(n);
+    }
+    if (values.length == resizeAfter) {
+      rab.resize(resizeTo);
+    }
+    return false;
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const fixedLength = new ctor(rab, 0, 4);
+    values = [];
+    resizeAfter = 2;
+    resizeTo = 5 * ctor.BYTES_PER_ELEMENT;
+    assertEquals([], ToNumbers(fixedLength.filter(CollectValuesAndResize)));
+    assertEquals([0, 2, 4, 6], values);
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const fixedLengthWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT, 2);
+    values = [];
+    resizeAfter = 1;
+    resizeTo = 5 * ctor.BYTES_PER_ELEMENT;
+    assertEquals([], ToNumbers(fixedLengthWithOffset.filter(CollectValuesAndResize)));
+    assertEquals([4, 6], values);
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const lengthTracking = new ctor(rab, 0);
+    values = [];
+    resizeAfter = 2;
+    resizeTo = 5 * ctor.BYTES_PER_ELEMENT;
+    assertEquals([], ToNumbers(lengthTracking.filter(CollectValuesAndResize)));
+    assertEquals([0, 2, 4, 6], values);
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const lengthTrackingWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT);
+    values = [];
+    resizeAfter = 1;
+    resizeTo = 5 * ctor.BYTES_PER_ELEMENT;
+    assertEquals([], ToNumbers(lengthTrackingWithOffset.filter(CollectValuesAndResize)));
+    assertEquals([4, 6], values);
+  }
+})();
+
+(function ForEachReduceReduceRight() {
+  for (let ctor of ctors) {
+    const rab = CreateResizableArrayBuffer(4 * ctor.BYTES_PER_ELEMENT,
+                                           8 * ctor.BYTES_PER_ELEMENT);
+    const fixedLength = new ctor(rab, 0, 4);
+    const fixedLengthWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT, 2);
+    const lengthTracking = new ctor(rab, 0);
+    const lengthTrackingWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT);
+
+    // Write some data into the array.
+    const taWrite = new ctor(rab);
+    for (let i = 0; i < 4; ++i) {
+      WriteToTypedArray(taWrite, i, 2 * i);
+    }
+
+    // Orig. array: [0, 2, 4, 6]
+    //              [0, 2, 4, 6] << fixedLength
+    //                    [4, 6] << fixedLengthWithOffset
+    //              [0, 2, 4, 6, ...] << lengthTracking
+    //                    [4, 6, ...] << lengthTrackingWithOffset
+
+    function Helper(array) {
+      const forEachValues = [];
+      const reduceValues = [];
+      const reduceRightValues = [];
+
+      array.forEach((n) => { forEachValues.push(n);});
+
+      array.reduce((acc, n) => {
+        reduceValues.push(n);
+      }, "initial value");
+
+      array.reduceRight((acc, n) => {
+        reduceRightValues.push(n);
+      }, "initial value");
+
+      assertEquals(reduceValues, forEachValues);
+      reduceRightValues.reverse();
+      assertEquals(reduceValues, reduceRightValues);
+      return ToNumbers(forEachValues);
+    }
+
+    assertEquals([0, 2, 4, 6], Helper(fixedLength));
+    assertEquals([4, 6], Helper(fixedLengthWithOffset));
+    assertEquals([0, 2, 4, 6], Helper(lengthTracking));
+    assertEquals([4, 6], Helper(lengthTrackingWithOffset));
+
+    // Shrink so that fixed length TAs go out of bounds.
+    rab.resize(3 * ctor.BYTES_PER_ELEMENT);
+
+    // Orig. array: [0, 2, 4]
+    //              [0, 2, 4, ...] << lengthTracking
+    //                    [4, ...] << lengthTrackingWithOffset
+
+    assertThrows(() => { Helper(fixedLength); });
+    assertThrows(() => { Helper(fixedLengthWithOffset); });
+
+    assertEquals([0, 2, 4], Helper(lengthTracking));
+    assertEquals([4], Helper(lengthTrackingWithOffset));
+
+    // Shrink so that the TAs with offset go out of bounds.
+    rab.resize(1 * ctor.BYTES_PER_ELEMENT);
+
+    assertThrows(() => { Helper(fixedLength); });
+    assertThrows(() => { Helper(fixedLengthWithOffset); });
+    assertThrows(() => { Helper(lengthTrackingWithOffset); });
+
+    assertEquals([0], Helper(lengthTracking));
+
+    // Shrink to zero.
+    rab.resize(0);
+
+    assertThrows(() => { Helper(fixedLength); });
+    assertThrows(() => { Helper(fixedLengthWithOffset); });
+    assertThrows(() => { Helper(lengthTrackingWithOffset); });
+
+    assertEquals([], Helper(lengthTracking));
+
+    // Grow so that all TAs are back in-bounds.
+    rab.resize(6 * ctor.BYTES_PER_ELEMENT);
+    for (let i = 0; i < 6; ++i) {
+      WriteToTypedArray(taWrite, i, 2 * i);
+    }
+
+    // Orig. array: [0, 2, 4, 6, 8, 10]
+    //              [0, 2, 4, 6] << fixedLength
+    //                    [4, 6] << fixedLengthWithOffset
+    //              [0, 2, 4, 6, 8, 10, ...] << lengthTracking
+    //                    [4, 6, 8, 10, ...] << lengthTrackingWithOffset
+
+    assertEquals([0, 2, 4, 6], Helper(fixedLength));
+    assertEquals([4, 6], Helper(fixedLengthWithOffset));
+    assertEquals([0, 2, 4, 6, 8, 10], Helper(lengthTracking));
+    assertEquals([4, 6, 8, 10], Helper(lengthTrackingWithOffset));
+  }
+})();
+
+(function ForEachReduceReduceRightShrinkMidIteration() {
+  // Orig. array: [0, 2, 4, 6]
+  //              [0, 2, 4, 6] << fixedLength
+  //                    [4, 6] << fixedLengthWithOffset
+  //              [0, 2, 4, 6, ...] << lengthTracking
+  //                    [4, 6, ...] << lengthTrackingWithOffset
+  function CreateRabForTest(ctor) {
+    const rab = CreateResizableArrayBuffer(4 * ctor.BYTES_PER_ELEMENT,
+                                           8 * ctor.BYTES_PER_ELEMENT);
+    // Write some data into the array.
+    const taWrite = new ctor(rab);
+    for (let i = 0; i < 4; ++i) {
+      WriteToTypedArray(taWrite, i, 2 * i);
+    }
+    return rab;
+  }
+
+  let values;
+  let rab;
+  let resizeAfter;
+  let resizeTo;
+  function CollectValuesAndResize(n) {
+    if (typeof n == 'bigint') {
+      values.push(Number(n));
+    } else {
+      values.push(n);
+    }
+    if (values.length == resizeAfter) {
+      rab.resize(resizeTo);
+    }
+    return true;
+  }
+
+  function ForEachHelper(array) {
+    values = [];
+    array.forEach(CollectValuesAndResize);
+    return values;
+  }
+
+  function ReduceHelper(array) {
+    values = [];
+    array.reduce((acc, n) => { CollectValuesAndResize(n); }, "initial value");
+    return values;
+  }
+
+  function ReduceRightHelper(array) {
+    values = [];
+    array.reduceRight((acc, n) => { CollectValuesAndResize(n); },
+                      "initial value");
+    return values;
+  }
+
+  // Test for forEach.
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const fixedLength = new ctor(rab, 0, 4);
+    resizeAfter = 2;
+    resizeTo = 3 * ctor.BYTES_PER_ELEMENT;
+    assertEquals([0, 2, undefined, undefined], ForEachHelper(fixedLength));
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const fixedLengthWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT, 2);
+    resizeAfter = 1;
+    resizeTo = 3 * ctor.BYTES_PER_ELEMENT;
+    assertEquals([4, undefined], ForEachHelper(fixedLengthWithOffset));
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const lengthTracking = new ctor(rab, 0);
+    resizeAfter = 2;
+    resizeTo = 3 * ctor.BYTES_PER_ELEMENT;
+    assertEquals([0, 2, 4, undefined], ForEachHelper(lengthTracking));
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const lengthTrackingWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT);
+    resizeAfter = 1;
+    resizeTo = 3 * ctor.BYTES_PER_ELEMENT;
+    assertEquals([4, undefined], ForEachHelper(lengthTrackingWithOffset));
+  }
+
+  // Tests for reduce.
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const fixedLength = new ctor(rab, 0, 4);
+    resizeAfter = 2;
+    resizeTo = 3 * ctor.BYTES_PER_ELEMENT;
+    assertEquals([0, 2, undefined, undefined], ReduceHelper(fixedLength));
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const fixedLengthWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT, 2);
+    resizeAfter = 1;
+    resizeTo = 3 * ctor.BYTES_PER_ELEMENT;
+    assertEquals([4, undefined], ReduceHelper(fixedLengthWithOffset));
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const lengthTracking = new ctor(rab, 0);
+    resizeAfter = 2;
+    resizeTo = 3 * ctor.BYTES_PER_ELEMENT;
+    assertEquals([0, 2, 4, undefined], ReduceHelper(lengthTracking));
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const lengthTrackingWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT);
+    resizeAfter = 1;
+    resizeTo = 3 * ctor.BYTES_PER_ELEMENT;
+    assertEquals([4, undefined], ReduceHelper(lengthTrackingWithOffset));
+  }
+
+  // Tests for reduceRight.
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const fixedLength = new ctor(rab, 0, 4);
+    resizeAfter = 2;
+    resizeTo = 3 * ctor.BYTES_PER_ELEMENT;
+    assertEquals([6, 4, undefined, undefined], ReduceRightHelper(fixedLength));
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const fixedLengthWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT, 2);
+    resizeAfter = 1;
+    resizeTo = 3 * ctor.BYTES_PER_ELEMENT;
+    assertEquals([6, undefined], ReduceRightHelper(fixedLengthWithOffset));
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const lengthTracking = new ctor(rab, 0);
+    resizeAfter = 2;
+    resizeTo = 3 * ctor.BYTES_PER_ELEMENT;
+    // Unaffected by the shrinking, since we've already iterated past the point.
+    assertEquals([6, 4, 2, 0], ReduceRightHelper(lengthTracking));
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const lengthTracking = new ctor(rab, 0);
+    resizeAfter = 1;
+    resizeTo = 2 * ctor.BYTES_PER_ELEMENT;
+    assertEquals([6, undefined, 2, 0], ReduceRightHelper(lengthTracking));
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const lengthTrackingWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT);
+    resizeAfter = 1;
+    resizeTo = 3 * ctor.BYTES_PER_ELEMENT;
+    // Unaffected by the shrinking, since we've already iterated past the point.
+    assertEquals([6, 4], ReduceRightHelper(lengthTrackingWithOffset));
+  }
+})();
+
+(function ForEachReduceReduceRightGrowMidIteration() {
+  // Orig. array: [0, 2, 4, 6]
+  //              [0, 2, 4, 6] << fixedLength
+  //                    [4, 6] << fixedLengthWithOffset
+  //              [0, 2, 4, 6, ...] << lengthTracking
+  //                    [4, 6, ...] << lengthTrackingWithOffset
+  function CreateRabForTest(ctor) {
+    const rab = CreateResizableArrayBuffer(4 * ctor.BYTES_PER_ELEMENT,
+                                           8 * ctor.BYTES_PER_ELEMENT);
+    // Write some data into the array.
+    const taWrite = new ctor(rab);
+    for (let i = 0; i < 4; ++i) {
+      WriteToTypedArray(taWrite, i, 2 * i);
+    }
+    return rab;
+  }
+
+  let values;
+  let rab;
+  let resizeAfter;
+  let resizeTo;
+  function CollectValuesAndResize(n) {
+    if (typeof n == 'bigint') {
+      values.push(Number(n));
+    } else {
+      values.push(n);
+    }
+    if (values.length == resizeAfter) {
+      rab.resize(resizeTo);
+    }
+    return true;
+  }
+
+  function ForEachHelper(array) {
+    values = [];
+    array.forEach(CollectValuesAndResize);
+    return values;
+  }
+
+  function ReduceHelper(array) {
+    values = [];
+    array.reduce((acc, n) => { CollectValuesAndResize(n); }, "initial value");
+    return values;
+  }
+
+  function ReduceRightHelper(array) {
+    values = [];
+    array.reduceRight((acc, n) => { CollectValuesAndResize(n); },
+                      "initial value");
+    return values;
+  }
+
+  // Test for forEach.
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const fixedLength = new ctor(rab, 0, 4);
+    resizeAfter = 2;
+    resizeTo = 5 * ctor.BYTES_PER_ELEMENT;
+    assertEquals([0, 2, 4, 6], ForEachHelper(fixedLength));
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const fixedLengthWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT, 2);
+    resizeAfter = 1;
+    resizeTo = 5 * ctor.BYTES_PER_ELEMENT;
+    assertEquals([4, 6], ForEachHelper(fixedLengthWithOffset));
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const lengthTracking = new ctor(rab, 0);
+    resizeAfter = 2;
+    resizeTo = 5 * ctor.BYTES_PER_ELEMENT;
+    assertEquals([0, 2, 4, 6], ForEachHelper(lengthTracking));
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const lengthTrackingWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT);
+    resizeAfter = 1;
+    resizeTo = 5 * ctor.BYTES_PER_ELEMENT;
+    assertEquals([4, 6], ForEachHelper(lengthTrackingWithOffset));
+  }
+
+  // Test for reduce.
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const fixedLength = new ctor(rab, 0, 4);
+    resizeAfter = 2;
+    resizeTo = 5 * ctor.BYTES_PER_ELEMENT;
+    assertEquals([0, 2, 4, 6], ReduceHelper(fixedLength));
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const fixedLengthWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT, 2);
+    resizeAfter = 1;
+    resizeTo = 5 * ctor.BYTES_PER_ELEMENT;
+    assertEquals([4, 6], ReduceHelper(fixedLengthWithOffset));
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const lengthTracking = new ctor(rab, 0);
+    resizeAfter = 2;
+    resizeTo = 5 * ctor.BYTES_PER_ELEMENT;
+    assertEquals([0, 2, 4, 6], ReduceHelper(lengthTracking));
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const lengthTrackingWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT);
+    resizeAfter = 1;
+    resizeTo = 5 * ctor.BYTES_PER_ELEMENT;
+    assertEquals([4, 6], ReduceHelper(lengthTrackingWithOffset));
+  }
+
+  // Test for reduceRight.
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const fixedLength = new ctor(rab, 0, 4);
+    resizeAfter = 2;
+    resizeTo = 5 * ctor.BYTES_PER_ELEMENT;
+    assertEquals([6, 4, 2, 0], ReduceRightHelper(fixedLength));
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const fixedLengthWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT, 2);
+    resizeAfter = 1;
+    resizeTo = 5 * ctor.BYTES_PER_ELEMENT;
+    assertEquals([6, 4], ReduceRightHelper(fixedLengthWithOffset));
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const lengthTracking = new ctor(rab, 0);
+    resizeAfter = 2;
+    resizeTo = 5 * ctor.BYTES_PER_ELEMENT;
+    assertEquals([6, 4, 2, 0], ReduceRightHelper(lengthTracking));
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const lengthTrackingWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT);
+    resizeAfter = 1;
+    resizeTo = 5 * ctor.BYTES_PER_ELEMENT;
+    assertEquals([6, 4], ReduceRightHelper(lengthTrackingWithOffset));
+  }
+})();

test/test262/test262.status

@@ -422,18 +422,6 @@
   'built-ins/DataView/prototype/setUint16/resizable-buffer': [FAIL],
   'built-ins/DataView/prototype/setUint32/resizable-buffer': [FAIL],
   'built-ins/DataView/prototype/setUint8/resizable-buffer': [FAIL],
-  'built-ins/TypedArray/prototype/filter/BigInt/return-abrupt-from-this-out-of-bounds': [SKIP],
-  'built-ins/TypedArray/prototype/filter/return-abrupt-from-this-out-of-bounds': [SKIP],
-  'built-ins/TypedArray/prototype/find/BigInt/return-abrupt-from-this-out-of-bounds': [SKIP],
-  'built-ins/TypedArray/prototype/findIndex/BigInt/return-abrupt-from-this-out-of-bounds': [SKIP],
-  'built-ins/TypedArray/prototype/findIndex/return-abrupt-from-this-out-of-bounds': [SKIP],
-  'built-ins/TypedArray/prototype/findLast/BigInt/return-abrupt-from-this-out-of-bounds': [SKIP],
-  'built-ins/TypedArray/prototype/findLastIndex/BigInt/return-abrupt-from-this-out-of-bounds': [SKIP],
-  'built-ins/TypedArray/prototype/findLastIndex/return-abrupt-from-this-out-of-bounds': [SKIP],
-  'built-ins/TypedArray/prototype/findLast/return-abrupt-from-this-out-of-bounds': [SKIP],
-  'built-ins/TypedArray/prototype/find/return-abrupt-from-this-out-of-bounds': [SKIP],
-  'built-ins/TypedArray/prototype/forEach/BigInt/return-abrupt-from-this-out-of-bounds': [SKIP],
-  'built-ins/TypedArray/prototype/forEach/return-abrupt-from-this-out-of-bounds': [SKIP],
   'built-ins/TypedArray/prototype/includes/BigInt/return-abrupt-from-this-out-of-bounds': [SKIP],
   'built-ins/TypedArray/prototype/includes/return-abrupt-from-this-out-of-bounds': [SKIP],
   'built-ins/TypedArray/prototype/indexOf/BigInt/return-abrupt-from-this-out-of-bounds': [SKIP],
@@ -444,10 +432,6 @@
   'built-ins/TypedArray/prototype/lastIndexOf/return-abrupt-from-this-out-of-bounds': [SKIP],
   'built-ins/TypedArray/prototype/map/BigInt/return-abrupt-from-this-out-of-bounds': [SKIP],
   'built-ins/TypedArray/prototype/map/return-abrupt-from-this-out-of-bounds': [SKIP],
-  'built-ins/TypedArray/prototype/reduce/BigInt/return-abrupt-from-this-out-of-bounds': [SKIP],
-  'built-ins/TypedArray/prototype/reduce/return-abrupt-from-this-out-of-bounds': [SKIP],
-  'built-ins/TypedArray/prototype/reduceRight/BigInt/return-abrupt-from-this-out-of-bounds': [SKIP],
-  'built-ins/TypedArray/prototype/reduceRight/return-abrupt-from-this-out-of-bounds': [SKIP],
   'built-ins/TypedArray/prototype/reverse/BigInt/return-abrupt-from-this-out-of-bounds': [SKIP],
   'built-ins/TypedArray/prototype/reverse/return-abrupt-from-this-out-of-bounds': [SKIP],
   'built-ins/TypedArray/prototype/set/BigInt/typedarray-arg-target-out-of-bounds': [SKIP],