Move family of MakeError functions to C++

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();
 
 // -------------------------------------------------------------------
 // Imports
 
 var InternalArray = utils.InternalArray;
-var MakeTypeError;
 var promiseCombinedDeferredSymbol =
     utils.ImportNow("promise_combined_deferred_symbol");
 var promiseHasHandlerSymbol =
     utils.ImportNow("promise_has_handler_symbol");
 var promiseRejectReactionsSymbol =
     utils.ImportNow("promise_reject_reactions_symbol");
 var promiseFulfillReactionsSymbol =
     utils.ImportNow("promise_fulfill_reactions_symbol");
 var promiseDeferredReactionsSymbol =
     utils.ImportNow("promise_deferred_reactions_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");
 
 utils.Import(function(from) {
-  MakeTypeError = from.MakeTypeError;
   SpeciesConstructor = from.SpeciesConstructor;
 });
 
 // -------------------------------------------------------------------
 
 // [[PromiseState]] values:
 const kPending = 0;
 const kFulfilled = +1;
 const kRejected = -1;
 
@@ skipping 27 matching lines @@
   };
 }
 
 
 // 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 MakeTypeError(kNotAPromise, this);
+  if (IS_UNDEFINED(new.target)) throw %make_type_error(kNotAPromise, this);
   if (!IS_CALLABLE(executor)) {
-    throw MakeTypeError(kResolverNotAFunction, executor);
+    throw %make_type_error(kResolverNotAFunction, executor);
   }
 
   var promise = PromiseInit(%_NewObject(GlobalPromise, new.target));
   var callbacks = CreateResolvingFunctions(promise);
   var debug_is_active = DEBUG_IS_ACTIVE;
   try {
     if (debug_is_active) %DebugPushPromise(promise);
     executor(callbacks.resolve, callbacks.reject);
   } %catch (e) {  // Natives syntax to mark this catch block.
     %_Call(callbacks.reject, UNDEFINED, e);
@@ skipping 138 matching lines @@
 }
 
 function PromiseCreate() {
   return new GlobalPromise(PromiseNopResolver)
 }
 
 // ES#sec-promise-resolve-functions
 // Promise Resolve Functions, steps 6-13
 function ResolvePromise(promise, resolution) {
   if (resolution === promise) {
-    return RejectPromise(promise, MakeTypeError(kPromiseCyclic, resolution));
+    return RejectPromise(promise, %make_type_error(kPromiseCyclic, resolution));
   }
   if (IS_RECEIVER(resolution)) {
     // 25.4.1.3.2 steps 8-12
     try {
       var then = resolution.then;
     } catch (e) {
       return RejectPromise(promise, e);
     }
 
     // Resolution is a native promise and if it's already resolved or
@@ skipping 76 matching lines @@
     return {
       promise: promise,
       resolve: callbacks.resolve,
       reject: callbacks.reject
     };
   }
 
   var result = {promise: UNDEFINED, resolve: UNDEFINED, reject: UNDEFINED };
   result.promise = new C((resolve, reject) => {
     if (!IS_UNDEFINED(result.resolve) || !IS_UNDEFINED(result.reject))
-        throw MakeTypeError(kPromiseExecutorAlreadyInvoked);
+        throw %make_type_error(kPromiseExecutorAlreadyInvoked);
     result.resolve = resolve;
     result.reject = reject;
   });
 
   if (!IS_CALLABLE(result.resolve) || !IS_CALLABLE(result.reject))
-      throw MakeTypeError(kPromiseNonCallable);
+      throw %make_type_error(kPromiseNonCallable);
 
   return result;
 }
 
 // Unspecified V8-specific legacy function
 function PromiseDefer() {
   %IncrementUseCounter(kPromiseDefer);
   return NewPromiseCapability(this);
 }
 
 // Unspecified V8-specific legacy function
 function PromiseAccept(x) {
   %IncrementUseCounter(kPromiseAccept);
   return %_Call(PromiseResolve, this, x);
 }
 
 // ES#sec-promise.reject
 // Promise.reject ( x )
 function PromiseReject(r) {
   if (!IS_RECEIVER(this)) {
-    throw MakeTypeError(kCalledOnNonObject, PromiseResolve);
+    throw %make_type_error(kCalledOnNonObject, PromiseResolve);
   }
   if (this === GlobalPromise) {
     // Optimized case, avoid extra closure.
     var promise = PromiseCreateAndSet(kRejected, r);
     // The debug event for this would always be an uncaught promise reject,
     // which is usually simply noise. Do not trigger that debug event.
     %PromiseRejectEvent(promise, r, false);
     return promise;
   } else {
     var promiseCapability = NewPromiseCapability(this);
@@ skipping 11 matching lines @@
 function PromiseCreateResolved(x) {
   return %_Call(PromiseResolve, GlobalPromise, x);
 }
 
 // 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)) {
-    throw MakeTypeError(kNotAPromise, this);
+    throw %make_type_error(kNotAPromise, this);
   }
 
   var constructor = SpeciesConstructor(this, GlobalPromise);
   onResolve = IS_CALLABLE(onResolve) ? onResolve : PromiseIdResolveHandler;
   onReject = IS_CALLABLE(onReject) ? onReject : PromiseIdRejectHandler;
   var deferred = NewPromiseCapability(constructor);
   switch (status) {
     case kPending:
       PromiseAttachCallbacks(this, deferred, onResolve, onReject);
       break;
@@ skipping 28 matching lines @@
 function PromiseCatch(onReject) {
   return this.then(UNDEFINED, onReject);
 }
 
 // Combinators.
 
 // ES#sec-promise.resolve
 // Promise.resolve ( x )
 function PromiseResolve(x) {
   if (!IS_RECEIVER(this)) {
-    throw MakeTypeError(kCalledOnNonObject, PromiseResolve);
+    throw %make_type_error(kCalledOnNonObject, PromiseResolve);
   }
   if (IsPromise(x) && x.constructor === this) return x;
 
   // Avoid creating resolving functions.
   if (this === GlobalPromise) {
     var promise = PromiseInit(new GlobalPromise(promiseRawSymbol));
     var resolveResult = ResolvePromise(promise, x);
     return promise;
   }
 
   var promiseCapability = NewPromiseCapability(this);
   var resolveResult = %_Call(promiseCapability.resolve, UNDEFINED, x);
   return promiseCapability.promise;
 }
 
 // ES#sec-promise.all
 // Promise.all ( iterable )
 function PromiseAll(iterable) {
   if (!IS_RECEIVER(this)) {
-    throw MakeTypeError(kCalledOnNonObject, "Promise.all");
+    throw %make_type_error(kCalledOnNonObject, "Promise.all");
   }
 
   var deferred = NewPromiseCapability(this);
   var resolutions = new InternalArray();
   var count;
 
   function CreateResolveElementFunction(index, values, promiseCapability) {
     var alreadyCalled = false;
     return (x) => {
       if (alreadyCalled === true) return;
@@ skipping 30 matching lines @@
   } catch (e) {
     %_Call(deferred.reject, UNDEFINED, e);
   }
   return deferred.promise;
 }
 
 // ES#sec-promise.race
 // Promise.race ( iterable )
 function PromiseRace(iterable) {
   if (!IS_RECEIVER(this)) {
-    throw MakeTypeError(kCalledOnNonObject, PromiseRace);
+    throw %make_type_error(kCalledOnNonObject, PromiseRace);
   }
 
   var deferred = NewPromiseCapability(this);
   try {
     for (var value of iterable) {
       this.resolve(value).then(deferred.resolve, deferred.reject);
       SET_PRIVATE(deferred.reject, promiseCombinedDeferredSymbol, deferred);
     }
   } catch (e) {
     deferred.reject(e)
@@ skipping 95 matching lines @@
   to.PromiseChain = PromiseChain;
   to.PromiseDefer = PromiseDefer;
   to.PromiseAccept = PromiseAccept;
 
   to.PromiseCreateRejected = PromiseCreateRejected;
   to.PromiseCreateResolved = PromiseCreateResolved;
   to.PromiseThen = PromiseThen;
 });
 
 })