Add an API to create a detached global object

src/api-natives.cc

 // Copyright 2015 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/api-natives.h"
 
 #include "src/api.h"
 #include "src/isolate-inl.h"
 #include "src/lookup.h"
 #include "src/messages.h"
@@ skipping 521 matching lines @@
   NeanderArray array(list);
   array.add(isolate, property);
 }
 
 
 Handle<JSFunction> ApiNatives::CreateApiFunction(
     Isolate* isolate, Handle<FunctionTemplateInfo> obj,
     Handle<Object> prototype, ApiInstanceType instance_type) {
   Handle<SharedFunctionInfo> shared =
       FunctionTemplateInfo::GetOrCreateSharedFunctionInfo(isolate, obj);
+  int map_index =
+      Context::FunctionMapIndex(shared->language_mode(), shared->kind());
+  Handle<Map> initial_map(Map::cast(isolate->native_context()->get(map_index)));
+  return CreateApiFunctionWithMap(isolate, isolate->native_context(), obj,
+                                  initial_map, prototype, instance_type);
+}
+
+Handle<JSFunction> ApiNatives::CreateApiFunctionWithMap(

[Toon Verwaest, 2016/06/30 14:46:17]

I'd prefer it if you wouldn't reuse this function. By passing in the map you'd
expect any combination to work, which won't.

Rather just manually create the shared function info, the function and its
initial-map with JS_GLOBAL_PROXY_TYPE in straightline simple code that's obvious
to read. Then you don't need the context_or_undefined hack below for example.

+    Isolate* isolate, Handle<Object> context_or_undefined,
+    Handle<FunctionTemplateInfo> obj, Handle<Map> initial_map,
+    Handle<Object> prototype, ApiInstanceType instance_type) {
+  Handle<SharedFunctionInfo> shared =
+      FunctionTemplateInfo::GetOrCreateSharedFunctionInfo(isolate, obj);
   Handle<JSFunction> result =
       isolate->factory()->NewFunctionFromSharedFunctionInfo(
-          shared, isolate->native_context());
+          initial_map, shared, context_or_undefined);
 
   if (obj->remove_prototype()) {
     result->set_map(*isolate->sloppy_function_without_prototype_map());
     DCHECK(prototype.is_null());
     DCHECK(result->shared()->IsApiFunction());
     DCHECK(!result->has_initial_map());
     DCHECK(!result->has_prototype());
     DCHECK(!result->IsConstructor());
     return result;
   }
 
   // Down from here is only valid for API functions that can be used as a
   // constructor (don't set the "remove prototype" flag).
 
   if (obj->read_only_prototype()) {
     result->set_map(*isolate->sloppy_function_with_readonly_prototype_map());
   }
 
-  if (prototype->IsTheHole(isolate)) {
-    prototype = isolate->factory()->NewFunctionPrototype(result);
+  if (context_or_undefined->IsContext()) {
+    if (prototype->IsTheHole(isolate)) {
+      prototype = isolate->factory()->NewFunctionPrototype(result);
+    } else {
+      JSObject::AddProperty(Handle<JSObject>::cast(prototype),
+                            isolate->factory()->constructor_string(), result,
+                            DONT_ENUM);
+    }
   } else {
-    JSObject::AddProperty(Handle<JSObject>::cast(prototype),
-                          isolate->factory()->constructor_string(), result,
-                          DONT_ENUM);
+    prototype = isolate->factory()->null_value();
   }
 
   int internal_field_count = 0;
   if (!obj->instance_template()->IsUndefined(isolate)) {
     Handle<ObjectTemplateInfo> instance_template = Handle<ObjectTemplateInfo>(
         ObjectTemplateInfo::cast(obj->instance_template()));
     internal_field_count =
         Smi::cast(instance_template->internal_field_count())->value();
   }
 
@@ skipping 21 matching lines @@
       instance_size += JSGlobalProxy::kSize;
       break;
     default:
       UNREACHABLE();
       type = JS_OBJECT_TYPE;  // Keep the compiler happy.
       break;
   }
 
   Handle<Map> map =
       isolate->factory()->NewMap(type, instance_size, FAST_HOLEY_SMI_ELEMENTS);
-  JSFunction::SetInitialMap(result, map, Handle<JSObject>::cast(prototype));
+  JSFunction::SetInitialMap(result, map, prototype);
 
   // Mark as undetectable if needed.
   if (obj->undetectable()) {
     map->set_is_undetectable();
   }
 
   // Mark as needs_access_check if needed.
   if (obj->needs_access_check()) {
     map->set_is_access_check_needed(true);
   }
@@ skipping 10 matching lines @@
   if (!obj->instance_call_handler()->IsUndefined(isolate)) {
     map->set_is_callable();
     map->set_is_constructor(true);
   }
 
   return result;
 }
 
 }  // namespace internal
 }  // namespace v8