[builtins] Implement %TypedArray%.prototype.map in the CSA

src/builtins/builtins-typedarray.cc

 // Copyright 2016 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-utils.h"
 #include "src/builtins/builtins.h"
 #include "src/counters.h"
 #include "src/elements.h"
 #include "src/objects-inl.h"
 
@@ skipping 23 matching lines @@
       // +Infinity / -Infinity
       DCHECK(!std::isnan(fp));
       return fp < 0 ? minimum : maximum;
     }
     relative = static_cast<int64_t>(fp);
   }
   return relative < 0 ? std::max<int64_t>(relative + maximum, minimum)
                       : std::min<int64_t>(relative, maximum);
 }
 
-// ES7 section 22.2.4.6 TypedArrayCreate ( constructor, argumentList )
-MaybeHandle<JSTypedArray> TypedArrayCreate(Isolate* isolate,
-                                           Handle<JSFunction> default_ctor,
-                                           int argc, Handle<Object>* argv,
-                                           const char* method_name) {
-  // 1. Let newTypedArray be ? Construct(constructor, argumentList).
-  Handle<Object> new_obj;
-  ASSIGN_RETURN_ON_EXCEPTION(
-      isolate, new_obj, Execution::New(default_ctor, argc, argv), JSTypedArray);
-
-  // 2. Perform ? ValidateTypedArray(newTypedArray).
-  Handle<JSTypedArray> new_array;
-  ASSIGN_RETURN_ON_EXCEPTION(
-      isolate, new_array, JSTypedArray::Validate(isolate, new_obj, method_name),
-      JSTypedArray);
-
-  // 3. If argumentList is a List of a single Number, then
-  // If newTypedArray.[[ArrayLength]] < size, throw a TypeError exception.
-  DCHECK_IMPLIES(argc == 1, argv[0]->IsSmi());
-  if (argc == 1 && new_array->length_value() < argv[0]->Number()) {
-    const MessageTemplate::Template message =
-        MessageTemplate::kTypedArrayTooShort;
-    THROW_NEW_ERROR(isolate, NewTypeError(message), JSTypedArray);
-  }
-
-  // 4. Return newTypedArray.
-  return new_array;
-}
-
-// ES7 section 22.2.4.7 TypedArraySpeciesCreate ( exemplar, argumentList )
-MaybeHandle<JSTypedArray> TypedArraySpeciesCreate(Isolate* isolate,
-                                                  Handle<JSTypedArray> exemplar,
-                                                  int argc,
-                                                  Handle<Object>* argv,
-                                                  const char* method_name) {
-  // 1. Assert: exemplar is an Object that has a [[TypedArrayName]] internal
-  // slot.
-  DCHECK(exemplar->IsJSTypedArray());
-
-  // 2. Let defaultConstructor be the intrinsic object listed in column one of
-  // Table 51 for exemplar.[[TypedArrayName]].
-  Handle<JSFunction> default_ctor = isolate->uint8_array_fun();
-  switch (exemplar->type()) {
-#define TYPED_ARRAY_CTOR(Type, type, TYPE, ctype, size) \
-  case kExternal##Type##Array: {                        \
-    default_ctor = isolate->type##_array_fun();         \
-    break;                                              \
-  }
-
-    TYPED_ARRAYS(TYPED_ARRAY_CTOR)
-#undef TYPED_ARRAY_CTOR
-    default:
-      UNREACHABLE();
-  }
-
-  // 3. Let constructor be ? SpeciesConstructor(exemplar, defaultConstructor).
-  Handle<Object> ctor;
-  ASSIGN_RETURN_ON_EXCEPTION(
-      isolate, ctor,
-      Object::SpeciesConstructor(isolate, exemplar, default_ctor),
-      JSTypedArray);
-
-  // 4. Return ? TypedArrayCreate(constructor, argumentList).
-  return TypedArrayCreate(isolate, Handle<JSFunction>::cast(ctor), argc, argv,
-                          method_name);
-}
-
 MaybeHandle<JSTypedArray> TypedArraySpeciesCreateByLength(
-    Isolate* isolate, Handle<JSTypedArray> exemplar, const char* method_name,
-    int64_t length) {
+    Isolate* isolate, Handle<JSTypedArray> exemplar, int64_t length) {
   const int argc = 1;
   ScopedVector<Handle<Object>> argv(argc);
   argv[0] = isolate->factory()->NewNumberFromInt64(length);
-  return TypedArraySpeciesCreate(isolate, exemplar, argc, argv.start(),
-                                 method_name);
+  return JSTypedArray::SpeciesCreate(isolate, exemplar, argc, argv.start());
 }
 
 }  // namespace
 
 BUILTIN(TypedArrayPrototypeCopyWithin) {
   HandleScope scope(isolate);
 
   Handle<JSTypedArray> array;
-  const char* method = "%TypedArray%.prototype.copyWithin";
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
-      isolate, array, JSTypedArray::Validate(isolate, args.receiver(), method));
+      isolate, array, JSTypedArray::Validate(isolate, args.receiver()));
 
   if (V8_UNLIKELY(array->WasNeutered())) return *array;
 
   int64_t len = array->length_value();
   int64_t to = 0;
   int64_t from = 0;
   int64_t final = len;
 
   if (V8_LIKELY(args.length() > 1)) {
     Handle<Object> num;
@@ skipping 42 matching lines @@
   uint8_t* data = static_cast<uint8_t*>(elements->DataPtr());
   std::memmove(data + to, data + from, count);
 
   return *array;
 }
 
 BUILTIN(TypedArrayPrototypeFill) {
   HandleScope scope(isolate);
 
   Handle<JSTypedArray> array;
-  const char* method = "%TypedArray%.prototype.fill";
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
-      isolate, array, JSTypedArray::Validate(isolate, args.receiver(), method));
+      isolate, array, JSTypedArray::Validate(isolate, args.receiver()));
 
   if (V8_UNLIKELY(array->WasNeutered())) return *array;
 
   Handle<Object> obj_value = args.atOrUndefined(isolate, 1);
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
       isolate, obj_value, Object::ToNumber(obj_value));
 
   int64_t len = array->length_value();
   int64_t start = 0;
   int64_t end = len;
@@ skipping 28 matching lines @@
 
   return array->GetElementsAccessor()->Fill(isolate, array, obj_value,
                                             static_cast<uint32_t>(start),
                                             static_cast<uint32_t>(end));
 }
 
 BUILTIN(TypedArrayPrototypeIncludes) {
   HandleScope scope(isolate);
 
   Handle<JSTypedArray> array;
-  const char* method = "%TypedArray%.prototype.includes";
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
-      isolate, array, JSTypedArray::Validate(isolate, args.receiver(), method));
+      isolate, array, JSTypedArray::Validate(isolate, args.receiver()));
 
   if (args.length() < 2) return isolate->heap()->false_value();
 
   int64_t len = array->length_value();
   if (len == 0) return isolate->heap()->false_value();
 
   int64_t index = 0;
   if (args.length() > 2) {
     Handle<Object> num;
     ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
@@ skipping 10 matching lines @@
                                                static_cast<uint32_t>(index),
                                                static_cast<uint32_t>(len));
   MAYBE_RETURN(result, isolate->heap()->exception());
   return *isolate->factory()->ToBoolean(result.FromJust());
 }
 
 BUILTIN(TypedArrayPrototypeIndexOf) {
   HandleScope scope(isolate);
 
   Handle<JSTypedArray> array;
-  const char* method = "%TypedArray%.prototype.indexOf";
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
-      isolate, array, JSTypedArray::Validate(isolate, args.receiver(), method));
+      isolate, array, JSTypedArray::Validate(isolate, args.receiver()));
 
   int64_t len = array->length_value();
   if (len == 0) return Smi::FromInt(-1);
 
   int64_t index = 0;
   if (args.length() > 2) {
     Handle<Object> num;
     ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
         isolate, num, Object::ToInteger(isolate, args.at<Object>(2)));
     index = CapRelativeIndex(num, 0, len);
   }
 
   // TODO(cwhan.tunz): throw. See the above comment in CopyWithin.
   if (V8_UNLIKELY(array->WasNeutered())) return Smi::FromInt(-1);
 
   Handle<Object> search_element = args.atOrUndefined(isolate, 1);
   ElementsAccessor* elements = array->GetElementsAccessor();
   Maybe<int64_t> result = elements->IndexOfValue(isolate, array, search_element,
                                                  static_cast<uint32_t>(index),
                                                  static_cast<uint32_t>(len));
   MAYBE_RETURN(result, isolate->heap()->exception());
   return *isolate->factory()->NewNumberFromInt64(result.FromJust());
 }
 
 BUILTIN(TypedArrayPrototypeLastIndexOf) {
   HandleScope scope(isolate);
 
   Handle<JSTypedArray> array;
-  const char* method = "%TypedArray%.prototype.lastIndexOf";
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
-      isolate, array, JSTypedArray::Validate(isolate, args.receiver(), method));
+      isolate, array, JSTypedArray::Validate(isolate, args.receiver()));
 
   int64_t len = array->length_value();
   if (len == 0) return Smi::FromInt(-1);
 
   int64_t index = len - 1;
   if (args.length() > 2) {
     Handle<Object> num;
     ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
         isolate, num, Object::ToInteger(isolate, args.at<Object>(2)));
     // Set a negative value (-1) for returning -1 if num is negative and
@@ skipping 11 matching lines @@
   Maybe<int64_t> result = elements->LastIndexOfValue(
       isolate, array, search_element, static_cast<uint32_t>(index));
   MAYBE_RETURN(result, isolate->heap()->exception());
   return *isolate->factory()->NewNumberFromInt64(result.FromJust());
 }
 
 BUILTIN(TypedArrayPrototypeReverse) {
   HandleScope scope(isolate);
 
   Handle<JSTypedArray> array;
-  const char* method = "%TypedArray%.prototype.reverse";
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
-      isolate, array, JSTypedArray::Validate(isolate, args.receiver(), method));
+      isolate, array, JSTypedArray::Validate(isolate, args.receiver()));
 
   if (V8_UNLIKELY(array->WasNeutered())) return *array;
 
   ElementsAccessor* elements = array->GetElementsAccessor();
   elements->Reverse(*array);
   return *array;
 }
 
 BUILTIN(TypedArrayPrototypeSlice) {
   HandleScope scope(isolate);
 
   Handle<JSTypedArray> array;
-  const char* method = "%TypedArray%.prototype.slice";
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
-      isolate, array, JSTypedArray::Validate(isolate, args.receiver(), method));
+      isolate, array, JSTypedArray::Validate(isolate, args.receiver()));
 
   int64_t len = array->length_value();
   int64_t start = 0;
   int64_t end = len;
   {
     Handle<Object> num = args.atOrUndefined(isolate, 1);
     if (!num->IsUndefined(isolate)) {
       ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, num,
                                          Object::ToInteger(isolate, num));
       start = CapRelativeIndex(num, 0, len);
 
       num = args.atOrUndefined(isolate, 2);
       if (!num->IsUndefined(isolate)) {
         ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, num,
                                            Object::ToInteger(isolate, num));
         end = CapRelativeIndex(num, 0, len);
       }
     }
   }
 
   int64_t count = std::max<int64_t>(end - start, 0);
 
   Handle<JSTypedArray> result_array;
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
       isolate, result_array,
-      TypedArraySpeciesCreateByLength(isolate, array, method, count));
+      TypedArraySpeciesCreateByLength(isolate, array, count));
 
   // TODO(cwhan.tunz): neutering check of the result_array should be done in
   // TypedArraySpeciesCreate, but currently ValidateTypedArray does not throw
   // for neutered buffer, so this is a temporary neutering check for the result
   // array
   if (V8_UNLIKELY(result_array->WasNeutered())) return *result_array;
 
   // TODO(cwhan.tunz): should throw.
   if (V8_UNLIKELY(array->WasNeutered())) return *result_array;
 
   if (count == 0) return *result_array;
 
   ElementsAccessor* accessor = array->GetElementsAccessor();
   return *accessor->Slice(array, static_cast<uint32_t>(start),
                           static_cast<uint32_t>(end), result_array);
 }
 
 }  // namespace internal
 }  // namespace v8