[builtins] Remove bunch of uses of %_Arguments and %_ArgumentsLength.

src/accessors.cc

 // Copyright 2012 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/accessors.h"
 
 #include "src/api.h"
 #include "src/contexts.h"
 #include "src/deoptimizer.h"
 #include "src/execution.h"
@@ skipping 926 matching lines @@
   DisallowHeapAllocation no_allocation;
   List<JSFunction*> functions(2);
   frame->GetFunctions(&functions);
   for (int i = functions.length() - 1; i >= 0; i--) {
     if (functions[i] == *function) return i;
   }
   return -1;
 }
 
 
+namespace {
+
 Handle<Object> GetFunctionArguments(Isolate* isolate,
                                     Handle<JSFunction> function) {
-  if (function->shared()->native()) return isolate->factory()->null_value();
-
   // Find the top invocation of the function by traversing frames.
   for (JavaScriptFrameIterator it(isolate); !it.done(); it.Advance()) {
     JavaScriptFrame* frame = it.frame();
     int function_index = FindFunctionInFrame(frame, function);
     if (function_index < 0) continue;
 
     if (function_index > 0) {
       // The function in question was inlined.  Inlined functions have the
       // correct number of arguments and no allocated arguments object, so
       // we can construct a fresh one by interpreting the function's
@@ skipping 18 matching lines @@
     arguments->set_elements(*array);
 
     // Return the freshly allocated arguments object.
     return arguments;
   }
 
   // No frame corresponding to the given function found. Return null.
   return isolate->factory()->null_value();
 }
 
+}  // namespace
 
-Handle<Object> Accessors::FunctionGetArguments(Handle<JSFunction> function) {
-  return GetFunctionArguments(function->GetIsolate(), function);
+
+Handle<JSObject> Accessors::FunctionGetArguments(Handle<JSFunction> function) {
+  Handle<Object> arguments =
+      GetFunctionArguments(function->GetIsolate(), function);
+  CHECK(arguments->IsJSObject());
+  return Handle<JSObject>::cast(arguments);
 }
 
 
 void Accessors::FunctionArgumentsGetter(
     v8::Local<v8::Name> name,
     const v8::PropertyCallbackInfo<v8::Value>& info) {
   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(info.GetIsolate());
   HandleScope scope(isolate);
   Handle<JSFunction> function =
       Handle<JSFunction>::cast(Utils::OpenHandle(*info.Holder()));
-  Handle<Object> result = GetFunctionArguments(isolate, function);
+  Handle<Object> result =
+      function->shared()->native()
+          ? Handle<Object>::cast(isolate->factory()->null_value())
+          : GetFunctionArguments(isolate, function);
   info.GetReturnValue().Set(Utils::ToLocal(result));
 }
 
 
 Handle<AccessorInfo> Accessors::FunctionArgumentsInfo(
       Isolate* isolate, PropertyAttributes attributes) {
   return MakeAccessor(isolate, isolate->factory()->arguments_string(),
                       &FunctionArgumentsGetter, nullptr, attributes);
 }
 
@@ skipping 184 matching lines @@
   Isolate* isolate = name->GetIsolate();
   Handle<AccessorInfo> info = MakeAccessor(isolate, name, &ModuleGetExport,
                                            &ModuleSetExport, attributes);
   info->set_data(Smi::FromInt(index));
   return info;
 }
 
 
 }  // namespace internal
 }  // namespace v8