Promises: Rename functions/parameters to match spec

src/js/promise.js

Index: src/js/promise.js
diff --git a/src/js/promise.js b/src/js/promise.js
index f2fcc477996afc47d1954b71504ecd7b48f73943..a32a808c3ca209e125d2bd75df4804ba1227c507 100644
--- a/src/js/promise.js
+++ b/src/js/promise.js
@@ -51,7 +51,7 @@ function CreateResolvingFunctions(promise) {
   var resolve = value => {
     if (alreadyResolved === true) return;
     alreadyResolved = true;
-    FulfillPromise(promise, value);
+    ResolvePromise(promise, value);
   };
 
   // ES#sec-promise-reject-functions
@@ -72,13 +72,13 @@ function CreateResolvingFunctions(promise) {
 
 // ES#sec-promise-executor
 // Promise ( executor )
-var GlobalPromise = function Promise(resolver) {
-  if (resolver === promiseRawSymbol) {
+var GlobalPromise = function Promise(executor) {
+  if (executor === promiseRawSymbol) {
     return %_NewObject(GlobalPromise, new.target);
   }
   if (IS_UNDEFINED(new.target)) throw MakeTypeError(kNotAPromise, this);
-  if (!IS_CALLABLE(resolver)) {
-    throw MakeTypeError(kResolverNotAFunction, resolver);
+  if (!IS_CALLABLE(executor)) {
+    throw MakeTypeError(kResolverNotAFunction, executor);
   }
 
   var promise = PromiseInit(%_NewObject(GlobalPromise, new.target));
@@ -86,7 +86,7 @@ var GlobalPromise = function Promise(resolver) {
   var debug_is_active = DEBUG_IS_ACTIVE;
   try {
     if (debug_is_active) %DebugPushPromise(promise, Promise);
-    resolver(callbacks.resolve, callbacks.reject);
+    executor(callbacks.resolve, callbacks.reject);
   } catch (e) {
     %_Call(callbacks.reject, UNDEFINED, e);
   } finally {
@@ -118,7 +118,7 @@ function PromiseInit(promise) {
       promise, kPending, UNDEFINED, new InternalArray, new InternalArray)
 }
 
-function PromiseDone(promise, status, value, promiseQueue) {
+function FulfillPromise(promise, status, value, promiseQueue) {
   if (GET_PRIVATE(promise, promiseStateSymbol) === kPending) {
     var tasks = GET_PRIVATE(promise, promiseQueue);
     if (tasks.length) PromiseEnqueue(value, tasks, status);
@@ -162,7 +162,7 @@ function PromiseEnqueue(value, tasks, status) {
 function PromiseIdResolveHandler(x) { return x }
 function PromiseIdRejectHandler(r) { throw r }
 
-function PromiseNopResolver() {}
+function PromiseNoopResolver() {}

[adamk, 2016/05/25 20:57:26]

This one doesn't seem spec related?

[gsathya, 2016/05/25 23:09:24]

Yeah, this isn't. I thought nop was a typo

[adamk, 2016/05/25 23:19:18]

Ah, understood. I believe "nop" is an accepted spelling, I'd leave that change
out of this patch.

[gsathya, 2016/05/25 23:53:07]

Done.

 
 // -------------------------------------------------------------------
 // Define exported functions.
@@ -175,19 +175,19 @@ function IsPromise(x) {
 }
 
 function PromiseCreate() {
-  return new GlobalPromise(PromiseNopResolver)
+  return new GlobalPromise(PromiseNoopResolver)
 }
 
-// ES#sec-fulfillpromise
-// FulfillPromise ( promise, value)
-function FulfillPromise(promise, x) {
-  if (x === promise) {
-    return RejectPromise(promise, MakeTypeError(kPromiseCyclic, x));
+// ES#sec-resolvepromise

[adamk, 2016/05/25 20:57:26]

This section doesn't exist. The format of these is "ES#actual-anchor-in-spec"

[gsathya, 2016/05/25 23:09:24]

Aha. Changed.

+// ResolvePromise ( promise, value)

[adamk, 2016/05/25 20:57:26]

Nor does this abstract operation. What does it correspond to in the spec? Looks
like it's most of the steps of
https://tc39.github.io/ecma262/#sec-promise-resolve-functions?

[gsathya, 2016/05/25 23:09:24]

Yeah, I've updated the anchor to link to this. Let me know if there's a better
name for this

+function ResolvePromise(promise, value) {
+  if (value === promise) {
+    return RejectPromise(promise, MakeTypeError(kPromiseCyclic, value));
   }
-  if (IS_RECEIVER(x)) {
+  if (IS_RECEIVER(value)) {
     // 25.4.1.3.2 steps 8-12
     try {
-      var then = x.then;
+      var then = value.then;
     } catch (e) {
       return RejectPromise(promise, e);
     }
@@ -200,7 +200,7 @@ function FulfillPromise(promise, x) {
         }
         var callbacks = CreateResolvingFunctions(promise);
         try {
-          %_Call(then, x, callbacks.resolve, callbacks.reject);
+          %_Call(then, value, callbacks.resolve, callbacks.reject);
         } catch (e) {
           %_Call(callbacks.reject, UNDEFINED, e);
         }
@@ -216,22 +216,22 @@ function FulfillPromise(promise, x) {
       return;
     }
   }
-  PromiseDone(promise, kFulfilled, x, promiseFulfillReactionsSymbol);
+  FulfillPromise(promise, kFulfilled, value, promiseFulfillReactionsSymbol);
 }
 
 // ES#sec-rejectpromise
 // RejectPromise ( promise, reason )
-function RejectPromise(promise, r) {
+function RejectPromise(promise, reason) {
   // 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, promiseStateSymbol) === kPending) {
     var debug_is_active = DEBUG_IS_ACTIVE;
     if (debug_is_active ||
         !HAS_DEFINED_PRIVATE(promise, promiseHasHandlerSymbol)) {
-      %PromiseRejectEvent(promise, r, debug_is_active);
+      %PromiseRejectEvent(promise, reason, debug_is_active);
     }
   }
-  PromiseDone(promise, kRejected, r, promiseRejectReactionsSymbol)
+  FulfillPromise(promise, kRejected, reason, promiseRejectReactionsSymbol)
 }
 
 // ES#sec-newpromisecapability
@@ -496,7 +496,7 @@ utils.InstallFunctions(GlobalPromise.prototype, DONT_ENUM, [
   "promise_create", PromiseCreate,
   "promise_has_user_defined_reject_handler", PromiseHasUserDefinedRejectHandler,
   "promise_reject", RejectPromise,
-  "promise_resolve", FulfillPromise,
+  "promise_resolve", ResolvePromise,
   "promise_then", PromiseThen,
   "promise_create_rejected", PromiseCreateRejected,
   "promise_create_resolved", PromiseCreateResolved
@@ -507,7 +507,7 @@ utils.InstallFunctions(GlobalPromise.prototype, DONT_ENUM, [
 // promise without having to hold on to those closures forever.
 utils.InstallFunctions(extrasUtils, 0, [
   "createPromise", PromiseCreate,
-  "resolvePromise", FulfillPromise,
+  "resolvePromise", ResolvePromise,
   "rejectPromise", RejectPromise
 ]);