[promises] Remove IsPromise

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 162 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(%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;
   }
   if (IS_RECEIVER(resolution)) {
     // 25.4.1.3.2 steps 8-12
     try {
       var then = resolution.then;
     } catch (e) {
       %PromiseReject(promise, e, true);
       PromiseSet(promise, kRejected, e);
       return;
     }
 
     // Resolution is a native promise and if it's already resolved or
     // rejected, shortcircuit the resolution procedure by directly
     // reusing the value from the promise.
-    if (IsPromise(resolution) && then === PromiseThen) {
+    if (%is_promise(resolution) && then === PromiseThen) {
       var thenableState = GET_PRIVATE(resolution, promiseStateSymbol);
       if (thenableState === kFulfilled) {
         // This goes inside the if-else to save one symbol lookup in
         // the slow path.
         var thenableValue = GET_PRIVATE(resolution, promiseResultSymbol);
         %PromiseFulfill(promise, kFulfilled, thenableValue,
                        promiseFulfillReactionsSymbol);
         PromiseSet(promise, kFulfilled, thenableValue);
         SET_PRIVATE(promise, promiseHasHandlerSymbol, true);
         return;
       } else if (thenableState === kRejected) {
         var thenableValue = GET_PRIVATE(resolution, promiseResultSymbol);
         if (!HAS_DEFINED_PRIVATE(resolution, promiseHasHandlerSymbol)) {
           // Promise has already been rejected, but had no handler.
           // Revoke previously triggered reject event.
           %PromiseRevokeReject(resolution);
         }
         // Don't cause a debug event as this case is forwarding a rejection
         %PromiseReject(promise, thenableValue, false);
         PromiseSet(promise, kRejected, thenableValue);
         SET_PRIVATE(resolution, promiseHasHandlerSymbol, true);
         return;
       }
     }
 
     if (IS_CALLABLE(then)) {
-      if (DEBUG_IS_ACTIVE && IsPromise(resolution)) {
+      if (DEBUG_IS_ACTIVE && %is_promise(resolution)) {
           // Mark the dependency of the new promise on the resolution
         SET_PRIVATE(resolution, promiseHandledBySymbol, promise);
       }
       %EnqueuePromiseResolveThenableJob(promise, resolution, then);
       return;
     }
   }
   %PromiseFulfill(promise, kFulfilled, resolution,
                   promiseFulfillReactionsSymbol);
   PromiseSet(promise, kFulfilled, resolution);
@@ skipping 98 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) {
-  if (!IsPromise(this)) {
+  if (!%is_promise(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.
     resultCapability = NewPromiseCapability(constructor, false);
   }
   return PerformPromiseThen(this, onResolve, onReject, resultCapability);
 }
 
 // ES#sec-promise.prototype.catch
 // Promise.prototype.catch ( onRejected )
 function PromiseCatch(onReject) {
   return this.then(UNDEFINED, onReject);
 }
 
 // Combinators.
 
 // ES#sec-promise.resolve
 // Promise.resolve ( x )
 function PromiseResolve(x) {
   if (!IS_RECEIVER(this)) {
     throw %make_type_error(kCalledOnNonObject, PromiseResolve);
   }
-  if (IsPromise(x) && x.constructor === this) return x;
+  if (%is_promise(x) && x.constructor === this) return x;
 
   // Avoid creating resolving functions.
   if (this === GlobalPromise) {
     var promise = PromiseCreate();
     ResolvePromise(promise, x);
     return promise;
   }
 
   // debugEvent is not so meaningful here as it will be resolved
   var promiseCapability = NewPromiseCapability(this, true);
@@ skipping 39 matching lines @@
     var i = 0;
     count = 1;
     for (var value of iterable) {
       var nextPromise = this.resolve(value);
       ++count;
       var throwawayPromise = nextPromise.then(
           CreateResolveElementFunction(i, resolutions, deferred),
           deferred.reject);
       // For catch prediction, mark that rejections here are semantically
       // handled by the combined Promise.
-      if (instrumenting && IsPromise(throwawayPromise)) {
+      if (instrumenting && %is_promise(throwawayPromise)) {
         SET_PRIVATE(throwawayPromise, promiseHandledBySymbol, deferred.promise);
       }
       ++i;
     }
 
     // 6.d
     if (--count === 0) {
       var valuesArray = [];
       %MoveArrayContents(resolutions, valuesArray);
       %_Call(deferred.resolve, UNDEFINED, valuesArray);
@@ skipping 22 matching lines @@
   if (instrumenting) {
     SET_PRIVATE(deferred.reject, promiseForwardingHandlerSymbol, true);
   }
 
   try {
     for (var value of iterable) {
       var throwawayPromise = this.resolve(value).then(deferred.resolve,
                                                       deferred.reject);
       // For catch prediction, mark that rejections here are semantically
       // handled by the combined Promise.
-      if (instrumenting && IsPromise(throwawayPromise)) {
+      if (instrumenting && %is_promise(throwawayPromise)) {
         SET_PRIVATE(throwawayPromise, promiseHandledBySymbol, deferred.promise);
       }
     }
   } catch (e) {
     %_Call(deferred.reject, UNDEFINED, e);
   }
   return deferred.promise;
 }
 
 
@@ skipping 99 matching lines @@
 // resolve/reject closures, and allows them to later resolve and reject any
 // promise without having to hold on to those closures forever.
 utils.InstallFunctions(extrasUtils, 0, [
   "createPromise", PromiseCreate,
   "resolvePromise", ResolvePromise,
   "rejectPromise", DoRejectPromise,
   "markPromiseAsHandled", MarkPromiseAsHandled
 ]);
 
 utils.Export(function(to) {
-  to.IsPromise = IsPromise;
   to.PromiseCreate = PromiseCreate;
   to.PromiseThen = PromiseThen;
 
   to.CreateInternalPromiseCapability = CreateInternalPromiseCapability;
   to.PerformPromiseThen = PerformPromiseThen;
   to.ResolvePromise = ResolvePromise;
   to.RejectPromise = RejectPromise;
 });
 
 })