Replace NewFunctionWithPrototype(name, prototype) by NewFunction(name)

src/factory.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 "factory.h"
 
 #include "conversions.h"
 #include "isolate-inl.h"
 #include "macro-assembler.h"
 
@@ skipping 1185 matching lines @@
                                         Handle<Context> context,
                                         PretenureFlag pretenure) {
   AllocationSpace space = pretenure == TENURED ? OLD_POINTER_SPACE : NEW_SPACE;
   Handle<JSFunction> result = New<JSFunction>(map, space);
   InitializeFunction(result, info, context);
   return result;
 }
 
 
 Handle<JSFunction> Factory::NewFunction(Handle<String> name,
-                                        Handle<Code> code,
-                                        MaybeHandle<Object> maybe_prototype) {
+                                        MaybeHandle<Object> maybe_prototype,
+                                        MaybeHandle<Code> maybe_code) {
   Handle<SharedFunctionInfo> info = NewSharedFunctionInfo(name);
   ASSERT(info->strict_mode() == SLOPPY);
-  info->set_code(*code);
+  Handle<Code> code;
+  if (maybe_code.ToHandle(&code)) {
+    info->set_code(*code);
+  }
   Handle<Context> context(isolate()->context()->native_context());
   Handle<Map> map = maybe_prototype.is_null()
       ? isolate()->sloppy_function_without_prototype_map()
       : isolate()->sloppy_function_map();
   Handle<JSFunction> result = NewFunction(map, info, context);
   Handle<Object> prototype;
   if (maybe_prototype.ToHandle(&prototype)) {
     result->set_prototype_or_initial_map(*prototype);
   }
   return result;
 }
 
 
-Handle<JSFunction> Factory::NewFunctionWithPrototype(Handle<String> name,
-                                                     Handle<Object> prototype) {
-  Handle<SharedFunctionInfo> info = NewSharedFunctionInfo(name);
-  ASSERT(info->strict_mode() == SLOPPY);
-  Handle<Context> context(isolate()->context()->native_context());
-  Handle<Map> map = isolate()->sloppy_function_map();
-  Handle<JSFunction> result = NewFunction(map, info, context);
-  result->set_prototype_or_initial_map(*prototype);
-  return result;
+Handle<JSFunction> Factory::NewFunction(Handle<String> name) {
+  return NewFunction(name, the_hole_value(), MaybeHandle<Code>());
 }
 
 
 Handle<JSFunction> Factory::NewFunction(MaybeHandle<Object> maybe_prototype,
                                         Handle<String> name,
                                         InstanceType type,
                                         int instance_size,
                                         Handle<Code> code,
                                         bool force_initial_map) {
   // Allocate the function
-  Handle<JSFunction> function = NewFunction(name, code, maybe_prototype);
+  Handle<JSFunction> function = NewFunction(name, maybe_prototype, code);
 
   if (force_initial_map ||
       type != JS_OBJECT_TYPE ||
       instance_size != JSObject::kHeaderSize) {
     Handle<Object> prototype = maybe_prototype.ToHandleChecked();
     Handle<Map> initial_map = NewMap(
         type, instance_size, GetInitialFastElementsKind());
     if (prototype->IsTheHole() && !function->shared()->is_generator()) {
       prototype = NewFunctionPrototype(function);
     }
@@ skipping 1070 matching lines @@
   return Handle<Object>::null();
 }
 
 
 Handle<Object> Factory::ToBoolean(bool value) {
   return value ? true_value() : false_value();
 }
 
 
 } }  // namespace v8::internal