Add UseCounters for various standards-related code paths

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 promiseOnRejectSymbol = utils.ImportNow("promise_on_reject_symbol");
 var promiseOnResolveSymbol =
     utils.ImportNow("promise_on_resolve_symbol");
 var promiseRawSymbol = utils.ImportNow("promise_raw_symbol");
 var promiseStatusSymbol = utils.ImportNow("promise_status_symbol");
 var promiseValueSymbol = utils.ImportNow("promise_value_symbol");
 var toStringTagSymbol = utils.ImportNow("to_string_tag_symbol");
+const kPromiseChain = 17;
+const kPromiseAccept = 18;
+const kPromiseDefer = 19;

[adamk, 2016/01/05 19:10:09]

Same for theses consts. I can imagine doing a cleanup later where we move
constants from macros into the source file.

I'm open to arguments for why we should diverge here.

[Dan Ehrenberg, 2016/01/06 03:20:55]

I don't like macros! But this patch isn't the forum for that kind of argument.
Switched to using macros.

 
 utils.Import(function(from) {
   MakeTypeError = from.MakeTypeError;
 });
 
 // -------------------------------------------------------------------
 
 // Status values: 0 = pending, +1 = resolved, -1 = rejected
 var lastMicrotaskId = 0;
 
@@ skipping 194 matching lines @@
     var result = {promise: UNDEFINED, resolve: UNDEFINED, reject: UNDEFINED };
     result.promise = new C(function(resolve, reject) {
       // TODO(littledan): Check for resolve and reject being not undefined
       result.resolve = resolve;
       result.reject = reject;
     });
     return result;
   }
 }
 
 function PromiseDeferred() {

[adamk, 2016/01/05 19:10:09]

Could this be renamed "PromiseDefer" for clarity? It looks like it doesn't
really have callers any more.

[Dan Ehrenberg, 2016/01/06 03:20:55]

Agreed that this is confusing. I plan to do this and other cleanups that Camillo
recommended once the current batch of Promise patches goes in (chiefly Caitlin's
patches).

+  %IncrementUseCounter(kPromiseDefer);
   return NewPromiseCapability(this);
 }
 
 function PromiseResolved(x) {

[adamk, 2016/01/05 19:10:09]

Same here, clarity. The two lines where this function has different names are
surprising.

[Dan Ehrenberg, 2016/01/06 03:20:55]

Ditto.

+  %IncrementUseCounter(kPromiseAccept);
   return %_Call(PromiseCast, this, x);
 }
 
 function PromiseRejected(r) {
   if (!IS_RECEIVER(this)) {
     throw MakeTypeError(kCalledOnNonObject, PromiseRejected);
   }
   var promise;
   if (this === GlobalPromise) {
     // Optimized case, avoid extra closure.
@@ skipping 43 matching lines @@
   // Mark this promise as having handler.
   SET_PRIVATE(this, promiseHasHandlerSymbol, true);
   if (DEBUG_IS_ACTIVE) {
     %DebugPromiseEvent({ promise: deferred.promise, parentPromise: this });
   }
   return deferred.promise;
 }
 
 // Chain is left around for now as an alias for then
 function PromiseChain(onResolve, onReject) {
+  %IncrementUseCounter(kPromiseChain);
   return %_Call(PromiseThen, this, onResolve, onReject);
 }
 
 function PromiseCatch(onReject) {
   return this.then(UNDEFINED, onReject);
 }
 
 // Combinators.
 
 function PromiseCast(x) {
@@ skipping 124 matching lines @@
 [PromiseChain, PromiseDeferred, PromiseResolved].forEach(
     fn => %FunctionRemovePrototype(fn));
 
 utils.Export(function(to) {
   to.PromiseChain = PromiseChain;
   to.PromiseDeferred = PromiseDeferred;
   to.PromiseResolved = PromiseResolved;
 });
 
 })