[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 1286 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(

[caitp, 2016/10/13 22:32:44]

This doesn't change allows me to not alter some tests which check the result of
%ClassOf() in test/mjsunit/es6/array-iterator.js, but other than that it doesn't
buy much (and allocates some extra stuff that gets thrown away :().

Happy to remove it if the test change is preferred.

+        isolate->heap()->ArrayIterator_string());
+
+    Handle<Map> initial_map(array_iterator_function->initial_map(), isolate);
+
+#define ARRAY_ITERATOR_LIST(V, TypedArray, Array)                            \
+  V(TypedArray, TYPED_ARRAY, KEY, typed_array, key)                          \
+  V(Array, GENERIC_ARRAY, KEY, array, key)                                   \
+  V(TypedArray, UINT8_ARRAY, KEY_VALUE, uint8_array, key_value)              \
+  V(TypedArray, INT8_ARRAY, KEY_VALUE, int8_array, key_value)                \
+  V(TypedArray, UINT16_ARRAY, KEY_VALUE, uint16_array, key_value)            \
+  V(TypedArray, INT16_ARRAY, KEY_VALUE, int16_array, key_value)              \
+  V(TypedArray, UINT32_ARRAY, KEY_VALUE, uint32_array, key_value)            \
+  V(TypedArray, INT32_ARRAY, KEY_VALUE, int32_array, key_value)              \
+  V(TypedArray, FLOAT32_ARRAY, KEY_VALUE, float32_array, key_value)          \
+  V(TypedArray, FLOAT64_ARRAY, KEY_VALUE, float64_array, key_value)          \
+  V(TypedArray, UINT8_CLAMPED_ARRAY, KEY_VALUE, uint8_clamped_array,         \
+    key_value)                                                               \
+  V(Array, FAST_SMI_ARRAY, KEY_VALUE, fast_smi_array, key_value)             \
+  V(Array, FAST_HOLEY_SMI_ARRAY, KEY_VALUE, fast_holey_smi_array, key_value) \
+  V(Array, FAST_ARRAY, KEY_VALUE, fast_array, key_value)                     \
+  V(Array, FAST_HOLEY_ARRAY, KEY_VALUE, fast_holey_array, key_value)         \
+  V(Array, FAST_DOUBLE_ARRAY, KEY_VALUE, fast_double_array, key_value)       \
+  V(Array, FAST_HOLEY_DOUBLE_ARRAY, KEY_VALUE, fast_holey_double_array,      \
+    key_value)                                                               \
+  V(Array, GENERIC_ARRAY, KEY_VALUE, array, key_value)                       \
+  V(TypedArray, UINT8_ARRAY, VALUE, uint8_array, value)                      \
+  V(TypedArray, INT8_ARRAY, VALUE, int8_array, value)                        \
+  V(TypedArray, UINT16_ARRAY, VALUE, uint16_array, value)                    \
+  V(TypedArray, INT16_ARRAY, VALUE, int16_array, value)                      \
+  V(TypedArray, UINT32_ARRAY, VALUE, uint32_array, value)                    \
+  V(TypedArray, INT32_ARRAY, VALUE, int32_array, value)                      \
+  V(TypedArray, FLOAT32_ARRAY, VALUE, float32_array, value)                  \
+  V(TypedArray, FLOAT64_ARRAY, VALUE, float64_array, value)                  \
+  V(TypedArray, UINT8_CLAMPED_ARRAY, VALUE, uint8_clamped_array, value)      \
+  V(Array, FAST_SMI_ARRAY, VALUE, fast_smi_array, value)                     \
+  V(Array, FAST_HOLEY_SMI_ARRAY, VALUE, fast_holey_smi_array, value)         \
+  V(Array, FAST_ARRAY, VALUE, fast_array, value)                             \
+  V(Array, FAST_HOLEY_ARRAY, VALUE, fast_holey_array, value)                 \
+  V(Array, FAST_DOUBLE_ARRAY, VALUE, fast_double_array, value)               \
+  V(Array, FAST_HOLEY_DOUBLE_ARRAY, VALUE, fast_holey_double_array, value)   \
+  V(Array, GENERIC_ARRAY, VALUE, array, value)
+
+#define CREATE_ARRAY_ITERATOR_MAP(Class, 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_size(Class::kSize);                                   \
+    map->set_instance_type(type);                                           \
+    native_context()->set_##prefix##_##suffix##_iterator_map(*map);         \
+  } while (0);
+
+    ARRAY_ITERATOR_LIST(CREATE_ARRAY_ITERATOR_MAP, JSTypedArrayIterator,
+                        JSArrayIterator)
+
+#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 723 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 705 matching lines @@
         generator_function_prototype, factory->constructor_string(),
         generator_function_function,
         static_cast<PropertyAttributes>(DONT_ENUM | READ_ONLY));
 
     native_context->sloppy_generator_function_map()->SetConstructor(
         *generator_function_function);
     native_context->strict_generator_function_map()->SetConstructor(
         *generator_function_function);
   }
 
+  {  // -- A r r a y I t e r a t o r
+    Handle<Object> array_values(native_context->array_values_iterator(),
+                                isolate);
+    JSObject::AddProperty(container,
+                          factory->NewStringFromAsciiChecked("ArrayValues"),
+                          array_values, DONT_ENUM);
+  }
+
   {  // -- S e t I t e r a t o r
     Handle<JSObject> set_iterator_prototype =
         isolate->factory()->NewJSObject(isolate->object_function(), TENURED);
     JSObject::ForceSetPrototype(set_iterator_prototype, iterator_prototype);
     Handle<JSFunction> set_iterator_function = InstallFunction(
         container, "SetIterator", JS_SET_ITERATOR_TYPE, JSSetIterator::kSize,
         set_iterator_prototype, Builtins::kIllegal);
     native_context->set_set_iterator_map(set_iterator_function->initial_map());
   }
 
@@ skipping 1610 matching lines @@
 }
 
 
 // Called when the top-level V8 mutex is destroyed.
 void Bootstrapper::FreeThreadResources() {
   DCHECK(!IsActive());
 }
 
 }  // namespace internal
 }  // namespace v8