Remove "force_initial_map"

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 1215 matching lines @@
 
 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) {
+                                        Handle<Code> code) {
   // Allocate the function
   Handle<JSFunction> function = NewFunction(name, maybe_prototype, code);
 
-  if (force_initial_map ||
+  if (!maybe_prototype.is_null() ||
       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);
     }
     initial_map->set_prototype(*prototype);
     function->set_initial_map(*initial_map);
     initial_map->set_constructor(*function);
   } else {
     ASSERT(!function->has_initial_map());
     ASSERT(!function->has_prototype());
   }
 
   return function;
 }
 
 
 Handle<JSFunction> Factory::NewFunction(Handle<String> name,
                                         InstanceType type,
                                         int instance_size,
-                                        Handle<Code> code,
-                                        bool force_initial_map) {
-  return NewFunction(
-      the_hole_value(), name, type, instance_size, code, force_initial_map);
+                                        Handle<Code> code) {
+  return NewFunction(the_hole_value(), name, type, instance_size, code);
 }
 
 
 Handle<JSObject> Factory::NewFunctionPrototype(Handle<JSFunction> function) {
   // Make sure to use globals from the function's context, since the function
   // can be from a different context.
   Handle<Context> native_context(function->context()->native_context());
   Handle<Map> new_map;
   if (function->shared()->is_generator()) {
     // Generator prototypes can share maps since they don't have "constructor"
@@ skipping 813 matching lines @@
     default:
       UNREACHABLE();
       type = JS_OBJECT_TYPE;  // Keep the compiler happy.
       break;
   }
 
   MaybeHandle<Object> maybe_prototype = prototype;
   if (obj->remove_prototype()) maybe_prototype = MaybeHandle<Object>();
 
   Handle<JSFunction> result = NewFunction(
-      maybe_prototype, Factory::empty_string(), type,
-      instance_size, code, !obj->remove_prototype());
+      maybe_prototype, Factory::empty_string(), type, instance_size, code);
 
   result->shared()->set_length(obj->length());
   Handle<Object> class_name(obj->class_name(), isolate());
   if (class_name->IsString()) {
     result->shared()->set_instance_class_name(*class_name);
     result->shared()->set_name(*class_name);
   }
   result->shared()->set_function_data(*obj);
   result->shared()->set_construct_stub(*construct_stub);
   result->shared()->DontAdaptArguments();
@@ skipping 206 matching lines @@
   return Handle<Object>::null();
 }
 
 
 Handle<Object> Factory::ToBoolean(bool value) {
   return value ? true_value() : false_value();
 }
 
 
 } }  // namespace v8::internal