Re^3-land "Ship promises and weak collections"

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.
 
 "use strict";
 
 // This file relies on the fact that the following declaration has been made
 // in runtime.js:
 // var $Object = global.Object
 // var $WeakMap = global.WeakMap
 
 
-var $Promise = Promise;
+var $Promise = function Promise(resolver) {
+  if (resolver === promiseRaw) return;
+  if (!%_IsConstructCall()) throw MakeTypeError('not_a_promise', [this]);
+  if (!IS_SPEC_FUNCTION(resolver))
+    throw MakeTypeError('resolver_not_a_function', [resolver]);
+  var promise = PromiseInit(this);
+  try {
+    %DebugPromiseHandlePrologue(function() { return promise });
+    resolver(function(x) { PromiseResolve(promise, x) },
+             function(r) { PromiseReject(promise, r) });
+  } catch (e) {
+    PromiseReject(promise, e);
+  } finally {
+    %DebugPromiseHandleEpilogue();
+  }
+}
 
 
 //-------------------------------------------------------------------
 
 // Core functionality.
 
 // 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");
 
 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]);
-  if (typeof resolver !== 'function')
-    throw MakeTypeError('resolver_not_a_function', [resolver]);
-  var promise = PromiseInit(this);
-  try {
-    %DebugPromiseHandlePrologue(function() { return promise });
-    resolver(function(x) { PromiseResolve(promise, x) },
-             function(r) { PromiseReject(promise, r) });
-  } catch (e) {
-    PromiseReject(promise, e);
-  } finally {
-    %DebugPromiseHandleEpilogue();
-  }
-}
-
 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)
@@ skipping 13 matching lines @@
 function PromiseReject(promise, r) {
   PromiseDone(promise, -1, r, promiseOnReject)
 }
 
 
 // For API.
 
 function PromiseNopResolver() {}
 
 function PromiseCreate() {
-  return new Promise(PromiseNopResolver)
+  return new $Promise(PromiseNopResolver)
 }
 
 
 // Convenience.
 
 function PromiseDeferred() {
   if (this === $Promise) {
     // Optimized case, avoid extra closure.
-    var promise = PromiseInit(new Promise(promiseRaw));
+    var promise = PromiseInit(new $Promise(promiseRaw));
     return {
       promise: promise,
       resolve: function(x) { PromiseResolve(promise, x) },
       reject: function(r) { PromiseReject(promise, r) }
     };
   } else {
     var result = {};
     result.promise = new this(function(resolve, reject) {
       result.resolve = resolve;
       result.reject = reject;
     })
     return result;
   }
 }
 
 function PromiseResolved(x) {
   if (this === $Promise) {
     // Optimized case, avoid extra closure.
-    return PromiseSet(new Promise(promiseRaw), +1, x);
+    return PromiseSet(new $Promise(promiseRaw), +1, x);
   } else {
     return new this(function(resolve, reject) { resolve(x) });
   }
 }
 
 function PromiseRejected(r) {
   if (this === $Promise) {
     // Optimized case, avoid extra closure.
-    return PromiseSet(new Promise(promiseRaw), -1, r);
+    return PromiseSet(new $Promise(promiseRaw), -1, r);
   } else {
     return new this(function(resolve, reject) { reject(r) });
   }
 }
 
 
 // Simple chaining.
 
 function PromiseIdResolveHandler(x) { return x }
 function PromiseIdRejectHandler(r) { throw r }
@@ skipping 54 matching lines @@
     }
   } finally {
     %DebugPromiseHandleEpilogue();
   }
 }
 
 
 // Multi-unwrapped chaining with thenable coercion.
 
 function PromiseThen(onResolve, onReject) {
-  onResolve =
-    IS_NULL_OR_UNDEFINED(onResolve) ? PromiseIdResolveHandler : onResolve;
-  onReject =
-    IS_NULL_OR_UNDEFINED(onReject) ? PromiseIdRejectHandler : onReject;
+  onResolve = IS_SPEC_FUNCTION(onResolve) ? onResolve : PromiseIdResolveHandler;
+  onReject = IS_SPEC_FUNCTION(onReject) ? onReject : PromiseIdRejectHandler;
   var that = this;
   var constructor = this.constructor;
   return %_CallFunction(
     this,
     function(x) {
       x = PromiseCoerce(constructor, x);
       return x === that ? onReject(MakeTypeError('promise_cyclic', [x])) :
              IsPromise(x) ? x.then(onResolve, onReject) : onResolve(x);
     },
     onReject,
@@ skipping 109 matching lines @@
 SetUpPromise();
 
 // Functions to expose promise details to the debugger.
 function GetPromiseStatus(promise) {
   return GET_PRIVATE(promise, promiseStatus);
 }
 
 function GetPromiseValue(promise) {
   return GET_PRIVATE(promise, promiseValue);
 }