[promises] Move promise constructor to TFS

src/js/promise.js

 // Copyright 2012 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.
 
 (function(global, utils, extrasUtils) {
 
 "use strict";
 
 %CheckIsBootstrapping();
 
@@ skipping 17 matching lines @@
     utils.ImportNow("promise_deferred_reaction_symbol");
 var promiseHandledHintSymbol =
     utils.ImportNow("promise_handled_hint_symbol");
 var promiseRawSymbol = utils.ImportNow("promise_raw_symbol");
 var promiseStateSymbol = utils.ImportNow("promise_state_symbol");
 var promiseResultSymbol = utils.ImportNow("promise_result_symbol");
 var SpeciesConstructor;
 var speciesSymbol = utils.ImportNow("species_symbol");
 var toStringTagSymbol = utils.ImportNow("to_string_tag_symbol");
 var ObjectHasOwnProperty;
+var GlobalPromise = global.Promise;
 
 utils.Import(function(from) {
   ObjectHasOwnProperty = from.ObjectHasOwnProperty;
   SpeciesConstructor = from.SpeciesConstructor;
 });
 
 // -------------------------------------------------------------------
 
 // [[PromiseState]] values:
 // These values should be kept in sync with PromiseStatus in globals.h
 const kPending = 0;
 const kFulfilled = +1;
 const kRejected = +2;
 
 const kResolveCallback = 0;
 const kRejectCallback = 1;
 
-// ES#sec-promise-executor
-// Promise ( executor )
-var GlobalPromise = function Promise(executor) {
-  if (executor === promiseRawSymbol) {
-    return %_NewObject(GlobalPromise, new.target);
-  }
-  if (IS_UNDEFINED(new.target)) throw %make_type_error(kNotAPromise, this);
-  if (!IS_CALLABLE(executor)) {
-    throw %make_type_error(kResolverNotAFunction, executor);
-  }
-
-  var promise = PromiseInit(%_NewObject(GlobalPromise, new.target));
-  // Calling the reject function would be a new exception, so debugEvent = true
-  // TODO(gsathya): Remove container for callbacks when this is moved
-  // to CPP/TF.
-  var callbacks = %create_resolving_functions(promise, true);
-  var debug_is_active = DEBUG_IS_ACTIVE;
-  try {
-    if (debug_is_active) %DebugPushPromise(promise);
-    executor(callbacks[kResolveCallback], callbacks[kRejectCallback]);
-  } %catch (e) {  // Natives syntax to mark this catch block.
-    %_Call(callbacks[kRejectCallback], UNDEFINED, e);
-  } finally {
-    if (debug_is_active) %DebugPopPromise();
-  }
-
-  return promise;
-}
-
 // Core functionality.
 
 function PromiseSet(promise, status, value) {
   SET_PRIVATE(promise, promiseStateSymbol, status);
   SET_PRIVATE(promise, promiseResultSymbol, value);
 
   // There are 3 possible states for the resolve, reject symbols when we add
   // a new callback --
   // 1) UNDEFINED -- This is the zero state where there is no callback
   // registered. When we see this state, we directly attach the callbacks to
   // the symbol.
   // 2) !IS_ARRAY -- There is a single callback directly attached to the
   // symbols. We need to create a new array to store additional callbacks.
   // 3) IS_ARRAY -- There are multiple callbacks already registered,
   // therefore we can just push the new callback to the existing array.
   SET_PRIVATE(promise, promiseFulfillReactionsSymbol, UNDEFINED);
   SET_PRIVATE(promise, promiseRejectReactionsSymbol, UNDEFINED);
 
   // This symbol is used only when one deferred needs to be attached. When more
   // than one deferred need to be attached the promise, we attach them directly
   // to the promiseFulfillReactionsSymbol and promiseRejectReactionsSymbol and
   // reset this back to UNDEFINED.
   SET_PRIVATE(promise, promiseDeferredReactionSymbol, UNDEFINED);
 
   return promise;
 }
 
 function PromiseCreateAndSet(status, value) {
-  var promise = new GlobalPromise(promiseRawSymbol);
+  var promise = %promise_internal_constructor();
   // If debug is active, notify about the newly created promise first.
   if (DEBUG_IS_ACTIVE) PromiseSet(promise, kPending, UNDEFINED);
   return PromiseSet(promise, status, value);
 }
 
 function PromiseInit(promise) {
   return PromiseSet(promise, kPending, UNDEFINED);
 }
 
 function PromiseHandle(value, handler, deferred) {
@@ skipping 78 matching lines @@
 
 function PromiseIdResolveHandler(x) { return x; }
 function PromiseIdRejectHandler(r) { %_ReThrow(r); }
 SET_PRIVATE(PromiseIdRejectHandler, promiseForwardingHandlerSymbol, true);
 
 // -------------------------------------------------------------------
 // Define exported functions.
 
 // For bootstrapper.
 
+// Only used by utils
 // ES#sec-ispromise IsPromise ( x )
 function IsPromise(x) {
   return IS_RECEIVER(x) && HAS_DEFINED_PRIVATE(x, promiseStateSymbol);
 }
 
 function PromiseCreate() {
-  return PromiseInit(new GlobalPromise(promiseRawSymbol));
+  return PromiseInit(%promise_internal_constructor());
 }
 
 // ES#sec-promise-resolve-functions
 // Promise Resolve Functions, steps 6-13
 function ResolvePromise(promise, resolution) {
   if (resolution === promise) {
     var exception = %make_type_error(kPromiseCyclic, resolution);
     %PromiseReject(promise, exception, true);
     PromiseSet(promise, kRejected, exception);
     return;
@@ skipping 150 matching lines @@
 
   // Mark this promise as having handler.
   SET_PRIVATE(promise, promiseHasHandlerSymbol, true);
   return resultCapability.promise;
 }
 
 // ES#sec-promise.prototype.then
 // Promise.prototype.then ( onFulfilled, onRejected )
 // Multi-unwrapped chaining with thenable coercion.
 function PromiseThen(onResolve, onReject) {
-  var status = GET_PRIVATE(this, promiseStateSymbol);
-  if (IS_UNDEFINED(status)) {
+  if (!IsPromise(this)) {
     throw %make_type_error(kNotAPromise, this);
   }
 
   var constructor = SpeciesConstructor(this, GlobalPromise);
   var resultCapability;
   if (constructor === GlobalPromise) {
     resultCapability = CreateInternalPromiseCapability();
   } else {
     // Pass false for debugEvent so .then chaining does not trigger
     // redundant ExceptionEvents.
@@ skipping 194 matching lines @@
 }
 
 
 function PromiseSpecies() {
   return this;
 }
 
 // -------------------------------------------------------------------
 // Install exported functions.
 
-%AddNamedProperty(global, 'Promise', GlobalPromise, DONT_ENUM);
-%AddNamedProperty(GlobalPromise.prototype, toStringTagSymbol, "Promise",
-                  DONT_ENUM | READ_ONLY);
-
 utils.InstallFunctions(GlobalPromise, DONT_ENUM, [
   "reject", PromiseReject,
   "all", PromiseAll,
   "race", PromiseRace,
   "resolve", PromiseResolve
 ]);
 
 utils.InstallGetter(GlobalPromise, speciesSymbol, PromiseSpecies);
 
 utils.InstallFunctions(GlobalPromise.prototype, DONT_ENUM, [
@@ skipping 29 matching lines @@
   to.PromiseCreate = PromiseCreate;
   to.PromiseThen = PromiseThen;
 
   to.CreateInternalPromiseCapability = CreateInternalPromiseCapability;
   to.PerformPromiseThen = PerformPromiseThen;
   to.ResolvePromise = ResolvePromise;
   to.RejectPromise = RejectPromise;
 });
 
 })