[builtins] implement Array.prototype[@@iterator] in TFJ builtins

src/bootstrapper.cc

 // Copyright 2014 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/bootstrapper.h"
 
 #include "src/accessors.h"
 #include "src/api-natives.h"
 #include "src/base/ieee754.h"
 #include "src/code-stubs.h"
@@ skipping 1292 matching lines @@
     ArrayConstructorStub array_constructor_stub(isolate);
     Handle<Code> code = array_constructor_stub.GetCode();
     array_function->shared()->SetConstructStub(*code);
 
     Handle<JSFunction> is_arraylike = SimpleInstallFunction(
         array_function, isolate->factory()->InternalizeUtf8String("isArray"),
         Builtins::kArrayIsArray, 1, true);
     native_context()->set_is_arraylike(*is_arraylike);
   }
 
+  {  // --- A r r a y I t e r a t o r ---
+    Handle<JSObject> iterator_prototype(
+        native_context()->initial_iterator_prototype());
+
+    Handle<JSObject> array_iterator_prototype =
+        factory->NewJSObject(isolate->object_function(), TENURED);
+    JSObject::ForceSetPrototype(array_iterator_prototype, iterator_prototype);
+
+    JSObject::AddProperty(
+        array_iterator_prototype, factory->to_string_tag_symbol(),
+        factory->ArrayIterator_string(),
+        static_cast<PropertyAttributes>(DONT_ENUM | READ_ONLY));
+
+    Handle<JSFunction> next = InstallFunction(
+        array_iterator_prototype, "next", JS_OBJECT_TYPE, JSObject::kHeaderSize,
+        MaybeHandle<JSObject>(), Builtins::kArrayIteratorPrototypeNext);
+
+    // Set the expected parameters for %ArrayIteratorPrototype%.next to 0 (not
+    // including the receiver), as required by the builtin.
+    next->shared()->set_internal_formal_parameter_count(0);
+
+    // Set the length for the function to satisfy ECMA-262.
+    next->shared()->set_length(0);
+
+    Handle<JSFunction> array_iterator_function = CreateFunction(
+        isolate, factory->ArrayIterator_string(),
+        JS_FAST_ARRAY_VALUE_ITERATOR_TYPE, JSArrayIterator::kSize,
+        array_iterator_prototype, Builtins::kIllegal);
+    array_iterator_function->shared()->set_instance_class_name(
+        isolate->heap()->ArrayIterator_string());
+
+    Handle<Map> initial_map(array_iterator_function->initial_map(), isolate);
+
+#define ARRAY_ITERATOR_LIST(V)                                              \
+  V(TYPED_ARRAY, KEY, typed_array, key)                                     \
+  V(GENERIC_ARRAY, KEY, array, key)                                         \
+  V(UINT8_ARRAY, KEY_VALUE, uint8_array, key_value)                         \
+  V(INT8_ARRAY, KEY_VALUE, int8_array, key_value)                           \
+  V(UINT16_ARRAY, KEY_VALUE, uint16_array, key_value)                       \
+  V(INT16_ARRAY, KEY_VALUE, int16_array, key_value)                         \
+  V(UINT32_ARRAY, KEY_VALUE, uint32_array, key_value)                       \
+  V(INT32_ARRAY, KEY_VALUE, int32_array, key_value)                         \
+  V(FLOAT32_ARRAY, KEY_VALUE, float32_array, key_value)                     \
+  V(FLOAT64_ARRAY, KEY_VALUE, float64_array, key_value)                     \
+  V(UINT8_CLAMPED_ARRAY, KEY_VALUE, uint8_clamped_array, key_value)         \
+  V(FAST_SMI_ARRAY, KEY_VALUE, fast_smi_array, key_value)                   \
+  V(FAST_HOLEY_SMI_ARRAY, KEY_VALUE, fast_holey_smi_array, key_value)       \
+  V(FAST_ARRAY, KEY_VALUE, fast_array, key_value)                           \
+  V(FAST_HOLEY_ARRAY, KEY_VALUE, fast_holey_array, key_value)               \
+  V(FAST_DOUBLE_ARRAY, KEY_VALUE, fast_double_array, key_value)             \
+  V(FAST_HOLEY_DOUBLE_ARRAY, KEY_VALUE, fast_holey_double_array, key_value) \
+  V(GENERIC_ARRAY, KEY_VALUE, array, key_value)                             \
+  V(UINT8_ARRAY, VALUE, uint8_array, value)                                 \
+  V(INT8_ARRAY, VALUE, int8_array, value)                                   \
+  V(UINT16_ARRAY, VALUE, uint16_array, value)                               \
+  V(INT16_ARRAY, VALUE, int16_array, value)                                 \
+  V(UINT32_ARRAY, VALUE, uint32_array, value)                               \
+  V(INT32_ARRAY, VALUE, int32_array, value)                                 \
+  V(FLOAT32_ARRAY, VALUE, float32_array, value)                             \
+  V(FLOAT64_ARRAY, VALUE, float64_array, value)                             \
+  V(UINT8_CLAMPED_ARRAY, VALUE, uint8_clamped_array, value)                 \
+  V(FAST_SMI_ARRAY, VALUE, fast_smi_array, value)                           \
+  V(FAST_HOLEY_SMI_ARRAY, VALUE, fast_holey_smi_array, value)               \
+  V(FAST_ARRAY, VALUE, fast_array, value)                                   \
+  V(FAST_HOLEY_ARRAY, VALUE, fast_holey_array, value)                       \
+  V(FAST_DOUBLE_ARRAY, VALUE, fast_double_array, value)                     \
+  V(FAST_HOLEY_DOUBLE_ARRAY, VALUE, fast_holey_double_array, value)         \
+  V(GENERIC_ARRAY, VALUE, array, value)
+
+#define CREATE_ARRAY_ITERATOR_MAP(PREFIX, SUFFIX, prefix, suffix)           \
+  do {                                                                      \
+    const InstanceType type = JS_##PREFIX##_##SUFFIX##_ITERATOR_TYPE;       \
+    Handle<Map> map =                                                       \
+        Map::Copy(initial_map, "JS_" #PREFIX "_" #SUFFIX "_ITERATOR_TYPE"); \
+    map->set_instance_type(type);                                           \
+    native_context()->set_##prefix##_##suffix##_iterator_map(*map);         \
+  } while (0);
+
+    ARRAY_ITERATOR_LIST(CREATE_ARRAY_ITERATOR_MAP)
+
+#undef CREATE_ARRAY_ITERATOR_MAP
+#undef ARRAY_ITERATOR_LIST
+  }
+
   {  // --- N u m b e r ---
     Handle<JSFunction> number_fun = InstallFunction(
         global, "Number", JS_VALUE_TYPE, JSValue::kSize,
         isolate->initial_object_prototype(), Builtins::kNumberConstructor);
     number_fun->shared()->DontAdaptArguments();
     number_fun->shared()->SetConstructStub(
         *isolate->builtins()->NumberConstructor_ConstructStub());
     number_fun->shared()->set_length(1);
     InstallWithIntrinsicDefaultProto(isolate, number_fun,
                                      Context::NUMBER_FUNCTION_INDEX);
@@ skipping 762 matching lines @@
                         Builtins::kTypedArrayPrototypeBuffer, false);
     SimpleInstallGetter(prototype, factory->byte_length_string(),
                         Builtins::kTypedArrayPrototypeByteLength, true,
                         kTypedArrayByteLength);
     SimpleInstallGetter(prototype, factory->byte_offset_string(),
                         Builtins::kTypedArrayPrototypeByteOffset, true,
                         kTypedArrayByteOffset);
     SimpleInstallGetter(prototype, factory->length_string(),
                         Builtins::kTypedArrayPrototypeLength, true,
                         kTypedArrayLength);
+
+    // Install "keys", "values" and "entries" methods on the {prototype}.
+    SimpleInstallFunction(prototype, factory->entries_string(),
+                          Builtins::kTypedArrayPrototypeEntries, 0, true);
+    SimpleInstallFunction(prototype, factory->keys_string(),
+                          Builtins::kTypedArrayPrototypeKeys, 0, true);
+    Handle<JSFunction> iterator =
+        SimpleInstallFunction(prototype, factory->values_string(),
+                              Builtins::kTypedArrayPrototypeValues, 0, true);
+    JSObject::AddProperty(prototype, factory->iterator_symbol(), iterator,
+                          DONT_ENUM);
   }
 
   {  // -- T y p e d A r r a y s
 #define INSTALL_TYPED_ARRAY(Type, type, TYPE, ctype, size)             \
   {                                                                    \
     Handle<JSFunction> fun;                                            \
     InstallTypedArray(#Type "Array", TYPE##_ELEMENTS, &fun);           \
     InstallWithIntrinsicDefaultProto(isolate, fun,                     \
                                      Context::TYPE##_ARRAY_FUN_INDEX); \
   }
@@ skipping 2363 matching lines @@
 }
 
 
 // Called when the top-level V8 mutex is destroyed.
 void Bootstrapper::FreeThreadResources() {
   DCHECK(!IsActive());
 }
 
 }  // namespace internal
 }  // namespace v8