Revert of [runtime] Introduce dedicated JSBoundFunction to represent bound functions.

src/runtime/runtime-debug.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/debug/debug.h"
 #include "src/debug/debug-evaluate.h"
 #include "src/debug/debug-frames.h"
@@ skipping 132 matching lines @@
   result->set(4, *iterator_kind);
   Handle<String> kind_str = factory->NewStringFromAsciiChecked(kind);
   result->set(5, *kind_str);
   return factory->NewJSArrayWithElements(result);
 }
 
 
 MaybeHandle<JSArray> Runtime::GetInternalProperties(Isolate* isolate,
                                                     Handle<Object> object) {
   Factory* factory = isolate->factory();
-  if (object->IsJSBoundFunction()) {
-    Handle<JSBoundFunction> function = Handle<JSBoundFunction>::cast(object);
+  if (object->IsJSFunction()) {
+    Handle<JSFunction> function = Handle<JSFunction>::cast(object);
+    if (function->shared()->bound()) {
+      RUNTIME_ASSERT_HANDLIFIED(function->function_bindings()->IsFixedArray(),
+                                JSArray);
 
-    Handle<FixedArray> result = factory->NewFixedArray(2 * 3);
-    Handle<String> target =
-        factory->NewStringFromAsciiChecked("[[TargetFunction]]");
-    result->set(0, *target);
-    result->set(1, function->bound_target_function());
+      Handle<BindingsArray> bindings(function->function_bindings());
 
-    Handle<String> bound_this =
-        factory->NewStringFromAsciiChecked("[[BoundThis]]");
-    result->set(2, *bound_this);
-    result->set(3, function->bound_this());
+      Handle<FixedArray> result = factory->NewFixedArray(2 * 3);
+      Handle<String> target =
+          factory->NewStringFromAsciiChecked("[[TargetFunction]]");
+      result->set(0, *target);
+      result->set(1, bindings->bound_function());
 
-    Handle<String> bound_args =
-        factory->NewStringFromAsciiChecked("[[BoundArgs]]");
-    result->set(4, *bound_args);
-    Handle<FixedArray> bound_arguments =
-        factory->CopyFixedArray(handle(function->bound_arguments(), isolate));
-    Handle<JSArray> arguments_array =
-        factory->NewJSArrayWithElements(bound_arguments);
-    result->set(5, *arguments_array);
-    return factory->NewJSArrayWithElements(result);
+      Handle<String> bound_this =
+          factory->NewStringFromAsciiChecked("[[BoundThis]]");
+      result->set(2, *bound_this);
+      result->set(3, bindings->bound_this());
+
+      Handle<String> bound_args =
+          factory->NewStringFromAsciiChecked("[[BoundArgs]]");
+      result->set(4, *bound_args);
+      Handle<JSArray> arguments_array =
+          BindingsArray::CreateBoundArguments(bindings);
+      result->set(5, *arguments_array);
+      return factory->NewJSArrayWithElements(result);
+    }
   } else if (object->IsJSMapIterator()) {
     Handle<JSMapIterator> iterator = Handle<JSMapIterator>::cast(object);
     return GetIteratorInternalProperties(isolate, iterator);
   } else if (object->IsJSSetIterator()) {
     Handle<JSSetIterator> iterator = Handle<JSSetIterator>::cast(object);
     return GetIteratorInternalProperties(isolate, iterator);
   } else if (object->IsJSGeneratorObject()) {
     Handle<JSGeneratorObject> generator =
         Handle<JSGeneratorObject>::cast(object);
 
@@ skipping 676 matching lines @@
   Handle<FixedArray> array = isolate->factory()->NewFixedArray(result.length());
   for (int i = 0; i < result.length(); ++i) {
     array->set(i, *result[i]);
   }
   return *isolate->factory()->NewJSArrayWithElements(array);
 }
 
 
 RUNTIME_FUNCTION(Runtime_GetFunctionScopeCount) {
   HandleScope scope(isolate);
-  DCHECK_EQ(1, args.length());
+  DCHECK(args.length() == 1);
 
   // Check arguments.
-  CONVERT_ARG_HANDLE_CHECKED(JSReceiver, function, 0);
+  CONVERT_ARG_HANDLE_CHECKED(JSFunction, fun, 0);
 
   // Count the visible scopes.
   int n = 0;
-  if (function->IsJSFunction()) {
-    for (ScopeIterator it(isolate, Handle<JSFunction>::cast(function));
-         !it.Done(); it.Next()) {
-      n++;
-    }
+  for (ScopeIterator it(isolate, fun); !it.Done(); it.Next()) {
+    n++;
   }
 
   return Smi::FromInt(n);
 }
 
 
 RUNTIME_FUNCTION(Runtime_GetFunctionScopeDetails) {
   HandleScope scope(isolate);
   DCHECK(args.length() == 2);
 
@@ skipping 566 matching lines @@
   int compilation_state = script->compilation_state();
   RUNTIME_ASSERT(compilation_state == Script::COMPILATION_STATE_INITIAL);
   script->set_source(*source);
 
   return isolate->heap()->undefined_value();
 }
 
 
 RUNTIME_FUNCTION(Runtime_FunctionGetInferredName) {
   SealHandleScope shs(isolate);
-  DCHECK_EQ(1, args.length());
+  DCHECK(args.length() == 1);
 
-  CONVERT_ARG_CHECKED(Object, f, 0);
-  if (f->IsJSFunction()) {
-    return JSFunction::cast(f)->shared()->inferred_name();
-  }
-  return isolate->heap()->empty_string();
+  CONVERT_ARG_CHECKED(JSFunction, f, 0);
+  return f->shared()->inferred_name();
 }
 
 
 RUNTIME_FUNCTION(Runtime_FunctionGetDebugName) {
   HandleScope scope(isolate);
-  DCHECK_EQ(1, args.length());
+  DCHECK(args.length() == 1);
 
-  CONVERT_ARG_HANDLE_CHECKED(JSReceiver, function, 0);
-
-  if (function->IsJSBoundFunction()) {
-    return Handle<JSBoundFunction>::cast(function)->name();
-  }
-  Handle<Object> name =
-      JSFunction::GetDebugName(Handle<JSFunction>::cast(function));
+  CONVERT_ARG_HANDLE_CHECKED(JSFunction, f, 0);
+  Handle<Object> name = JSFunction::GetDebugName(f);
   return *name;
 }
 
 
 // A testing entry. Returns statement position which is the closest to
 // source_position.
 RUNTIME_FUNCTION(Runtime_GetFunctionCodePositionFromSource) {
   HandleScope scope(isolate);
   CHECK(isolate->debug()->live_edit_enabled());
   DCHECK(args.length() == 2);
@@ skipping 186 matching lines @@
   return Smi::FromInt(isolate->debug()->is_active());
 }
 
 
 RUNTIME_FUNCTION(Runtime_DebugBreakInOptimizedCode) {
   UNIMPLEMENTED();
   return NULL;
 }
 }  // namespace internal
 }  // namespace v8