Wrap JSFunction bindings in a helper object

src/runtime/runtime-function.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/runtime/runtime-utils.h"
 
 #include "src/accessors.h"
 #include "src/arguments.h"
 #include "src/compiler.h"
 #include "src/deoptimizer.h"
@@ skipping 339 matching lines @@
     }
     return param_data;
   }
 }
 
 
 RUNTIME_FUNCTION(Runtime_FunctionBindArguments) {
   HandleScope scope(isolate);
   DCHECK(args.length() == 4);
   CONVERT_ARG_HANDLE_CHECKED(JSFunction, bound_function, 0);
   CONVERT_ARG_HANDLE_CHECKED(Object, bindee, 1);

[Igor Sheludko, 2015/10/01 08:03:35]

While you are here: it looks like bindee must be a JSReceiver, why not just
declare it as JSReceiver to avoid handle castings below.

[mvstanton, 2015/10/01 11:23:01]

Good idea, done.

   CONVERT_ARG_HANDLE_CHECKED(Object, this_object, 2);
   CONVERT_NUMBER_ARG_HANDLE_CHECKED(new_length, 3);
 
   // TODO(lrn): Create bound function in C++ code from premade shared info.
   bound_function->shared()->set_bound(true);
   bound_function->shared()->set_optimized_code_map(Smi::FromInt(0));
   bound_function->shared()->set_inferred_name(isolate->heap()->empty_string());
   // Get all arguments of calling function (Function.prototype.bind).
   int argc = 0;
   base::SmartArrayPointer<Handle<Object>> arguments =
       Runtime::GetCallerArguments(isolate, 0, &argc);
   // Don't count the this-arg.
   if (argc > 0) {
     RUNTIME_ASSERT(arguments[0].is_identical_to(this_object));
     argc--;
   } else {
     RUNTIME_ASSERT(this_object->IsUndefined());
   }
   // Initialize array of bindings (function, this, and any existing arguments
   // if the function was already bound).
-  Handle<FixedArray> new_bindings;
+  Handle<BindingsArray> new_bindings;
   int i;

[Igor Sheludko, 2015/10/01 08:03:35]

Suggestion for better readability: int out_index = 0;

[mvstanton, 2015/10/01 11:23:01]

Done.

+  Handle<TypeFeedbackVector> vector(
+      bound_function->shared()->feedback_vector());
   if (bindee->IsJSFunction() && JSFunction::cast(*bindee)->shared()->bound()) {
-    Handle<FixedArray> old_bindings(
+    Handle<BindingsArray> old_bindings(
         JSFunction::cast(*bindee)->function_bindings());
-    RUNTIME_ASSERT(old_bindings->length() > JSFunction::kBoundFunctionIndex);
-    new_bindings =
-        isolate->factory()->NewFixedArray(old_bindings->length() + argc);
-    bindee = Handle<Object>(old_bindings->get(JSFunction::kBoundFunctionIndex),
-                            isolate);
+    RUNTIME_ASSERT(old_bindings->bindings_count() >= 0);
+    bindee = Handle<JSReceiver>(old_bindings->bound_function(), isolate);

[Igor Sheludko, 2015/10/01 08:03:35]

nit: bindee = handle(old_bindings->bound_function(), isolate);

[mvstanton, 2015/10/01 11:23:01]

Done.

+    Handle<Object> old_bound_this = handle(old_bindings->bound_this(), isolate);

[Igor Sheludko, 2015/10/01 08:03:35]

nit: Handle<Object> old_bound_this(old_bindings->bound_this(), isolate);

[mvstanton, 2015/10/01 11:23:01]

Done.

+    new_bindings = BindingsArray::New(
+        isolate, vector, Handle<JSReceiver>::cast(bindee), old_bound_this,
+        old_bindings->bindings_count() + argc);
     i = 0;

[Igor Sheludko, 2015/10/01 08:03:35]

Can be removed.

[mvstanton, 2015/10/01 11:23:01]

Done.

-    for (int n = old_bindings->length(); i < n; i++) {
-      new_bindings->set(i, old_bindings->get(i));
+    for (int n = old_bindings->bindings_count(); i < n; i++) {
+      new_bindings->set_binding(i, old_bindings->binding(i));

[Igor Sheludko, 2015/10/01 08:03:35]

suggestion: new_bindings->set_binding(out_index, old_bindings->binding(i));

[mvstanton, 2015/10/01 11:23:01]

Done.

     }
   } else {
-    int array_size = JSFunction::kBoundArgumentsStartIndex + argc;
-    new_bindings = isolate->factory()->NewFixedArray(array_size);
-    new_bindings->set(JSFunction::kBoundFunctionIndex, *bindee);
-    new_bindings->set(JSFunction::kBoundThisIndex, *this_object);
-    i = 2;
+    new_bindings = BindingsArray::New(
+        isolate, vector, Handle<JSReceiver>::cast(bindee), this_object, argc);
+    i = 0;

[Igor Sheludko, 2015/10/01 08:03:35]

Can be removed.

[mvstanton, 2015/10/01 11:23:01]

Done.

   }
   // Copy arguments, skipping the first which is "this_arg".
   for (int j = 0; j < argc; j++, i++) {
-    new_bindings->set(i, *arguments[j + 1]);
+    new_bindings->set_binding(i, *arguments[j + 1]);
   }
   new_bindings->set_map_no_write_barrier(isolate->heap()->fixed_array_map());
   bound_function->set_function_bindings(*new_bindings);
 
   // Update length. Have to remove the prototype first so that map migration
   // is happy about the number of fields.
   RUNTIME_ASSERT(bound_function->RemovePrototype());
 
   // The new function should have the same [[Prototype]] as the bindee.
   Handle<Map> bound_function_map(
@@ skipping 23 matching lines @@
 }
 
 
 RUNTIME_FUNCTION(Runtime_BoundFunctionGetBindings) {
   HandleScope handles(isolate);
   DCHECK(args.length() == 1);
   CONVERT_ARG_HANDLE_CHECKED(JSReceiver, callable, 0);
   if (callable->IsJSFunction()) {
     Handle<JSFunction> function = Handle<JSFunction>::cast(callable);
     if (function->shared()->bound()) {
-      RUNTIME_ASSERT(function->function_bindings()->IsFixedArray());
-      Handle<FixedArray> bindings(function->function_bindings());
-      return *isolate->factory()->NewJSArrayWithElements(bindings);
+      RUNTIME_ASSERT(function->function_bindings()->IsBindingsArray());
+      Handle<BindingsArray> bindings(function->function_bindings());
+      return *BindingsArray::CreateRuntimeBindings(bindings);
     }
   }
   return isolate->heap()->undefined_value();
 }
 
 
 RUNTIME_FUNCTION(Runtime_NewObjectFromBound) {
   HandleScope scope(isolate);
   DCHECK(args.length() == 1);
   // First argument is a function to use as a constructor.
   CONVERT_ARG_HANDLE_CHECKED(JSFunction, function, 0);
   RUNTIME_ASSERT(function->shared()->bound());
 
   // The argument is a bound function. Extract its bound arguments
   // and callable.
-  Handle<FixedArray> bound_args =
-      Handle<FixedArray>(FixedArray::cast(function->function_bindings()));
-  int bound_argc = bound_args->length() - JSFunction::kBoundArgumentsStartIndex;
-  Handle<Object> bound_function(
-      JSReceiver::cast(bound_args->get(JSFunction::kBoundFunctionIndex)),
-      isolate);
+  Handle<BindingsArray> bound_args =
+      handle(BindingsArray::cast(function->function_bindings()));
+  int bound_argc = bound_args->bindings_count();
+  Handle<Object> bound_function(bound_args->bound_function(), isolate);
   DCHECK(!bound_function->IsJSFunction() ||
          !Handle<JSFunction>::cast(bound_function)->shared()->bound());
 
   int total_argc = 0;
   base::SmartArrayPointer<Handle<Object>> param_data =
       Runtime::GetCallerArguments(isolate, bound_argc, &total_argc);
   for (int i = 0; i < bound_argc; i++) {
-    param_data[i] = Handle<Object>(
-        bound_args->get(JSFunction::kBoundArgumentsStartIndex + i), isolate);
+    param_data[i] = Handle<Object>(bound_args->binding(i), isolate);

[Igor Sheludko, 2015/10/01 08:03:35]

nit: param_data[i] = handle(bound_args->binding(i), isolate);

[mvstanton, 2015/10/01 11:23:01]

Done.

   }
 
   Handle<Object> result;
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
       isolate, result, Execution::New(isolate, bound_function, bound_function,
                                       total_argc, param_data.get()));
   return *result;
 }
 
 
@@ skipping 113 matching lines @@
 
 
 RUNTIME_FUNCTION(Runtime_ThrowStrongModeTooFewArguments) {
   HandleScope scope(isolate);
   DCHECK(args.length() == 0);
   THROW_NEW_ERROR_RETURN_FAILURE(isolate,
                                  NewTypeError(MessageTemplate::kStrongArity));
 }
 }  // namespace internal
 }  // namespace v8