Implement Function.prototype.toMethod.

src/objects.cc

 // Copyright 2013 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/v8.h"
 
 #include "src/accessors.h"
 #include "src/allocation-site-scopes.h"
 #include "src/api.h"
 #include "src/arguments.h"
@@ skipping 9378 matching lines @@
     PrintF("  ** Queueing ");
     PrintName();
     PrintF(" for concurrent recompilation.\n");
   }
   set_code_no_write_barrier(
       GetIsolate()->builtins()->builtin(Builtins::kInOptimizationQueue));
   // No write barrier required, since the builtin is part of the root set.
 }
 
 
+Handle<JSFunction> JSFunction::Copy(Handle<JSFunction> function) {
+  Isolate* isolate = function->GetIsolate();
+  Handle<Map> map(function->map());
+  Handle<SharedFunctionInfo> shared(function->shared());
+  Handle<Context> context(function->context());
+  Handle<JSFunction> clone =
+    isolate->factory()->NewFunctionWithMapFromSharedFunctionInfo(
+        map, shared, context);
+
+  if (shared->bound()) {
+    clone->set_function_bindings(function->function_bindings());
+  }
+
+  clone->set_properties(

[arv (Not doing code reviews), 2014/08/20 15:35:53]

For F.p.toMethod we should not copy the properties. However if we use private
own property for the [[HomeObject]] we need to at least handle that.

+      *isolate->factory()->NewFixedArray(function->properties()->length()));
+
+  Handle<FixedArrayBase> original_elements(function->elements());

[Toon Verwaest, 2014/08/20 07:43:11]

Use the ElementsAccessor Copy method instead.

+  if (original_elements->length() > 0) {
+    if (original_elements->IsFixedArray()) {
+      clone->set_elements(*isolate->factory()->CopyFixedArray(
+            Handle<FixedArray>::cast(original_elements)));
+    } else if (original_elements->IsFixedDoubleArray()) {
+      clone->set_elements(*isolate->factory()->CopyFixedDoubleArray(
+            Handle<FixedDoubleArray>::cast(original_elements)));
+    } else {
+      CHECK(false);
+    }
+  }
+
+
+  Handle<DescriptorArray> descriptors(map->instance_descriptors());
+  for (int i = 0; i < map->NumberOfOwnDescriptors(); i++) {
+    Handle<Name> name(descriptors->GetKey(i));
+    PropertyDetails details(descriptors->GetDetails(i));
+    if (details.type() == NORMAL || details.type() == FIELD) {

[Toon Verwaest, 2014/08/20 07:43:11]

NORMAL is not a valid entry for descriptors. Only FIELD needs to be copied.
We should better separate those ...

That also indicates though that if your function is in dictionary mode, you
don't copy anything from the backing store. Hence you'll lose all your
properties. For fast mode you copy them. Please add a test that normalizes the
function before binding. (The runtime function to turn something into dictionary
mode is called %OptimizeObjectForAddingMultipleProperties).

What about having separate methods to copy named and indexed properties,
extracted from the regular object copying mechanism?

+      Handle<Object> value =
+        Object::GetProperty(function, name).ToHandleChecked();
+      JSObject::SetOwnPropertyIgnoreAttributes(
+          clone,
+          name,
+          value,
+          details.attributes()).Assert();
+    }
+  }
+  return clone;
+}
+
+
 void SharedFunctionInfo::AddToOptimizedCodeMap(
     Handle<SharedFunctionInfo> shared,
     Handle<Context> native_context,
     Handle<Code> code,
     Handle<FixedArray> literals,
     BailoutId osr_ast_id) {
   Isolate* isolate = shared->GetIsolate();
   DCHECK(code->kind() == Code::OPTIMIZED_FUNCTION);
   DCHECK(native_context->IsNativeContext());
   STATIC_ASSERT(kEntryLength == 4);
@@ skipping 7250 matching lines @@
 #define ERROR_MESSAGES_TEXTS(C, T) T,
   static const char* error_messages_[] = {
       ERROR_MESSAGES_LIST(ERROR_MESSAGES_TEXTS)
   };
 #undef ERROR_MESSAGES_TEXTS
   return error_messages_[reason];
 }
 
 
 } }  // namespace v8::internal