[promise] make builtin resolve functions and executors non-constructors

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();
 
@@ skipping 19 matching lines @@
 });
 
 // -------------------------------------------------------------------
 
 // Status values: 0 = pending, +1 = resolved, -1 = rejected
 var lastMicrotaskId = 0;
 
 function CreateResolvingFunctions(promise) {
   var alreadyResolved = false;
 
-  var resolve = function(value) {
+  var resolve = (0, value => {

[adamk, 2016/01/07 22:22:28]

I'd prefer to leave the "(0," out for now, and leave it as a blocker against the
ES6 function name thing to make sure to scrub our natives for cases where we're
leaking names this way. It's unrelated to the tests you're fixing anyway.

     if (alreadyResolved === true) return;
     alreadyResolved = true;
     PromiseResolve(promise, value);
-  };
+  });
 
-  var reject = function(reason) {
+  var reject = (0, reason => {
     if (alreadyResolved === true) return;
     alreadyResolved = true;
     PromiseReject(promise, reason);
-  };
+  });
 
   return {
     __proto__: null,
     resolve: resolve,
     reject: reject
   };
 }
 
 
 var GlobalPromise = function Promise(resolver) {
@@ skipping 162 matching lines @@
     var promise = PromiseInit(new GlobalPromise(promiseRawSymbol));
     var callbacks = CreateResolvingFunctions(promise);
     return {
       promise: promise,
       resolve: callbacks.resolve,
       reject: callbacks.reject
     };
   }
 
   var result = {promise: UNDEFINED, resolve: UNDEFINED, reject: UNDEFINED };
-  result.promise = new C(function(resolve, reject) {
+  result.promise = new C((resolve, reject) => {
     if (!IS_UNDEFINED(result.resolve) || !IS_UNDEFINED(result.reject))
         throw MakeTypeError(kPromiseExecutorAlreadyInvoked);
     result.resolve = resolve;
     result.reject = reject;
   });
 
   if (!IS_CALLABLE(result.resolve))
       throw MakeTypeError(kCalledNonCallable, "promiseCapability.[[Resolve]]");
   if (!IS_CALLABLE(result.reject))
       throw MakeTypeError(kCalledNonCallable, "promiseCapability.[[Reject]]");
@@ skipping 97 matching lines @@
   if (!IS_RECEIVER(this)) {
     throw MakeTypeError(kCalledOnNonObject, "Promise.all");
   }
 
   var deferred = NewPromiseCapability(this);
   var resolutions = new InternalArray();
   var count;
 
   function CreateResolveElementFunction(index, values, promiseCapability) {
     var alreadyCalled = false;
-    return function(x) {
+    return (x) => {
       if (alreadyCalled === true) return;
       alreadyCalled = true;
       values[index] = x;
       if (--count === 0) {
         var valuesArray = [];
         %MoveArrayContents(values, valuesArray);
         %_Call(promiseCapability.resolve, UNDEFINED, valuesArray);
       }
     };
   }
@@ skipping 25 matching lines @@
 }
 
 function PromiseRace(iterable) {
   if (!IS_RECEIVER(this)) {
     throw MakeTypeError(kCalledOnNonObject, PromiseRace);
   }
 
   var deferred = NewPromiseCapability(this);
   try {
     for (var value of iterable) {
-      var reject = function(r) { deferred.reject(r) };
-      this.resolve(value).then(function(x) { deferred.resolve(x) }, reject);
+      var reject = (0, reason => { deferred.reject(reason); });
+      this.resolve(value).then((x) => { deferred.resolve(x) }, reject);
       SET_PRIVATE(reject, promiseCombinedDeferredSymbol, deferred);
     }
   } catch (e) {
     deferred.reject(e)
   }
   return deferred.promise;
 }
 
 
 // Utility for debugger
@@ skipping 66 matching lines @@
 [PromiseChain, PromiseDeferred, PromiseResolved].forEach(
     fn => %FunctionRemovePrototype(fn));
 
 utils.Export(function(to) {
   to.PromiseChain = PromiseChain;
   to.PromiseDeferred = PromiseDeferred;
   to.PromiseResolved = PromiseResolved;
 });
 
 })