perf($q): reduce memory footprint

Reduce the memory footprint of $q by using common functions
that will be used by all promises.

Author: lgalfaso

lib/promises-aplus/promises-aplus-test-adapter.js

@@ -1,5 +1,25 @@
 var isFunction = function isFunction(value){return typeof value == 'function';}
 var isObject = function isObject(value){return value != null && typeof value === 'object';}
+function bind(self, fn) {
+  var curryArgs = arguments.length > 2 ? sliceArgs(arguments, 2) : [];
+  if (isFunction(fn) && !(fn instanceof RegExp)) {
+    return curryArgs.length
+      ? function() {
+          return arguments.length
+            ? fn.apply(self, curryArgs.concat(slice.call(arguments, 0)))
+            : fn.apply(self, curryArgs);
+        }
+      : function() {
+          return arguments.length
+            ? fn.apply(self, arguments)
+            : fn.call(self);
+        };
+  } else {
+    // in IE, native methods are not functions so they cannot be bound (note: they don't need to be)
+    return fn;
+  }
+}
+
 
 var $q = qFactory(process.nextTick, function noopExceptionHandler() {});
 

src/ng/q.js

@@ -202,154 +202,166 @@ function qFactory(nextTick, exceptionHandler) {
     return [wrap(resolveFn), wrap(rejectFn)];
   }
 
-  /**
-   * @ngdoc
-   * @name ng.$q#defer
-   * @methodOf ng.$q
-   * @description
-   * Creates a `Deferred` object which represents a task which will finish in the future.
-   *
-   * @returns {Deferred} Returns a new instance of deferred.
-   */
-  var defer = function() {
-    var pending = [],
-        value,
-        status = 0,
-        deferred,
-        processScheduled = false;
-
-    function processQueue() {
-      var fn, promise;
-
-      processScheduled = false;
-      if (!status) return;
-      for (var i = 0; i < pending.length; ++i) {
-        promise = pending[i][0];
-        fn = pending[i][status];
-        try {
-          if (isFunction(fn)) {
-            promise.resolve(fn(value));
-          } else if (status === 1) {
-            promise.resolve(value);
-          } else {
-            promise.reject(value);
-          }
-        } catch(e) {
-          promise.reject(e);
-          exceptionHandler(e);
-        }
-      }
-      pending = [];
+  function makePromise(value, resolved) {
+    var result = defer();
+    if (resolved) {
+      result.resolve(value);
+    } else {
+      result.reject(value);
     }
+    return result.promise;
+  }
 
-    function scheduleProcessQueue() {
-      if (processScheduled) return;
-      processScheduled = true;
-      nextTick(processQueue);
+  function handleCallback(value, isResolved, callback) {
+    var callbackOutput = null;
+    try {
+      if (isFunction(callback)) callbackOutput = callback();
+    } catch(e) {
+      return makePromise(e, false);
     }
+    if (callbackOutput && isFunction(callbackOutput.then)) {
+      return callbackOutput.then(function() {
+        return makePromise(value, isResolved);
+      }, function(error) {
+        return makePromise(error, false);
+      });
+    } else {
+      return makePromise(value, isResolved);
+    }
+  }
+
 
-    function resolve(val) {
-      var then, fns;
+  function processQueue(state) {
+    var fn, promise;
 
-      if (status) return;
-      if (val === deferred.promise) throw new TypeError('Cycle detected');
-      fns = callOnce(resolve, reject);
+    state.processScheduled = false;
+    if (!state.status) return;
+    for (var i = 0; i < state.pending.length; ++i) {
+      promise = state.pending[i][0];
+      fn = state.pending[i][state.status];
       try {
-        if ((isObject(val) || isFunction(val))) then = val && val.then;
-        if (isFunction(then)) {
-          then.call(val, fns[0], fns[1], deferred.notify);
+        if (isFunction(fn)) {
+          promise.resolve(fn(state.value));
+        } else if (state.status === 1) {
+          promise.resolve(state.value);
         } else {
-          value = val;
-          status = 1;
-          scheduleProcessQueue();
+          promise.reject(state.value);
         }
       } catch(e) {
-        fns[1](e);
+        promise.reject(e);
         exceptionHandler(e);
       }
     }
+    state.pending = [];
+  }
+
+  function scheduleProcessQueue(state) {
+    if (state.processScheduled) return;
+    state.processScheduled = true;
+    nextTick(function() { processQueue(state); });
+  }
+
+  function Promise(state) {
+    this.$$state = state;
+  }
+
+  Promise.prototype.then = function(onFulfilled, onRejected, progressBack) {
+    var result = defer();
+
+    this.$$state.pending.push([result, onFulfilled, onRejected, progressBack]);
+    if (this.$$state.status) scheduleProcessQueue(this.$$state);
+
+    return result.promise;
+  };
+
+  Promise.prototype["catch"] = function(callback) {
+    return this.then(null, callback);
+  };
+
+  Promise.prototype["finally"] = function(callback, progressBack) {
+    return this.then(function(value) {
+        return handleCallback(value, true, callback);
+      }, function(error) {
+        return handleCallback(error, false, callback);
+      }, progressBack);
+  };
+
+
+  function Defer() {
+    this.$$state = {
+      pending: [],
+      status: 0,
+      value: undefined,
+      processScheduled: false
+    };
+    this.promise = new Promise(this.$$state);
+  }
+
+  Defer.prototype.resolve = function(val) {
+    var then, fns;
 
-    function reject(reason) {
-      if (status) return;
-      value = reason;
-      status = 2;
-      scheduleProcessQueue();
+    if (this.$$state.status) return;
+    if (val === this.promise) throw new TypeError('Cycle detected');
+    fns = callOnce(this.resolve, this.reject);
+    try {
+      if ((isObject(val) || isFunction(val))) then = val && val.then;
+      if (isFunction(then)) {
+        then.call(val, fns[0], fns[1], this.notify);
+      } else {
+        this.$$state.value = val;
+        this.$$state.status = 1;
+        scheduleProcessQueue(this.$$state);
+      }
+    } catch(e) {
+      fns[1](e);
+      exceptionHandler(e);
     }
+  };
 
-    deferred = {
-      promise: {
-        then: function(onFulfilled, onRejected, progressBack) {
-          var result = defer();
-
-          pending.push([result, onFulfilled, onRejected, progressBack]);
-          if (status) scheduleProcessQueue();
-
-          return result.promise;
-        },
-
-        "catch": function(callback) {
-          return deferred.promise.then(null, callback);
-        },
-
-        "finally": function(callback, progressBack) {
-          function makePromise(value, resolved) {
-            var result = defer();
-            if (resolved) {
-              result.resolve(value);
-            } else {
-              result.reject(value);
-            }
-            return result.promise;
-          }
+  Defer.prototype.reject = function(reason) {
+    if (this.$$state.status) return;
+    this.$$state.value = reason;
+    this.$$state.status = 2;
+    scheduleProcessQueue(this.$$state);
+  };
 
-          function handleCallback(value, isResolved) {
-            var callbackOutput = null;
-            try {
-              if (isFunction(callback)) callbackOutput = callback();
-            } catch(e) {
-              return makePromise(e, false);
-            }
-            if (callbackOutput && isFunction(callbackOutput.then)) {
-              return callbackOutput.then(function() {
-                return makePromise(value, isResolved);
-              }, function(error) {
-                return makePromise(error, false);
-              });
-            } else {
-              return makePromise(value, isResolved);
-            }
-          }
+  Defer.prototype.notify = function(progress) {
+    var callbacks = this.$$state.pending;
 
-          return this.then(function(value) {
-            return handleCallback(value, true);
-          }, function(error) {
-            return handleCallback(error, false);
-          }, progressBack);
-        }
-      },
-      resolve: resolve,
-      reject: reject,
-      notify: function(progress) {
-        var callbacks = pending;
-
-        if (!status && callbacks.length) {
-          nextTick(function() {
-            var callback, result;
-            for (var i = 0, ii = callbacks.length; i < ii; i++) {
-              result = callbacks[i][0];
-              callback = callbacks[i][3];
-              try {
-                result.notify(isFunction(callback) ? callback(progress) : progress);
-              } catch(e) {
-                exceptionHandler(e);
-              }
-            }
-          });
+    if (!this.$$state.status && callbacks.length) {
+      nextTick(function() {
+        var callback, result;
+        for (var i = 0, ii = callbacks.length; i < ii; i++) {
+          result = callbacks[i][0];
+          callback = callbacks[i][3];
+          try {
+            result.notify(isFunction(callback) ? callback(progress) : progress);
+          } catch(e) {
+            exceptionHandler(e);
+          }
         }
-      }
-    };
+      });
+    }
+  };
+
+  /**
+   * @ngdoc
+   * @name ng.$q#defer
+   * @methodOf ng.$q
+   * @description
+   * Creates a `Deferred` object which represents a task which will finish in the future.
+   *
+   * @returns {Deferred} Returns a new instance of deferred.
+   */
+  var defer = function() {
+
+    var result = new Defer();
+    result.resolve = bind(result, result.resolve);
+    result.reject = bind(result, result.reject);
+    result.notify = bind(result, result.notify);
+    result.promise = new Promise(result.$$state);
 
-    return deferred;
+    return result;
   };
 
   /**