src/builtins/typed-array-from.tq

// Copyright 2019 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include 'src/builtins/builtins-typed-array-gen.h'

namespace typed_array {
  const kBuiltinNameFrom: constexpr string = '%TypedArray%.from';

  type BuiltinsName extends int31 constexpr 'Builtins::Name';
  const kTypedArrayPrototypeValues: constexpr BuiltinsName
  generates 'Builtins::kTypedArrayPrototypeValues';

  extern builtin IterableToList(implicit context: Context)(JSAny, JSAny):
      JSArray;

  // %TypedArray%.from ( source [ , mapfn [ , thisArg ] ] )
  // https://tc39.github.io/ecma262/#sec-%typedarray%.from
  transitioning javascript builtin
  TypedArrayFrom(js-implicit context: NativeContext, receiver: JSAny)(
      ...arguments): JSTypedArray {
    try {
      const source: JSAny = arguments[0];

      // 1. Let C be the this value.
      // 2. If IsConstructor(C) is false, throw a TypeError exception.
      const constructor = Cast<Constructor>(receiver) otherwise NotConstructor;

      // 3. If mapfn is present and mapfn is not undefined, then
      //   a. If IsCallable(mapfn) is false, throw a TypeError exception.
      //   b. Let mapping be true.
      // 4. Else, let mapping be false.
      const mapping: bool = arguments.length > 1;
      const mapfnObj: JSAny = mapping ? arguments[1] : Undefined;
      if (mapping && !TaggedIsCallable(mapfnObj)) deferred {
          ThrowTypeError(MessageTemplate::kCalledNonCallable, mapfnObj);
        }

      // 5. If thisArg is present, let T be thisArg; else let T be undefined.
      const thisArg = arguments.length > 2 ? arguments[2] : Undefined;

      // We split up this builtin differently to the way it is written in the
      // spec. We already have great code in the elements accessor for copying
      // from a JSArray into a TypedArray, so we use that when possible. We only
      // avoid calling into the elements accessor when we have a mapping
      // function, because we can't handle that. Here, presence of a mapping
      // function is the slow path. We also combine the two different loops in
      // the specification (starting at 7.e and 13) because they are essentially
      // identical. We also save on code-size this way.

      let finalLength: uintptr;
      let finalSource: JSAny;

      try {
        // 6. Let usingIterator be ? GetMethod(source, @@iterator).
        // TODO(v8:8906): Use iterator::GetIteratorMethod() once it supports
        // labels.
        const usingIterator = GetMethod(source, IteratorSymbolConstant())
            otherwise IteratorIsUndefined, IteratorNotCallable;

        try {
          // TypedArrays have iterators, so normally we would go through the
          // IterableToList case below, which would convert the TypedArray to a
          // JSArray (boxing the values if they won't fit in a Smi).
          //
          // However, if we can guarantee that the source object has the
          // built-in iterator and that the %ArrayIteratorPrototype%.next method
          // has not been overridden, then we know the behavior of the iterator:
          // returning the values in the TypedArray sequentially from index 0 to
          // length-1.
          //
          // In this case, we can avoid creating the intermediate array and the
          // associated HeapNumbers, and use the fast path in
          // TypedArrayCopyElements which uses the same ordering as the default
          // iterator.
          //
          // Drop through to the default check_iterator behavior if any of these
          // checks fail.
          const sourceTypedArray =
              Cast<JSTypedArray>(source) otherwise UseUserProvidedIterator;
          const sourceBuffer = sourceTypedArray.buffer;
          if (IsDetachedBuffer(sourceBuffer)) goto UseUserProvidedIterator;

          // Check that the iterator function is exactly
          // Builtins::kTypedArrayPrototypeValues.
          const iteratorFn =
              Cast<JSFunction>(usingIterator) otherwise UseUserProvidedIterator;
          if (!TaggedEqual(
                  iteratorFn.shared_function_info.function_data,
                  SmiConstant(kTypedArrayPrototypeValues)))
            goto UseUserProvidedIterator;

          // Check that the ArrayIterator prototype's "next" method hasn't been
          // overridden.
          if (IsArrayIteratorProtectorCellInvalid())
            goto UseUserProvidedIterator;

          // Source is a TypedArray with unmodified iterator behavior. Use the
          // source object directly, taking advantage of the special-case code
          // in TypedArrayCopyElements
          finalLength = sourceTypedArray.length;
          finalSource = source;
        }
        label UseUserProvidedIterator {
          // 7. If usingIterator is not undefined, then
          //  a. Let values be ? IterableToList(source, usingIterator).
          //  b. Let len be the number of elements in values.
          const values: JSArray = IterableToList(source, usingIterator);

          finalLength = Convert<uintptr>(values.length);
          finalSource = values;
        }
      }
      label IteratorIsUndefined {
        // 8. NOTE: source is not an Iterable so assume it is already an
        // array-like object.

        // 9. Let arrayLike be ! ToObject(source).
        const arrayLike: JSReceiver = ToObject_Inline(context, source);

        // 10. Let len be ? ToLength(? Get(arrayLike, "length")).
        const length = GetLengthProperty(arrayLike);

        try {
          finalLength = ChangeSafeIntegerNumberToUintPtr(length)
              otherwise IfInvalidLength;
          finalSource = arrayLike;
        }
        label IfInvalidLength deferred {
          ThrowRangeError(MessageTemplate::kInvalidTypedArrayLength, length);
        }
      }
      label IteratorNotCallable(_value: JSAny) deferred {
        ThrowTypeError(MessageTemplate::kIteratorSymbolNonCallable);
      }

      const finalLengthNum = Convert<Number>(finalLength);

      // 7c/11. Let targetObj be ? TypedArrayCreate(C, «len»).
      const targetObj = TypedArrayCreateByLength(
          constructor, finalLengthNum, kBuiltinNameFrom);

      if (!mapping) {
        // Fast path.
        if (finalLength != 0) {
          // Call runtime.
          TypedArrayCopyElements(
              context, targetObj, finalSource, finalLengthNum);
        }
        return targetObj;
      }
      // Slow path.

      const mapfn: Callable = Cast<Callable>(mapfnObj) otherwise unreachable;
      const accessor: TypedArrayAccessor =
          GetTypedArrayAccessor(targetObj.elements_kind);

      // 7d-7e and 12-13.
      // 12. Let k be 0.
      // 13. Repeat, while k < len
      for (let k: uintptr = 0; k < finalLength; k++) {
        // 13a. Let Pk be ! ToString(k).
        const kNum = Convert<Number>(k);

        // 13b. Let kValue be ? Get(arrayLike, Pk).
        const kValue: JSAny = GetProperty(finalSource, kNum);

        let mappedValue: JSAny;
        // 13c. If mapping is true, then
        if (mapping) {
          // i. Let mappedValue be ? Call(mapfn, T, « kValue, k »).
          mappedValue = Call(context, mapfn, thisArg, kValue, kNum);
        } else {
          // 13d. Else, let mappedValue be kValue.
          mappedValue = kValue;
        }

        // 13e. Perform ? Set(targetObj, Pk, mappedValue, true).
        // Buffer may be detached during executing ToNumber/ToBigInt.
        accessor.StoreJSAny(context, targetObj, k, mappedValue)
            otherwise IfDetached;

        // 13f. Set k to k + 1. (done by the loop).
      }
      return targetObj;
    }
    label NotConstructor deferred {
      ThrowTypeError(MessageTemplate::kNotConstructor, receiver);
    }
    label IfDetached deferred {
      ThrowTypeError(MessageTemplate::kDetachedOperation, kBuiltinNameFrom);
    }
  }
}