[Builtins] Provide a code-stub impl. of Array.prototype.map

src/builtins/builtins-array-gen.cc

 // Copyright 2017 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-gen.h"
 #include "src/builtins/builtins.h"
 #include "src/code-stub-assembler.h"
 
 namespace v8 {
 namespace internal {
@@ skipping 110 matching lines @@
                 SmiConstant(MessageTemplate::kReduceNoInitial));
     Unreachable();
     Bind(&ok);
   }
 
   Node* FilterResultGenerator() {
     // 7. Let A be ArraySpeciesCreate(O, 0).
     return ArraySpeciesCreate(context(), o(), SmiConstant(0));
   }
 
+  Node* MapResultGenerator() {
+    // 7. Let A be ArraySpeciesCreate(O, 0).
+    return ArraySpeciesCreate(context(), o(), len_);
+  }
+

[danno, 2017/03/23 12:25:04]

Nit: Elsewhere we group the *Generator/*Filters together. Can you move this
after FilterProcessor?

[mvstanton, 2017/03/24 09:37:08]

Done.

   Node* FilterProcessor(Node* k_value, Node* k) {
     Node* callback_result = CallJS(CodeFactory::Call(isolate()), context(),
                                    callbackfn(), this_arg(), k_value, k, o());
     Label true_continue(this, &to_), false_continue(this);
     BranchIfToBooleanIsTrue(callback_result, &true_continue, &false_continue);
     Bind(&true_continue);
 
     // 1. let status be CreateDataPropertyOrThrow(A, ToString(to), kValue).
     // 2. ReturnIfAbrupt(status)
     Node* const p_to = ToString(context(), to_.value());
     CallRuntime(Runtime::kCreateDataProperty, context(), a(), p_to, k_value);
 
     // 3. Increase to by 1.
     to_.Bind(NumberInc(to_.value()));
     Goto(&false_continue);
     Bind(&false_continue);
     return a();
   }
 
+  Node* MapProcessor(Node* k_value, Node* k) {
+    Node* callback_result = CallJS(CodeFactory::Call(isolate()), context(),
+                                   callbackfn(), this_arg(), k_value, k, o());
+    // TODO(mvstanton): in some cases we have the ToString version of k,
+    // in the continuation.
+    Node* const p_k = ToString(context(), k);

[danno, 2017/03/23 12:25:04]

I wonder if you really need the ToString here, because CreateDataPropery should
be able to deal with all Numbers as property keys, and k is guaranteed to be a
Number, right? 

[mvstanton, 2017/03/24 09:37:08]

Done. This prompted some comment cleanup, to annotate what is happening
vis-a-vis the spec better.

+    CallRuntime(Runtime::kCreateDataProperty, context(), a(), p_k,
+                callback_result);
+    return a();
+  }
+
   void NullPostLoopAction() {}
 
  protected:
   Node* context() { return context_; }
   Node* receiver() { return receiver_; }
   Node* new_target() { return new_target_; }
   Node* o() { return o_; }
   Node* len() { return len_; }
   Node* callbackfn() { return callbackfn_; }
   Node* this_arg() { return this_arg_; }
@@ skipping 603 matching lines @@
   Node* context = Parameter(Descriptor::kContext);
   Node* receiver = Parameter(Descriptor::kReceiver);
   Node* callbackfn = Parameter(Descriptor::kCallbackFn);
   Node* this_arg = Parameter(Descriptor::kThisArg);
   Node* new_target = Parameter(Descriptor::kNewTarget);
 
   InitIteratingArrayBuiltinBody(context, receiver, callbackfn, this_arg,
                                 new_target);
 
   GenerateIteratingArrayBuiltinBody(
-      "Array.prototype.reduce",
+      "Array.prototype.filter",
       &ArrayBuiltinCodeStubAssembler::FilterResultGenerator,
       &ArrayBuiltinCodeStubAssembler::FilterProcessor,
       &ArrayBuiltinCodeStubAssembler::NullPostLoopAction,
       CodeFactory::ArrayFilterLoopContinuation(isolate()));
 }
 
+TF_BUILTIN(ArrayMapLoopContinuation, ArrayBuiltinCodeStubAssembler) {
+  Node* context = Parameter(Descriptor::kContext);
+  Node* receiver = Parameter(Descriptor::kReceiver);
+  Node* callbackfn = Parameter(Descriptor::kCallbackFn);
+  Node* this_arg = Parameter(Descriptor::kThisArg);
+  Node* array = Parameter(Descriptor::kArray);
+  Node* object = Parameter(Descriptor::kObject);
+  Node* initial_k = Parameter(Descriptor::kInitialK);
+  Node* len = Parameter(Descriptor::kLength);
+  Node* to = Parameter(Descriptor::kTo);
+
+  InitIteratingArrayBuiltinLoopContinuation(context, receiver, callbackfn,
+                                            this_arg, array, object, initial_k,
+                                            len, to);
+
+  GenerateIteratingArrayBuiltinLoopContinuation(
+      &ArrayBuiltinCodeStubAssembler::MapProcessor,
+      &ArrayBuiltinCodeStubAssembler::NullPostLoopAction);
+}
+
+TF_BUILTIN(ArrayMap, ArrayBuiltinCodeStubAssembler) {
+  Node* context = Parameter(Descriptor::kContext);
+  Node* receiver = Parameter(Descriptor::kReceiver);
+  Node* callbackfn = Parameter(Descriptor::kCallbackFn);
+  Node* this_arg = Parameter(Descriptor::kThisArg);
+  Node* new_target = Parameter(Descriptor::kNewTarget);
+
+  InitIteratingArrayBuiltinBody(context, receiver, callbackfn, this_arg,
+                                new_target);
+
+  GenerateIteratingArrayBuiltinBody(
+      "Array.prototype.map", &ArrayBuiltinCodeStubAssembler::MapResultGenerator,
+      &ArrayBuiltinCodeStubAssembler::MapProcessor,
+      &ArrayBuiltinCodeStubAssembler::NullPostLoopAction,
+      CodeFactory::ArrayMapLoopContinuation(isolate()));
+}
+
 TF_BUILTIN(ArrayIsArray, CodeStubAssembler) {
   Node* object = Parameter(Descriptor::kArg);
   Node* context = Parameter(Descriptor::kContext);
 
   Label call_runtime(this), return_true(this), return_false(this);
 
   GotoIf(TaggedIsSmi(object), &return_false);
   Node* instance_type = LoadInstanceType(object);
 
   GotoIf(Word32Equal(instance_type, Int32Constant(JS_ARRAY_TYPE)),
@@ skipping 1041 matching lines @@
   {
     Node* message = SmiConstant(MessageTemplate::kDetachedOperation);
     CallRuntime(Runtime::kThrowTypeError, context, message,
                 HeapConstant(operation));
     Unreachable();
   }
 }
 
 }  // namespace internal
 }  // namespace v8