[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 = value => {
     if (alreadyResolved === true) return;
     alreadyResolved = true;
     PromiseResolve(promise, value);
   };
 
-  var reject = function(reason) {
+  var reject = reason => {
     if (alreadyResolved === true) return;
     alreadyResolved = true;
     PromiseReject(promise, reason);
   };
 
   return {
     __proto__: null,
     resolve: resolve,
     reject: reject
   };
@@ skipping 166 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 = 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;
 });
 
 })