Rename original constructor to new target

src/runtime/runtime-array.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/arguments.h"
 #include "src/conversions-inl.h"
 #include "src/elements.h"
 #include "src/factory.h"
@@ skipping 217 matching lines @@
   Handle<FixedArray> keys = accumulator.GetKeys(KEEP_NUMBERS);
   for (int i = 0; i < keys->length(); i++) {
     if (NumberToUint32(keys->get(i)) >= length) keys->set_undefined(i);
   }
   return *isolate->factory()->NewJSArrayWithElements(keys);
 }
 
 
 static Object* ArrayConstructorCommon(Isolate* isolate,
                                       Handle<JSFunction> constructor,
-                                      Handle<JSFunction> original_constructor,
+                                      Handle<JSFunction> new_target,
                                       Handle<AllocationSite> site,
                                       Arguments* caller_args) {
   Factory* factory = isolate->factory();
 
   bool holey = false;
   bool can_use_type_feedback = true;
   bool can_inline_array_constructor = true;
   if (caller_args->length() == 1) {
     Handle<Object> argument_one = caller_args->at<Object>(0);
     if (argument_one->IsSmi()) {
@@ skipping 61 matching lines @@
        !can_inline_array_constructor)) {
     // The arguments passed in caused a transition. This kind of complexity
     // can't be dealt with in the inlined hydrogen array constructor case.
     // We must mark the allocationsite as un-inlinable.
     site->SetDoNotInlineCall();
   }
 
   // Set up the prototoype using original function.
   // TODO(dslomov): instead of setting the __proto__,
   // use and cache the correct map.
-  if (*original_constructor != *constructor) {
-    if (original_constructor->has_instance_prototype()) {
-      Handle<Object> prototype =
-          handle(original_constructor->instance_prototype(), isolate);
+  if (*new_target != *constructor) {
+    if (new_target->has_instance_prototype()) {
+      Handle<Object> prototype(new_target->instance_prototype(), isolate);
       MAYBE_RETURN(JSObject::SetPrototype(array, prototype, false,
                                           Object::THROW_ON_ERROR),
                    isolate->heap()->exception());
     }
   }
 
   return *array;
 }
 
 
@@ skipping 36 matching lines @@
   int args_length = args.length();
   CHECK(args_length >= 2);
 
   // This variables and checks work around -Werror=strict-overflow.
   int pre_last_arg_index = args_length - 2;
   int last_arg_index = args_length - 1;
   CHECK(pre_last_arg_index >= 0);
   CHECK(last_arg_index >= 0);
 
   CONVERT_ARG_HANDLE_CHECKED(JSFunction, constructor, pre_last_arg_index);
-  CONVERT_ARG_HANDLE_CHECKED(JSFunction, original_constructor, last_arg_index);
+  CONVERT_ARG_HANDLE_CHECKED(JSFunction, new_target, last_arg_index);
   Arguments caller_args(args_length - 2, args.arguments());
-  return ArrayConstructorCommon(isolate, constructor, original_constructor,
+  return ArrayConstructorCommon(isolate, constructor, new_target,
                                 Handle<AllocationSite>::null(), &caller_args);
 }
 
 
 RUNTIME_FUNCTION(Runtime_InternalArrayConstructor) {
   HandleScope scope(isolate);
   Arguments empty_args(0, NULL);
   bool no_caller_args = args.length() == 1;
   DCHECK(no_caller_args || args.length() == 3);
   int parameters_start = no_caller_args ? 0 : 1;
@@ skipping 100 matching lines @@
 
 RUNTIME_FUNCTION(Runtime_FastOneByteArrayJoin) {
   SealHandleScope shs(isolate);
   DCHECK(args.length() == 2);
   // Returning undefined means that this fast path fails and one has to resort
   // to a slow path.
   return isolate->heap()->undefined_value();
 }
 }  // namespace internal
 }  // namespace v8