blob: e46e13bb3932ee7b23d056f4ba5cf197d9b8b5b2 [file] [log] [blame]
/*
* Copyright (C) 2015 Yusuke Suzuki <utatane.tea@gmail.com>.
* Copyright (C) 2016-2019 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
// @internal
@globalPrivate
function pushNewPromiseReaction(thenable, existingReactions, promiseOrCapability, onFulfilled, onRejected)
{
"use strict";
if (!existingReactions) {
existingReactions = {
@promiseOrCapability: promiseOrCapability,
@onFulfilled: onFulfilled,
@onRejected: onRejected,
// This is 3x then number of out of line reactions (promise, fulfill callback, reject callback).
@outOfLineReactionCounts: 0,
};
@putPromiseInternalField(thenable, @promiseFieldReactionsOrResult, existingReactions);
} else {
var outOfLineReactionCounts = existingReactions.@outOfLineReactionCounts;
@putByValDirect(existingReactions, outOfLineReactionCounts++, promiseOrCapability);
@putByValDirect(existingReactions, outOfLineReactionCounts++, onFulfilled);
@putByValDirect(existingReactions, outOfLineReactionCounts++, onRejected);
existingReactions.@outOfLineReactionCounts = outOfLineReactionCounts;
}
}
@globalPrivate
function newPromiseCapabilitySlow(constructor)
{
"use strict";
var promiseCapability = {
@resolve: @undefined,
@reject: @undefined,
@promise: @undefined,
};
var promise = new constructor((resolve, reject) => {
if (promiseCapability.@resolve !== @undefined)
@throwTypeError("resolve function is already set");
if (promiseCapability.@reject !== @undefined)
@throwTypeError("reject function is already set");
promiseCapability.@resolve = resolve;
promiseCapability.@reject = reject;
});
if (!@isCallable(promiseCapability.@resolve))
@throwTypeError("executor did not take a resolve function");
if (!@isCallable(promiseCapability.@reject))
@throwTypeError("executor did not take a reject function");
promiseCapability.@promise = promise;
return promiseCapability;
}
@globalPrivate
function newPromiseCapability(constructor)
{
"use strict";
if (constructor === @Promise) {
var promise = @newPromise();
var capturedPromise = promise;
function @resolve(resolution) {
return @resolvePromiseWithFirstResolvingFunctionCallCheck(capturedPromise, resolution);
}
function @reject(reason) {
return @rejectPromiseWithFirstResolvingFunctionCallCheck(capturedPromise, reason);
}
return { @resolve, @reject, @promise: promise };
}
return @newPromiseCapabilitySlow(constructor);
}
@globalPrivate
function promiseResolve(constructor, value)
{
"use strict";
if (@isPromise(value) && value.constructor === constructor)
return value;
if (constructor === @Promise) {
var promise = @newPromise();
@resolvePromiseWithFirstResolvingFunctionCallCheck(promise, value);
return promise;
}
return @promiseResolveSlow(constructor, value);
}
@globalPrivate
function promiseResolveSlow(constructor, value)
{
"use strict";
@assert(constructor !== @Promise);
var promiseCapability = @newPromiseCapabilitySlow(constructor);
promiseCapability.@resolve.@call(@undefined, value);
return promiseCapability.@promise;
}
@globalPrivate
function promiseRejectSlow(constructor, reason)
{
"use strict";
@assert(constructor !== @Promise);
var promiseCapability = @newPromiseCapabilitySlow(constructor);
promiseCapability.@reject.@call(@undefined, reason);
return promiseCapability.@promise;
}
@globalPrivate
function newHandledRejectedPromise(error)
{
"use strict";
var promise = @newPromise();
@rejectPromiseWithFirstResolvingFunctionCallCheck(promise, error);
@putPromiseInternalField(promise, @promiseFieldFlags, @getPromiseInternalField(promise, @promiseFieldFlags) | @promiseFlagsIsHandled);
return promise;
}
@globalPrivate
function triggerPromiseReactions(state, reactions, argument)
{
"use strict";
if (!reactions)
return;
var isResolved = state === @promiseStateFulfilled;
@enqueueJob(@promiseReactionJob, state, reactions.@promiseOrCapability, isResolved ? reactions.@onFulfilled : reactions.@onRejected, argument);
for (var i = 0, count = reactions.@outOfLineReactionCounts; i < count; i += 3) {
var promise = reactions[i];
var handler = isResolved ? reactions[i + 1] : reactions[i + 2];
@enqueueJob(@promiseReactionJob, state, promise, handler, argument);
}
@assert(i === count);
}
@globalPrivate
function resolvePromise(promise, resolution)
{
"use strict";
@assert(@isPromise(promise));
if (resolution === promise)
return @rejectPromise(promise, @makeTypeError("Cannot resolve a promise with itself"));
if (!@isObject(resolution))
return @fulfillPromise(promise, resolution);
var then;
try {
then = resolution.then;
} catch (error) {
return @rejectPromise(promise, error);
}
if (@isPromise(resolution) && then === @defaultPromiseThen) {
@enqueueJob(@promiseResolveThenableJobFast, resolution, promise);
return;
}
if (!@isCallable(then))
return @fulfillPromise(promise, resolution);
@enqueueJob(@promiseResolveThenableJob, resolution, then, @createResolvingFunctions(promise));
}
// Keep in sync with JSPromise::rejectedPromise.
@globalPrivate
function rejectPromise(promise, reason)
{
"use strict";
@assert(@isPromise(promise));
@assert((@getPromiseInternalField(promise, @promiseFieldFlags) & @promiseStateMask) == @promiseStatePending);
var flags = @getPromiseInternalField(promise, @promiseFieldFlags);
var reactions = @getPromiseInternalField(promise, @promiseFieldReactionsOrResult);
@putPromiseInternalField(promise, @promiseFieldReactionsOrResult, reason);
@putPromiseInternalField(promise, @promiseFieldFlags, flags | @promiseStateRejected);
if (!(flags & @promiseFlagsIsHandled))
@hostPromiseRejectionTracker(promise, @promiseRejectionReject);
@triggerPromiseReactions(@promiseStateRejected, reactions, reason);
}
@globalPrivate
function fulfillPromise(promise, value)
{
"use strict";
@assert(@isPromise(promise));
@assert((@getPromiseInternalField(promise, @promiseFieldFlags) & @promiseStateMask) == @promiseStatePending);
var flags = @getPromiseInternalField(promise, @promiseFieldFlags);
var reactions = @getPromiseInternalField(promise, @promiseFieldReactionsOrResult);
@putPromiseInternalField(promise, @promiseFieldReactionsOrResult, value);
@putPromiseInternalField(promise, @promiseFieldFlags, flags | @promiseStateFulfilled);
@triggerPromiseReactions(@promiseStateFulfilled, reactions, value);
}
@globalPrivate
function resolvePromiseWithFirstResolvingFunctionCallCheck(promise, value)
{
"use strict";
@assert(@isPromise(promise));
var flags = @getPromiseInternalField(promise, @promiseFieldFlags);
if (flags & @promiseFlagsIsFirstResolvingFunctionCalled)
return;
@putPromiseInternalField(promise, @promiseFieldFlags, flags | @promiseFlagsIsFirstResolvingFunctionCalled);
return @resolvePromise(promise, value);
}
@globalPrivate
function fulfillPromiseWithFirstResolvingFunctionCallCheck(promise, value)
{
"use strict";
@assert(@isPromise(promise));
var flags = @getPromiseInternalField(promise, @promiseFieldFlags);
if (flags & @promiseFlagsIsFirstResolvingFunctionCalled)
return;
@putPromiseInternalField(promise, @promiseFieldFlags, flags | @promiseFlagsIsFirstResolvingFunctionCalled);
return @fulfillPromise(promise, value);
}
@globalPrivate
function rejectPromiseWithFirstResolvingFunctionCallCheck(promise, reason)
{
"use strict";
@assert(@isPromise(promise));
var flags = @getPromiseInternalField(promise, @promiseFieldFlags);
if (flags & @promiseFlagsIsFirstResolvingFunctionCalled)
return;
@putPromiseInternalField(promise, @promiseFieldFlags, flags | @promiseFlagsIsFirstResolvingFunctionCalled);
return @rejectPromise(promise, reason);
}
@globalPrivate
function createResolvingFunctions(promise)
{
"use strict";
@assert(@isPromise(promise));
var alreadyResolved = false;
var resolve = (0, /* prevent function name inference */ (resolution) => {
if (alreadyResolved)
return @undefined;
alreadyResolved = true;
return @resolvePromise(promise, resolution);
});
var reject = (0, /* prevent function name inference */ (reason) => {
if (alreadyResolved)
return @undefined;
alreadyResolved = true;
return @rejectPromise(promise, reason);
});
return { @resolve: resolve, @reject: reject };
}
@globalPrivate
function promiseReactionJobWithoutPromise(handler, argument)
{
"use strict";
try {
handler(argument);
} catch {
// This is user-uncatchable promise. We just ignore the error here.
}
}
// This function has strong guarantee that each handler function (onFulfilled and onRejected) will be called at most once.
@globalPrivate
function resolveWithoutPromise(resolution, onFulfilled, onRejected)
{
"use strict";
if (!@isObject(resolution)) {
@fulfillWithoutPromise(resolution, onFulfilled, onRejected);
return;
}
var then;
try {
then = resolution.then;
} catch (error) {
@rejectWithoutPromise(error, onFulfilled, onRejected);
return;
}
if (@isPromise(resolution) && then === @defaultPromiseThen) {
@enqueueJob(@promiseResolveThenableJobWithoutPromiseFast, resolution, onFulfilled, onRejected);
return;
}
if (!@isCallable(then)) {
@fulfillWithoutPromise(resolution, onFulfilled, onRejected);
return;
}
// Wrap onFulfilled and onRejected with @createResolvingFunctionsWithoutPromise to ensure that each function will be called at most once.
@enqueueJob(@promiseResolveThenableJob, resolution, then, @createResolvingFunctionsWithoutPromise(onFulfilled, onRejected));
}
// This function has strong guarantee that each handler function (onFulfilled and onRejected) will be called at most once.
@globalPrivate
function rejectWithoutPromise(reason, onFulfilled, onRejected)
{
"use strict";
@enqueueJob(@promiseReactionJobWithoutPromise, onRejected, reason);
}
// This function has strong guarantee that each handler function (onFulfilled and onRejected) will be called at most once.
@globalPrivate
function fulfillWithoutPromise(value, onFulfilled, onRejected)
{
"use strict";
@enqueueJob(@promiseReactionJobWithoutPromise, onFulfilled, value);
}
// This function has strong guarantee that each handler function (onFulfilled and onRejected) will be called at most once.
// This is special version of resolveWithoutPromise which skips resolution's then handling.
// https://github.com/tc39/ecma262/pull/1250
@globalPrivate
function resolveWithoutPromiseForAsyncAwait(resolution, onFulfilled, onRejected)
{
"use strict";
if (@isPromise(resolution)) {
var constructor = resolution.constructor;
if (constructor === @Promise || constructor === @InternalPromise)
return @performPromiseThen(resolution, onFulfilled, onRejected);
}
return @resolveWithoutPromise(resolution, onFulfilled, onRejected);
}
@globalPrivate
function createResolvingFunctionsWithoutPromise(onFulfilled, onRejected)
{
"use strict";
var alreadyResolved = false;
var resolve = (0, /* prevent function name inference */ (resolution) => {
if (alreadyResolved)
return @undefined;
alreadyResolved = true;
@resolveWithoutPromise(resolution, onFulfilled, onRejected);
});
var reject = (0, /* prevent function name inference */ (reason) => {
if (alreadyResolved)
return @undefined;
alreadyResolved = true;
@rejectWithoutPromise(reason, onFulfilled, onRejected);
});
return { @resolve: resolve, @reject: reject };
}
@globalPrivate
function promiseReactionJob(state, promiseOrCapability, handler, argument)
{
// Promise Reaction has four types.
// 1. @promiseOrCapability is PromiseCapability, and having handlers.
// The most generic one.
// 2. @promiseOrCapability is Promise, and having handlers.
// We just have promise.
// 3. @promiseOrCapability is Promise, and not having handlers.
// It only has promise. Just resolving it with the value.
// 4. Only having @onFulfilled and @onRejected
// It does not have promise capability. Just handlers are passed.
"use strict";
// Case (3).
if (@isUndefinedOrNull(handler)) {
try {
@assert(@isPromise(promiseOrCapability));
if (state === @promiseStateFulfilled)
@resolvePromise(promiseOrCapability, argument);
else
@rejectPromise(promiseOrCapability, argument);
} catch {
// This is user-uncatchable promise. We just ignore the error here.
}
return;
}
// Case (4).
if (!promiseOrCapability) {
@promiseReactionJobWithoutPromise(handler, argument);
return;
}
// Case (1), or (2).
var result;
try {
result = handler(argument);
} catch (error) {
if (@isPromise(promiseOrCapability)) {
@rejectPromise(promiseOrCapability, error);
return;
}
promiseOrCapability.@reject.@call(@undefined, error);
return;
}
if (@isPromise(promiseOrCapability)) {
@resolvePromise(promiseOrCapability, result);
return;
}
promiseOrCapability.@resolve.@call(@undefined, result);
}
@globalPrivate
function promiseResolveThenableJobFast(thenable, promiseToResolve)
{
"use strict";
@assert(@isPromise(thenable));
@assert(@isPromise(promiseToResolve));
// Even if we are using @defaultPromiseThen, still thenable.constructor access is observable, and if it is not returning @Promise,
// we need to call this constructor.
var constructor = @speciesConstructor(thenable, @Promise);
if (constructor !== @Promise && constructor !== @InternalPromise) {
@promiseResolveThenableJobWithDerivedPromise(thenable, constructor, @createResolvingFunctions(promiseToResolve));
return;
}
var flags = @getPromiseInternalField(thenable, @promiseFieldFlags);
var state = flags & @promiseStateMask;
var reactionsOrResult = @getPromiseInternalField(thenable, @promiseFieldReactionsOrResult);
if (state === @promiseStatePending)
@pushNewPromiseReaction(thenable, reactionsOrResult, promiseToResolve, @undefined, @undefined);
else {
if (state === @promiseStateRejected && !(flags & @promiseFlagsIsHandled))
@hostPromiseRejectionTracker(thenable, @promiseRejectionHandle);
@enqueueJob(@promiseReactionJob, state, promiseToResolve, @undefined, reactionsOrResult);
}
@putPromiseInternalField(thenable, @promiseFieldFlags, @getPromiseInternalField(thenable, @promiseFieldFlags) | @promiseFlagsIsHandled);
}
@globalPrivate
function promiseResolveThenableJobWithoutPromiseFast(thenable, onFulfilled, onRejected)
{
"use strict";
@assert(@isPromise(thenable));
// Even if we are using @defaultPromiseThen, still thenable.constructor access is observable, and if it is not returning @Promise,
// we need to call this constructor.
var constructor = @speciesConstructor(thenable, @Promise);
if (constructor !== @Promise && constructor !== @InternalPromise) {
@promiseResolveThenableJobWithDerivedPromise(thenable, constructor, @createResolvingFunctionsWithoutPromise(onFulfilled, onRejected));
return;
}
var flags = @getPromiseInternalField(thenable, @promiseFieldFlags);
var state = flags & @promiseStateMask;
var reactionsOrResult = @getPromiseInternalField(thenable, @promiseFieldReactionsOrResult);
if (state === @promiseStatePending)
@pushNewPromiseReaction(thenable, reactionsOrResult, @undefined, onFulfilled, onRejected);
else {
if (state === @promiseStateRejected) {
if (!(flags & @promiseFlagsIsHandled))
@hostPromiseRejectionTracker(thenable, @promiseRejectionHandle);
@rejectWithoutPromise(reactionsOrResult, onFulfilled, onRejected);
} else
@fulfillWithoutPromise(reactionsOrResult, onFulfilled, onRejected);
}
@putPromiseInternalField(thenable, @promiseFieldFlags, @getPromiseInternalField(thenable, @promiseFieldFlags) | @promiseFlagsIsHandled);
}
@globalPrivate
function promiseResolveThenableJob(thenable, then, resolvingFunctions)
{
"use strict";
try {
return then.@call(thenable, resolvingFunctions.@resolve, resolvingFunctions.@reject);
} catch (error) {
return resolvingFunctions.@reject.@call(@undefined, error);
}
}
@globalPrivate
function promiseResolveThenableJobWithDerivedPromise(thenable, constructor, resolvingFunctions)
{
"use strict";
try {
var promiseOrCapability = @newPromiseCapabilitySlow(constructor);
@performPromiseThen(thenable, resolvingFunctions.@resolve, resolvingFunctions.@reject, promiseOrCapability);
return promiseOrCapability.@promise;
} catch (error) {
return resolvingFunctions.@reject.@call(@undefined, error);
}
}
@globalPrivate
function promiseEmptyOnFulfilled(argument)
{
"use strict";
return argument;
}
@globalPrivate
function promiseEmptyOnRejected(argument)
{
"use strict";
throw argument;
}
@globalPrivate
function performPromiseThen(promise, onFulfilled, onRejected, promiseOrCapability)
{
"use strict";
if (!@isCallable(onFulfilled))
onFulfilled = @promiseEmptyOnFulfilled;
if (!@isCallable(onRejected))
onRejected = @promiseEmptyOnRejected;
var reactionsOrResult = @getPromiseInternalField(promise, @promiseFieldReactionsOrResult);
var flags = @getPromiseInternalField(promise, @promiseFieldFlags);
var state = flags & @promiseStateMask;
if (state === @promiseStatePending)
@pushNewPromiseReaction(promise, reactionsOrResult, promiseOrCapability, onFulfilled, onRejected);
else {
var handler;
if (state === @promiseStateRejected) {
handler = onRejected;
if (!(flags & @promiseFlagsIsHandled))
@hostPromiseRejectionTracker(promise, @promiseRejectionHandle);
} else
handler = onFulfilled;
@enqueueJob(@promiseReactionJob, state, promiseOrCapability, handler, reactionsOrResult);
}
@putPromiseInternalField(promise, @promiseFieldFlags, @getPromiseInternalField(promise, @promiseFieldFlags) | @promiseFlagsIsHandled);
}