Introduce a BuiltinsConstructStub that sets up new.target and does a [[call]] per ES6 9.3.2

src/bootstrapper.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 "src/bootstrapper.h"
 
 #include "src/accessors.h"
 #include "src/api-natives.h"
 #include "src/code-stubs.h"
 #include "src/extensions/externalize-string-extension.h"
@@ skipping 1084 matching lines @@
       global_object, object_name, isolate->object_function(), DONT_ENUM);
 
   Handle<JSObject> global(native_context()->global_object());
 
   // Install global Function object
   Handle<JSFunction> function_function =
       InstallFunction(global, "Function", JS_FUNCTION_TYPE, JSFunction::kSize,
                       empty_function, Builtins::kIllegal);
   function_function->initial_map()->set_is_callable();
   function_function->initial_map()->set_is_constructor(true);
+  function_function->shared()->set_construct_stub(
+      isolate->builtins()->builtin(Builtins::kJSBuiltinsConstructStub));
 
   {  // --- A r r a y ---
     Handle<JSFunction> array_function =
         InstallFunction(global, "Array", JS_ARRAY_TYPE, JSArray::kSize,
                         isolate->initial_object_prototype(),
                         Builtins::kArrayCode);
     array_function->shared()->DontAdaptArguments();
     array_function->shared()->set_function_data(Smi::FromInt(kArrayCode));
 
     // This seems a bit hackish, but we need to make sure Array.length
@@ skipping 36 matching lines @@
     initial_strong_map->set_is_strong();
     CacheInitialJSArrayMaps(native_context(), initial_strong_map);
   }
 
   {  // --- N u m b e r ---
     Handle<JSFunction> number_fun =
         InstallFunction(global, "Number", JS_VALUE_TYPE, JSValue::kSize,
                         isolate->initial_object_prototype(),
                         Builtins::kIllegal);
     native_context()->set_number_function(*number_fun);
+    number_fun->shared()->set_construct_stub(
+        isolate->builtins()->builtin(Builtins::kJSBuiltinsConstructStub));
   }
 
   {  // --- B o o l e a n ---
     Handle<JSFunction> boolean_fun =
         InstallFunction(global, "Boolean", JS_VALUE_TYPE, JSValue::kSize,
                         isolate->initial_object_prototype(),
                         Builtins::kIllegal);
     native_context()->set_boolean_function(*boolean_fun);
   }
 
@@ skipping 30 matching lines @@
         isolate->initial_object_prototype(), Builtins::kSymbolConstructor);
     symbol_fun->shared()->set_construct_stub(isolate->builtins()->builtin(
         Builtins::kSymbolConstructor_ConstructStub));
     symbol_fun->shared()->set_internal_formal_parameter_count(1);
     symbol_fun->shared()->set_length(1);
     native_context()->set_symbol_function(*symbol_fun);
   }
 
   {  // --- D a t e ---
     // Builtin functions for Date.prototype.
-    InstallFunction(global, "Date", JS_DATE_TYPE, JSDate::kSize,
-                    isolate->initial_object_prototype(), Builtins::kIllegal);
+    Handle<JSFunction> date_fun = InstallFunction(
+        global, "Date", JS_DATE_TYPE, JSDate::kSize,
+        isolate->initial_object_prototype(), Builtins::kIllegal);
+    date_fun->shared()->set_construct_stub(
+        isolate->builtins()->builtin(Builtins::kJSBuiltinsConstructStub));
   }
 
   {  // -- R e g E x p
     // Builtin functions for RegExp.prototype.
     Handle<JSFunction> regexp_fun =
         InstallFunction(global, "RegExp", JS_REGEXP_TYPE, JSRegExp::kSize,
                         isolate->initial_object_prototype(),
                         Builtins::kIllegal);
     native_context()->set_regexp_function(*regexp_fun);
 
@@ skipping 611 matching lines @@
         container, factory->InternalizeUtf8String("GeneratorFunctionPrototype"),
         generator_function_prototype, NONE);
 
     static const bool kUseStrictFunctionMap = true;
     Handle<JSFunction> generator_function_function =
         InstallFunction(container, "GeneratorFunction", JS_FUNCTION_TYPE,
                         JSFunction::kSize, generator_function_prototype,
                         Builtins::kIllegal, kUseStrictFunctionMap);
     generator_function_function->initial_map()->set_is_callable();
     generator_function_function->initial_map()->set_is_constructor(true);
+    generator_function_function->shared()->set_construct_stub(
+        isolate->builtins()->builtin(Builtins::kJSBuiltinsConstructStub));
   }
 
   {  // -- S e t I t e r a t o r
     Handle<JSObject> set_iterator_prototype =
         isolate->factory()->NewJSObject(isolate->object_function(), TENURED);
     SetObjectPrototype(set_iterator_prototype, iterator_prototype);
     Handle<JSFunction> set_iterator_function = InstallFunction(
         container, "SetIterator", JS_SET_ITERATOR_TYPE, JSSetIterator::kSize,
         set_iterator_prototype, Builtins::kIllegal);
     native_context->set_set_iterator_map(set_iterator_function->initial_map());
@@ skipping 330 matching lines @@
   SIMD128_TYPES(SIMD128_INSTALL_FUNCTION)
 #undef SIMD128_INSTALL_FUNCTION
 }
 
 
 void Genesis::InitializeGlobal_harmony_proxies() {
   if (!FLAG_harmony_proxies) return;
   Handle<JSGlobalObject> global(
       JSGlobalObject::cast(native_context()->global_object()));
   Isolate* isolate = global->GetIsolate();
-  InstallFunction(global, "Proxy", JS_PROXY_TYPE, JSProxy::kSize,
-                  isolate->initial_object_prototype(), Builtins::kIllegal);
+  Handle<JSFunction> proxy_fun =
+      InstallFunction(global, "Proxy", JS_PROXY_TYPE, JSProxy::kSize,
+                      isolate->initial_object_prototype(), Builtins::kIllegal);
+  // TODO(verwaest): Set to null in InstallFunction.
+  proxy_fun->initial_map()->set_prototype(isolate->heap()->null_value());
+  proxy_fun->shared()->set_construct_stub(
+      isolate->builtins()->builtin(Builtins::kJSBuiltinsConstructStub));
+  native_context()->set_proxy_function(*proxy_fun);
 }
 
 
 Handle<JSFunction> Genesis::InstallInternalArray(Handle<JSObject> target,
                                                  const char* name,
                                                  ElementsKind elements_kind) {
   // --- I n t e r n a l   A r r a y ---
   // An array constructor on the builtins object that works like
   // the public Array constructor, except that its prototype
   // doesn't inherit from Object.prototype.
@@ skipping 225 matching lines @@
     DCHECK(call->is_compiled());
 
     // Set the expected parameters for apply to 2; required by builtin.
     apply->shared()->set_internal_formal_parameter_count(2);
 
     // Set the lengths for the functions to satisfy ECMA-262.
     call->shared()->set_length(1);
     apply->shared()->set_length(2);
   }
 
+  // Set up the Promise constructor.
+  {
+    Handle<String> key = factory()->Promise_string();
+    Handle<JSFunction> function = Handle<JSFunction>::cast(
+        Object::GetProperty(handle(native_context()->global_object()), key)
+            .ToHandleChecked());
+    JSFunction::EnsureHasInitialMap(function);
+    function->initial_map()->set_instance_type(JS_PROMISE_TYPE);
+    function->shared()->set_construct_stub(
+        isolate()->builtins()->builtin(Builtins::kJSBuiltinsConstructStub));
+  }
+
   InstallBuiltinFunctionIds();
 
   // Create a constructor for RegExp results (a variant of Array that
   // predefines the two properties index and match).
   {
     // RegExpResult initial map.
 
     // Find global.Array.prototype to inherit from.
     Handle<JSFunction> array_constructor(native_context()->array_function());
     Handle<JSObject> array_prototype(
@@ skipping 793 matching lines @@
 }
 
 
 // Called when the top-level V8 mutex is destroyed.
 void Bootstrapper::FreeThreadResources() {
   DCHECK(!IsActive());
 }
 
 }  // namespace internal
 }  // namespace v8