PromisePrototype.js [plain text]
function catch(onRejected)
{
"use strict";
return this.then(@undefined, onRejected);
}
function then(onFulfilled, onRejected)
{
"use strict";
if (!@isPromise(this))
@throwTypeError("|this| is not a Promise");
var constructor = @speciesConstructor(this, @Promise);
var promise;
var promiseOrCapability;
if (constructor === @Promise) {
promiseOrCapability = @newPromise();
promise = promiseOrCapability;
} else {
promiseOrCapability = @newPromiseCapabilitySlow(constructor);
promise = promiseOrCapability.@promise;
}
if (!@isCallable(onFulfilled))
onFulfilled = function (argument) { return argument; };
if (!@isCallable(onRejected))
onRejected = function (argument) { throw argument; };
var reaction = @newPromiseReaction(promiseOrCapability, onFulfilled, onRejected);
var flags = @getPromiseInternalField(this, @promiseFieldFlags);
var state = flags & @promiseStateMask;
if (state === @promiseStatePending) {
reaction.@next = @getPromiseInternalField(this, @promiseFieldReactionsOrResult);
@putPromiseInternalField(this, @promiseFieldReactionsOrResult, reaction);
} else {
if (state === @promiseStateRejected && !(flags & @promiseFlagsIsHandled))
@hostPromiseRejectionTracker(this, @promiseRejectionHandle);
@enqueueJob(@promiseReactionJob, state, reaction, @getPromiseInternalField(this, @promiseFieldReactionsOrResult));
}
@putPromiseInternalField(this, @promiseFieldFlags, @getPromiseInternalField(this, @promiseFieldFlags) | @promiseFlagsIsHandled);
return promise;
}
function finally(onFinally)
{
"use strict";
if (!@isObject(this))
@throwTypeError("|this| is not an object");
var constructor = @speciesConstructor(this, @Promise);
@assert(@isConstructor(constructor));
var thenFinally;
var catchFinally;
if (!@isCallable(onFinally)) {
thenFinally = onFinally;
catchFinally = onFinally;
} else {
thenFinally = @getThenFinally(onFinally, constructor);
catchFinally = @getCatchFinally(onFinally, constructor);
}
return this.then(thenFinally, catchFinally);
}
@globalPrivate
function getThenFinally(onFinally, constructor)
{
"use strict";
return (value) =>
{
@assert(@isCallable(onFinally));
var result = onFinally();
@assert(@isConstructor(constructor));
var resultCapability = @newPromiseCapability(constructor);
resultCapability.@resolve.@call(@undefined, result);
var promise = resultCapability.@promise;
return promise.then(() => value);
}
}
@globalPrivate
function getCatchFinally(onFinally, constructor)
{
"use strict";
return (reason) =>
{
@assert(@isCallable(onFinally));
var result = onFinally();
@assert(@isConstructor(constructor));
var resultCapability = @newPromiseCapability(constructor);
resultCapability.@resolve.@call(@undefined, result);
var promise = resultCapability.@promise;
return promise.then(() => { throw reason; });
}
}