Unify symbols sharing across native scripts and runtime.

src/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.
 
-var $promiseHasUserDefinedRejectHandler;
-var $promiseStatus;
-var $promiseValue;
-
 (function(global, utils) {
 
 "use strict";
 
 %CheckIsBootstrapping();
 
 // -------------------------------------------------------------------
 // Imports
 
 var InternalArray = utils.InternalArray;
+var PromiseHasHandlerSymbol =
+    utils.GetPrivateSymbol("promise_has_handler_symbol");
+var PromiseOnRejectSymbol = utils.GetPrivateSymbol("promise_on_reject_symbol");
+var PromiseOnResolveSymbol =
+    utils.GetPrivateSymbol("promise_on_resolve_symbol");
+var PromiseRawSymbol = utils.GetPrivateSymbol("promise_raw_symbol");
+var PromiseStatusSymbol = utils.GetPrivateSymbol("promise_status_symbol");
+var PromiseValueSymbol = utils.GetPrivateSymbol("promise_value_symbol");
 
 // -------------------------------------------------------------------
 
 // Status values: 0 = pending, +1 = resolved, -1 = rejected
-var promiseStatus = GLOBAL_PRIVATE("Promise#status");
-var promiseValue = GLOBAL_PRIVATE("Promise#value");
-var promiseOnResolve = GLOBAL_PRIVATE("Promise#onResolve");
-var promiseOnReject = GLOBAL_PRIVATE("Promise#onReject");
-var promiseRaw = GLOBAL_PRIVATE("Promise#raw");
-var promiseHasHandler = %PromiseHasHandlerSymbol();
 var lastMicrotaskId = 0;
 
 var GlobalPromise = function Promise(resolver) {
-  if (resolver === promiseRaw) return;
+  if (resolver === PromiseRawSymbol) return;
   if (!%_IsConstructCall()) throw MakeTypeError(kNotAPromise, this);
   if (!IS_SPEC_FUNCTION(resolver))
     throw MakeTypeError(kResolverNotAFunction, resolver);
   var promise = PromiseInit(this);
   try {
     %DebugPushPromise(promise, Promise);
     resolver(function(x) { PromiseResolve(promise, x) },
              function(r) { PromiseReject(promise, r) });
   } catch (e) {
     PromiseReject(promise, e);
   } finally {
     %DebugPopPromise();
   }
 }
 
 // Core functionality.
 
 function PromiseSet(promise, status, value, onResolve, onReject) {
-  SET_PRIVATE(promise, promiseStatus, status);
-  SET_PRIVATE(promise, promiseValue, value);
-  SET_PRIVATE(promise, promiseOnResolve, onResolve);
-  SET_PRIVATE(promise, promiseOnReject, onReject);
+  SET_PRIVATE(promise, PromiseStatusSymbol, status);
+  SET_PRIVATE(promise, PromiseValueSymbol, value);
+  SET_PRIVATE(promise, PromiseOnResolveSymbol, onResolve);
+  SET_PRIVATE(promise, PromiseOnRejectSymbol, onReject);
   if (DEBUG_IS_ACTIVE) {
     %DebugPromiseEvent({ promise: promise, status: status, value: value });
   }
   return promise;
 }
 
 function PromiseCreateAndSet(status, value) {
-  var promise = new GlobalPromise(promiseRaw);
+  var promise = new GlobalPromise(PromiseRawSymbol);
   // If debug is active, notify about the newly created promise first.
   if (DEBUG_IS_ACTIVE) PromiseSet(promise, 0, UNDEFINED);
   return PromiseSet(promise, status, value);
 }
 
 function PromiseInit(promise) {
   return PromiseSet(
       promise, 0, UNDEFINED, new InternalArray, new InternalArray)
 }
 
 function PromiseDone(promise, status, value, promiseQueue) {
-  if (GET_PRIVATE(promise, promiseStatus) === 0) {
+  if (GET_PRIVATE(promise, PromiseStatusSymbol) === 0) {
     var tasks = GET_PRIVATE(promise, promiseQueue);
     if (tasks.length) PromiseEnqueue(value, tasks, status);
     PromiseSet(promise, status, value);
   }
 }
 
 function PromiseCoerce(constructor, x) {
   if (!IsPromise(x) && IS_SPEC_OBJECT(x)) {
     var then;
     try {
@@ skipping 56 matching lines @@
 function PromiseIdRejectHandler(r) { throw r }
 
 function PromiseNopResolver() {}
 
 // -------------------------------------------------------------------
 // Define exported functions.
 
 // For bootstrapper.
 
 function IsPromise(x) {
-  return IS_SPEC_OBJECT(x) && HAS_DEFINED_PRIVATE(x, promiseStatus);
+  return IS_SPEC_OBJECT(x) && HAS_DEFINED_PRIVATE(x, PromiseStatusSymbol);
 }
 
 function PromiseCreate() {
   return new GlobalPromise(PromiseNopResolver)
 }
 
 function PromiseResolve(promise, x) {
-  PromiseDone(promise, +1, x, promiseOnResolve)
+  PromiseDone(promise, +1, x, PromiseOnResolveSymbol)
 }
 
 function PromiseReject(promise, r) {
   // Check promise status to confirm that this reject has an effect.
   // Call runtime for callbacks to the debugger or for unhandled reject.
-  if (GET_PRIVATE(promise, promiseStatus) == 0) {
+  if (GET_PRIVATE(promise, PromiseStatusSymbol) == 0) {
     var debug_is_active = DEBUG_IS_ACTIVE;
-    if (debug_is_active || !HAS_DEFINED_PRIVATE(promise, promiseHasHandler)) {
+    if (debug_is_active ||
+        !HAS_DEFINED_PRIVATE(promise, PromiseHasHandlerSymbol)) {
       %PromiseRejectEvent(promise, r, debug_is_active);
     }
   }
-  PromiseDone(promise, -1, r, promiseOnReject)
+  PromiseDone(promise, -1, r, PromiseOnRejectSymbol)
 }
 
 // Convenience.
 
 function PromiseDeferred() {
   if (this === GlobalPromise) {
     // Optimized case, avoid extra closure.
-    var promise = PromiseInit(new GlobalPromise(promiseRaw));
+    var promise = PromiseInit(new GlobalPromise(PromiseRawSymbol));
     return {
       promise: promise,
       resolve: function(x) { PromiseResolve(promise, x) },
       reject: function(r) { PromiseReject(promise, r) }
     };
   } else {
     var result = {promise: UNDEFINED, reject: UNDEFINED, resolve: UNDEFINED};
     result.promise = new this(function(resolve, reject) {
       result.resolve = resolve;
       result.reject = reject;
@@ skipping 24 matching lines @@
   }
   return promise;
 }
 
 // Simple chaining.
 
 function PromiseChain(onResolve, onReject) {  // a.k.a. flatMap
   onResolve = IS_UNDEFINED(onResolve) ? PromiseIdResolveHandler : onResolve;
   onReject = IS_UNDEFINED(onReject) ? PromiseIdRejectHandler : onReject;
   var deferred = %_CallFunction(this.constructor, PromiseDeferred);
-  switch (GET_PRIVATE(this, promiseStatus)) {
+  switch (GET_PRIVATE(this, PromiseStatusSymbol)) {
     case UNDEFINED:
       throw MakeTypeError(kNotAPromise, this);
     case 0:  // Pending
-      GET_PRIVATE(this, promiseOnResolve).push(onResolve, deferred);
-      GET_PRIVATE(this, promiseOnReject).push(onReject, deferred);
+      GET_PRIVATE(this, PromiseOnResolveSymbol).push(onResolve, deferred);
+      GET_PRIVATE(this, PromiseOnRejectSymbol).push(onReject, deferred);
       break;
     case +1:  // Resolved
-      PromiseEnqueue(GET_PRIVATE(this, promiseValue),
+      PromiseEnqueue(GET_PRIVATE(this, PromiseValueSymbol),
                      [onResolve, deferred],
                      +1);
       break;
     case -1:  // Rejected
-      if (!HAS_DEFINED_PRIVATE(this, promiseHasHandler)) {
+      if (!HAS_DEFINED_PRIVATE(this, PromiseHasHandlerSymbol)) {
         // Promise has already been rejected, but had no handler.
         // Revoke previously triggered reject event.
         %PromiseRevokeReject(this);
       }
-      PromiseEnqueue(GET_PRIVATE(this, promiseValue),
+      PromiseEnqueue(GET_PRIVATE(this, PromiseValueSymbol),
                      [onReject, deferred],
                      -1);
       break;
   }
   // Mark this promise as having handler.
-  SET_PRIVATE(this, promiseHasHandler, true);
+  SET_PRIVATE(this, PromiseHasHandlerSymbol, true);
   if (DEBUG_IS_ACTIVE) {
     %DebugPromiseEvent({ promise: deferred.promise, parentPromise: this });
   }
   return deferred.promise;
 }
 
 function PromiseCatch(onReject) {
   return this.then(UNDEFINED, onReject);
 }
 
@@ skipping 74 matching lines @@
   } catch (e) {
     deferred.reject(e)
   }
   return deferred.promise;
 }
 
 
 // Utility for debugger
 
 function PromiseHasUserDefinedRejectHandlerRecursive(promise) {
-  var queue = GET_PRIVATE(promise, promiseOnReject);
+  var queue = GET_PRIVATE(promise, PromiseOnRejectSymbol);
   if (IS_UNDEFINED(queue)) return false;
   for (var i = 0; i < queue.length; i += 2) {
     if (queue[i] != PromiseIdRejectHandler) return true;
     if (PromiseHasUserDefinedRejectHandlerRecursive(queue[i + 1].promise)) {
       return true;
     }
   }
   return false;
 }
 
@@ skipping 19 matching lines @@
   "race", PromiseRace,
   "resolve", PromiseCast
 ]);
 
 utils.InstallFunctions(GlobalPromise.prototype, DONT_ENUM, [
   "chain", PromiseChain,
   "then", PromiseThen,
   "catch", PromiseCatch
 ]);
 
-$promiseStatus = promiseStatus;
-$promiseValue = promiseValue;
-
 utils.ExportToRuntime(function(to) {
-  to.promiseStatus = promiseStatus;
-  to.promiseValue = promiseValue;
   to.PromiseCreate = PromiseCreate;
   to.PromiseResolve = PromiseResolve;
   to.PromiseReject = PromiseReject;
   to.PromiseChain = PromiseChain;
   to.PromiseCatch = PromiseCatch;
   to.PromiseThen = PromiseThen;
   to.PromiseHasUserDefinedRejectHandler = PromiseHasUserDefinedRejectHandler;
 });
 
 })