Factor out some more try/catch statments

Also add comments

Author: Forbes Lindesay

src/core.js

@@ -4,13 +4,47 @@ var asap = require('asap/raw')
 
 function noop() {};
 
-var thenError = null;
+// States:
+//
+// 0 - pending
+// 1 - fulfilled with _value
+// 2 - rejected with _value
+// 3 - adopted the state of another promise, _value
+//
+// once the state is no longer pending (0) it is immutable
+
+// All `_` prefixed properties will be reduced to `_{random number}`
+// at build time to obfuscate them and discourage their use.
+// We don't use symbols or Object.defineProperty to fully hide them
+// because the performance isn't good enough.
+
+
+// to avoid using try/catch inside critical functions, we
+// extract them to here.
+var LAST_ERROR = null;
 var IS_ERROR = {};
 function getThen(obj) {
   try {
     return obj.then;
   } catch (ex) {
-    thenError = ex;
+    LAST_ERROR = ex;
+    return IS_ERROR;
+  }
+}
+
+function tryCallOne(fn, a) {
+  try {
+    return fn(a);
+  } catch (ex) {
+    LAST_ERROR = ex;
+    return IS_ERROR;
+  }
+}
+function tryCallTwo(fn, a, b) {
+  try {
+    fn(a, b);
+  } catch (ex) {
+    LAST_ERROR = ex;
     return IS_ERROR;
   }
 }
@@ -53,18 +87,15 @@ Promise.prototype._handle = function(deferred) {
   asap(function() {
     var cb = state === 1 ? deferred.onFulfilled : deferred.onRejected
     if (cb === null) {
-      (state === 1 ? deferred.resolve(value) : deferred.reject(value))
+      (state === 1 ? deferred.promise._resolve(value) : deferred.promise._reject(value))
       return
     }
-    var ret
-    try {
-      ret = cb(value)
-    }
-    catch (e) {
-      deferred.reject(e)
-      return
+    var ret = tryCallOne(cb, value);
+    if (ret === IS_ERROR) {
+      deferred.promise._reject(LAST_ERROR)
+    } else {
+      deferred.promise._resolve(ret)
     }
-    deferred.resolve(ret)
   });
 };
 Promise.prototype._resolve = function(newValue) {
@@ -75,7 +106,7 @@ Promise.prototype._resolve = function(newValue) {
   if (newValue && (typeof newValue === 'object' || typeof newValue === 'function')) {
     var then = getThen(newValue);
     if (then === IS_ERROR) {
-      return this._reject(thenError);
+      return this._reject(LAST_ERROR);
     }
     if (
       then === this.then &&
@@ -115,12 +146,6 @@ function Handler(onFulfilled, onRejected, promise){
   this.onRejected = typeof onRejected === 'function' ? onRejected : null
   this.promise = promise;
 }
-Handler.prototype.resolve = function (value) {
-  this.promise._resolve(value);
-};
-Handler.prototype.reject = function (value) {
-  this.promise._reject(value);
-}
 
 /**
  * Take a potentially misbehaving resolver function and make sure
@@ -130,19 +155,17 @@ Handler.prototype.reject = function (value) {
  */
 function doResolve(fn, promise) {
   var done = false;
-  try {
-    fn(function (value) {
-      if (done) return
-      done = true
-      promise._resolve(value)
-    }, function (reason) {
-      if (done) return
-      done = true
-      promise._reject(reason)
-    })
-  } catch (ex) {
+  var res = tryCallTwo(fn, function (value) {
     if (done) return
     done = true
-    promise._reject(ex)
+    promise._resolve(value)
+  }, function (reason) {
+    if (done) return
+    done = true
+    promise._reject(reason)
+  })
+  if (!done && res === IS_ERROR) {
+    done = true
+    promise._reject(LAST_ERROR)
   }
 }