793         var reason = this._settledValue();
796                                       possiblyUnhandledRejection, reason, this);
893                 es5.defineProperty(eventData, "reason", {value: event.reason});
906                 es5.defineProperty(domEvent, "reason", {value: event.reason});
963     unhandledRejection: function (name, reason, promise) {  argument
964         return {reason: reason, promise: promise};
1346 function fireRejectionEvent(name, localHandler, reason, promise) {  argument
1354                 localHandler(reason, promise);
1362         if (!activeFireEvent(name, reason, promise) && !localEventFired) {
1363             formatAndLogError(reason, "Unhandled rejection ");
1673     throw this.reason;
1684 Promise.prototype.thenThrow = function (reason) {
1686         thrower, undefined, undefined, {reason: reason}, undefined);
1689 Promise.prototype.catchThrow = function (reason) {  argument
1692             undefined, thrower, undefined, {reason: reason}, undefined);
1696         return this.caught(reason, handler);
1988 function checkCancel(ctx, reason) {  argument
1991             ctx.cancelPromise._reject(reason);
2004 function fail(reason) {  argument
2005     if (checkCancel(this, reason)) return;
2006     errorObj.e = reason;
2026                         var reason =
2028                         promise._attachExtraTrace(reason);
2029                         errorObj.e = reason;
2183         var reason = new Promise.CancellationError(
2185         Promise.coroutine.returnSentinel = reason;
2186         this._promise._attachExtraTrace(reason);
2189                                                          reason);
2210 PromiseSpawn.prototype._promiseRejected = function(reason) {  argument
2212     this._promise._attachExtraTrace(reason);
2215         .call(this._generator, reason);
2669 function errorAdapter(reason, nodeback) {  argument
2671     if (!reason) {
2672         var newReason = new Error(reason + "");
2673         newReason.cause = reason;
2674         reason = newReason;
2676     var ret = tryCatch(nodeback).call(promise._boundValue(), reason);
2853         ret.rejectionReason = this.reason();
2906 Promise.reject = Promise.rejected = function (reason) {
2909     ret._rejectCallback(reason, true);
3159         var reason = new CancellationError("late cancellation observer");
3160         promise._attachExtraTrace(reason);
3161         this._reject(reason);
3166 function(reason, synchronous, ignoreNonErrorWarnings) {  argument
3167     var trace = util.ensureErrorObject(reason);
3168     var hasStack = trace === reason;
3171             util.classString(reason);
3175     this._reject(reason);
3186     }, function (reason) {  argument
3187         promise._rejectCallback(reason, synchronous);
3347 Promise.prototype._reject = function (reason) {  argument
3351     this._fulfillmentHandler0 = reason;
3354         return async.fatalError(reason, util.isNode);
3374 Promise.prototype._rejectPromises = function (len, reason) {  argument
3380         this._settlePromise(promise, handler, receiver, reason);
3390             var reason = this._fulfillmentHandler0;
3391             this._settlePromise0(this._rejectionHandler0, reason, bitField);
3392             this._rejectPromises(len, reason);
3543 …          "expecting an array or an iterable object but got " + util.classString(values)).reason();
3614 PromiseArray.prototype._reject = function (reason) {  argument
3616     this._promise._rejectCallback(reason, false);
3634 PromiseArray.prototype._promiseRejected = function (reason) {  argument
3636     this._reject(reason);
4373 SettledPromiseArray.prototype._promiseRejected = function (reason, index) {  argument
4376     ret._settledValueField = reason;
4457 SomePromiseArray.prototype._promiseRejected = function (reason) {  argument
4458     this._addRejected(reason);
4496 SomePromiseArray.prototype._addRejected = function (reason) {  argument
4497     this._values.push(reason);
4567 var reason = PromiseInspection.prototype.error =
4568 PromiseInspection.prototype.reason = function () {
4627 Promise.prototype.reason = function() {  method in Promise
4630     return reason.call(target);
4722     function reject(reason) {  argument
4724         promise._rejectCallback(reason, synchronous, true);
4798 function failureClear(reason) {  argument
4800     throw reason;