Promises: some adaptations to spec

src/promise.js

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 44 matching lines @@
 var promiseOnResolve = NEW_PRIVATE("Promise#onResolve");
 var promiseOnReject = NEW_PRIVATE("Promise#onReject");
 var promiseRaw = NEW_PRIVATE("Promise#raw");
 
 function IsPromise(x) {
   return IS_SPEC_OBJECT(x) && %HasLocalProperty(x, promiseStatus);
 }
 
 function Promise(resolver) {
   if (resolver === promiseRaw) return;
+  if (!%_IsConstructCall()) throw MakeTypeError('not_a_promise', [this]);
   var promise = PromiseInit(this);
-  resolver(function(x) { PromiseResolve(promise, x) },
-           function(r) { PromiseReject(promise, r) });
-  // TODO(rossberg): current draft makes exception from this call asynchronous,
-  // but that's probably a mistake.
+  try {
+    resolver(function(x) { PromiseResolve(promise, x) },
+             function(r) { PromiseReject(promise, r) });
+  } catch (e) {
+    PromiseReject(promise, e);
+  }
 }
 
 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);
   return promise;
 }
 
 function PromiseInit(promise) {
   return PromiseSet(promise, 0, UNDEFINED, new InternalArray, new InternalArray)
 }
 
 function PromiseDone(promise, status, value, promiseQueue) {
-  if (GET_PRIVATE(promise, promiseStatus) !== 0) return;
-  PromiseEnqueue(value, GET_PRIVATE(promise, promiseQueue));
-  PromiseSet(promise, status, value);
+  if (GET_PRIVATE(promise, promiseStatus) === 0) {
+    PromiseEnqueue(value, GET_PRIVATE(promise, promiseQueue));
+    PromiseSet(promise, status, value);
+  }
 }
 
 function PromiseResolve(promise, x) {
   PromiseDone(promise, +1, x, promiseOnResolve)
 }
 
 function PromiseReject(promise, r) {
   PromiseDone(promise, -1, r, promiseOnReject)
 }
 
@@ skipping 117 matching lines @@
     onReject
   );
 }
 
 PromiseCoerce.table = new $WeakMap;
 
 function PromiseCoerce(constructor, x) {
   var then;
   if (IsPromise(x)) {
     return x;
-  } else if (!IS_NULL_OR_UNDEFINED(x) && %IsCallable(then = x.then)) {
+  } else if (!IS_NULL_OR_UNDEFINED(x) &&
+             typeof (then = x.then) === 'function') {

[Dmitry Lomov (no reviews), 2013/12/04 09:24:43]

Can we not have assignments in conditions? Pretty please? Replace with
  if (IS_NULL_OR_UNDEFINED(x)) return x;
  var then = x.then;
  if (typeof(then) !== 'function') return x;

[rossberg, 2013/12/06 11:43:29]

Done.

     if (PromiseCoerce.table.has(x)) {
       return PromiseCoerce.table.get(x);
     } else {
-      var deferred = constructor.deferred();
+      var deferred = %_CallFunction(constructor, PromiseDeferred);
       PromiseCoerce.table.set(x, deferred.promise);
       try {
         %_CallFunction(x, deferred.resolve, deferred.reject, then);
       } catch(e) {
         deferred.reject(e);
       }
       return deferred.promise;
     }
   } else {
     return x;
   }
 }
 
 
 // Combinators.
 
 function PromiseCast(x) {
   // TODO(rossberg): cannot do better until we support @@create.
-  return IsPromise(x) ? x : this.resolved(x);
+  return IsPromise(x) ? x : this.resolve(x);
 }
 
 function PromiseAll(values) {
-  var deferred = this.deferred();
+  var deferred = %_CallFunction(this, PromiseDeferred);

[Dmitry Lomov (no reviews), 2013/12/04 09:24:43]

Instead of using %_CallFunction here and above, let's have utility method
PromiseDeferredImpl, replace these calls with PromiseDeferredImpl(this), and
   Promise.defer = function(this) { PromiseDeferredImpl(this); }
Even better, I suggest not shipping defer (see below) :)

[rossberg, 2013/12/06 11:43:29]

Why? Avoiding extra hoops like that is exactly why we have %_CallFunction (which
really just is a safe and efficient version of f.call).

   var resolutions = [];
-  var count = values.length;
-  if (count === 0) {
-    deferred.resolve(resolutions);
-  } else {
-    for (var i = 0; i < values.length; ++i) {
-      this.cast(values[i]).chain(
-        function(i, x) {
-          resolutions[i] = x;
-          if (--count === 0) deferred.resolve(resolutions);
-        }.bind(UNDEFINED, i),  // TODO(rossberg): use let loop once available
-        function(r) {
-          if (count > 0) { count = 0; deferred.reject(r) }
-        }
-      );
+  try {
+    var count = values.length;
+    if (count === 0) {
+      deferred.resolve(resolutions);
+    } else {
+      for (var i = 0; i < values.length; ++i) {
+        this.cast(values[i]).chain(
+          function(i, x) {
+            resolutions[i] = x;
+            if (--count === 0) deferred.resolve(resolutions);
+          }.bind(UNDEFINED, i),  // TODO(rossberg): use let loop once available
+          function(r) { deferred.reject(r) }

[Dmitry Lomov (no reviews), 2013/12/04 09:24:43]

Why 'count > 0' condition disappeared here? What if more than one of values
fail?

[rossberg, 2013/12/06 11:43:29]

Reject used to throw on non-pending promises in an earlier version. For legacy
compatibility, I already changed that to just ignore the attempt, so the extra
check here became redundant (as in PromiseOne below).

+        );
+      }
     }
+  } catch (e) {
+    deferred.reject(e)
   }
   return deferred.promise;
 }
 
 function PromiseOne(values) {  // a.k.a. race
-  var deferred = this.deferred();
-  var done = false;
-  for (var i = 0; i < values.length; ++i) {
-    this.cast(values[i]).chain(
-      function(x) { if (!done) { done = true; deferred.resolve(x) } },
-      function(r) { if (!done) { done = true; deferred.reject(r) } }
-    );
+  var deferred = %_CallFunction(this, PromiseDeferred);

[Dmitry Lomov (no reviews), 2013/12/04 09:24:43]

Ditto re: %_CallFunction

+  try {
+    for (var i = 0; i < values.length; ++i) {
+      this.cast(values[i]).chain(
+        function(x) { deferred.resolve(x) },
+        function(r) { deferred.reject(r) }
+      );
+    }
+  } catch (e) {
+    deferred.reject(e)
   }
   return deferred.promise;
 }
 
 //-------------------------------------------------------------------
 
 function SetUpPromise() {
   %CheckIsBootstrapping()
   global.Promise = $Promise;
   InstallFunctions($Promise, DONT_ENUM, [
-    "deferred", PromiseDeferred,
-    "resolved", PromiseResolved,
-    "rejected", PromiseRejected,
+    "defer", PromiseDeferred,

[Dmitry Lomov (no reviews), 2013/12/04 09:24:43]

So, my understanding is that 'defer' is non-standard as of now? Let's not ship
non-standard API maybe? (maybe a separate CL)

[rossberg, 2013/12/06 11:43:29]

As per off-line discussion, I leave it in for the time being.

+    "resolve", PromiseResolved,
+    "reject", PromiseRejected,
     "all", PromiseAll,
     "one", PromiseOne,
     "cast", PromiseCast
   ]);
   InstallFunctions($Promise.prototype, DONT_ENUM, [
     "chain", PromiseChain,
     "then", PromiseThen,
     "catch", PromiseCatch
   ]);
 }
 
 SetUpPromise();