path: root/deps/v8/src/builtins/promise-abstract-operations.tq

// Copyright 2019 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include 'src/builtins/builtins-promise.h'
#include 'src/builtins/builtins-promise-gen.h'

namespace runtime {
  extern transitioning runtime
  RejectPromise(implicit context: Context)(JSPromise, JSAny, Boolean): JSAny;

  extern transitioning runtime
  PromiseRevokeReject(implicit context: Context)(JSPromise): JSAny;

  extern transitioning runtime
  PromiseRejectAfterResolved(implicit context: Context)(JSPromise, JSAny):
      JSAny;

  extern transitioning runtime
  PromiseResolveAfterResolved(implicit context: Context)(JSPromise, JSAny):
      JSAny;

  extern transitioning runtime
  PromiseRejectEventFromStack(implicit context: Context)(JSPromise, JSAny):
      JSAny;
}

// https://tc39.es/ecma262/#sec-promise-abstract-operations
namespace promise {
  extern macro AllocateFunctionWithMapAndContext(
      Map, SharedFunctionInfo, Context): JSFunction;

  extern macro PromiseReactionMapConstant(): Map;
  extern macro PromiseFulfillReactionJobTaskMapConstant(): Map;
  extern macro PromiseRejectReactionJobTaskMapConstant(): Map;
  extern transitioning builtin
  ResolvePromise(Context, JSPromise, JSAny): JSAny;

  extern transitioning builtin
  EnqueueMicrotask(Context, Microtask): Undefined;

  macro
  ExtractHandlerContext(implicit context: Context)(handler: Callable|Undefined):
      Context labels NotFound {
    let iter: JSAny = handler;
    while (true) {
      typeswitch (iter) {
        case (b: JSBoundFunction): {
          iter = b.bound_target_function;
        }
        case (p: JSProxy): {
          iter = p.target;
        }
        case (f: JSFunction): {
          return f.context;
        }
        case (JSAny): {
          break;
        }
      }
    }
    goto NotFound;
  }

  // According to the HTML specification, we use the handler's context to
  // EnqueueJob for Promise resolution.
  macro
  ExtractHandlerContext(implicit context: Context)(
      primary: Callable|Undefined, secondary: Callable|Undefined): Context {
    try {
      return ExtractHandlerContext(primary) otherwise NotFound;
    }
    label NotFound deferred {
      return ExtractHandlerContext(secondary) otherwise Default;
    }
    label Default deferred {
      return context;
    }
  }

  transitioning macro MorphAndEnqueuePromiseReaction(implicit context: Context)(
      promiseReaction: PromiseReaction, argument: JSAny,
      reactionType: constexpr PromiseReactionType): void {
    let primaryHandler: Callable|Undefined;
    let secondaryHandler: Callable|Undefined;
    if constexpr (reactionType == kPromiseReactionFulfill) {
      primaryHandler = promiseReaction.fulfill_handler;
      secondaryHandler = promiseReaction.reject_handler;
    } else {
      StaticAssert(reactionType == kPromiseReactionReject);
      primaryHandler = promiseReaction.reject_handler;
      secondaryHandler = promiseReaction.fulfill_handler;
    }

    const handlerContext: Context =
        ExtractHandlerContext(primaryHandler, secondaryHandler);

    // Morph {current} from a PromiseReaction into a PromiseReactionJobTask
    // and schedule that on the microtask queue. We try to minimize the number
    // of stores here to avoid screwing up the store buffer.
    StaticAssert(
        kPromiseReactionSize ==
        kPromiseReactionJobTaskSizeOfAllPromiseReactionJobTasks);
    if constexpr (reactionType == kPromiseReactionFulfill) {
      promiseReaction.map = PromiseFulfillReactionJobTaskMapConstant();
      const promiseReactionJobTask =
          UnsafeCast<PromiseFulfillReactionJobTask>(promiseReaction);
      promiseReactionJobTask.argument = argument;
      promiseReactionJobTask.context = handlerContext;
      EnqueueMicrotask(handlerContext, promiseReactionJobTask);
      StaticAssert(
          kPromiseReactionFulfillHandlerOffset ==
          kPromiseReactionJobTaskHandlerOffset);
      StaticAssert(
          kPromiseReactionPromiseOrCapabilityOffset ==
          kPromiseReactionJobTaskPromiseOrCapabilityOffset);
    } else {
      StaticAssert(reactionType == kPromiseReactionReject);
      promiseReaction.map = PromiseRejectReactionJobTaskMapConstant();
      const promiseReactionJobTask =
          UnsafeCast<PromiseRejectReactionJobTask>(promiseReaction);
      promiseReactionJobTask.argument = argument;
      promiseReactionJobTask.context = handlerContext;
      promiseReactionJobTask.handler = primaryHandler;
      EnqueueMicrotask(handlerContext, promiseReactionJobTask);
      StaticAssert(
          kPromiseReactionPromiseOrCapabilityOffset ==
          kPromiseReactionJobTaskPromiseOrCapabilityOffset);
    }
  }

  // https://tc39.es/ecma262/#sec-triggerpromisereactions
  transitioning macro TriggerPromiseReactions(implicit context: Context)(
      reactions: Zero|PromiseReaction, argument: JSAny,
      reactionType: constexpr PromiseReactionType): void {
    // We need to reverse the {reactions} here, since we record them on the
    // JSPromise in the reverse order.
    let current = reactions;
    let reversed: Zero|PromiseReaction = kZero;

    // As an additional safety net against misuse of the V8 Extras API, we
    // sanity check the {reactions} to make sure that they are actually
    // PromiseReaction instances and not actual JavaScript values (which
    // would indicate that we're rejecting or resolving an already settled
    // promise), see https://crbug.com/931640 for details on this.
    while (true) {
      typeswitch (current) {
        case (Zero): {
          break;
        }
        case (currentReaction: PromiseReaction): {
          current = currentReaction.next;
          currentReaction.next = reversed;
          reversed = currentReaction;
        }
      }
    }
    // Morph the {reactions} into PromiseReactionJobTasks and push them
    // onto the microtask queue.
    current = reversed;
    while (true) {
      typeswitch (current) {
        case (Zero): {
          break;
        }
        case (currentReaction: PromiseReaction): {
          current = currentReaction.next;
          MorphAndEnqueuePromiseReaction(
              currentReaction, argument, reactionType);
        }
      }
    }
  }

  // https://tc39.es/ecma262/#sec-fulfillpromise
  transitioning builtin
  FulfillPromise(implicit context: Context)(promise: JSPromise, value: JSAny):
      Undefined {
    // Assert: The value of promise.[[PromiseState]] is "pending".
    assert(promise.Status() == PromiseState::kPending);

    // 2. Let reactions be promise.[[PromiseFulfillReactions]].
    const reactions =
        UnsafeCast<(Zero | PromiseReaction)>(promise.reactions_or_result);

    // 3. Set promise.[[PromiseResult]] to value.
    // 4. Set promise.[[PromiseFulfillReactions]] to undefined.
    // 5. Set promise.[[PromiseRejectReactions]] to undefined.
    promise.reactions_or_result = value;

    // 6. Set promise.[[PromiseState]] to "fulfilled".
    promise.SetStatus(PromiseState::kFulfilled);

    // 7. Return TriggerPromiseReactions(reactions, value).
    TriggerPromiseReactions(reactions, value, kPromiseReactionFulfill);
    return Undefined;
  }

  extern macro PromiseBuiltinsAssembler::
      IsPromiseHookEnabledOrDebugIsActiveOrHasAsyncEventDelegate(): bool;

  // https://tc39.es/ecma262/#sec-rejectpromise
  transitioning builtin
  RejectPromise(implicit context: Context)(
      promise: JSPromise, reason: JSAny, debugEvent: Boolean): JSAny {
    // If promise hook is enabled or the debugger is active, let
    // the runtime handle this operation, which greatly reduces
    // the complexity here and also avoids a couple of back and
    // forth between JavaScript and C++ land.
    if (IsPromiseHookEnabledOrDebugIsActiveOrHasAsyncEventDelegate() ||
        !promise.HasHandler()) {
      // 7. If promise.[[PromiseIsHandled]] is false, perform
      //    HostPromiseRejectionTracker(promise, "reject").
      // We don't try to handle rejecting {promise} without handler
      // here, but we let the C++ code take care of this completely.
      return runtime::RejectPromise(promise, reason, debugEvent);
    }

    // 2. Let reactions be promise.[[PromiseRejectReactions]].
    const reactions =
        UnsafeCast<(Zero | PromiseReaction)>(promise.reactions_or_result);

    // 3. Set promise.[[PromiseResult]] to reason.
    // 4. Set promise.[[PromiseFulfillReactions]] to undefined.
    // 5. Set promise.[[PromiseRejectReactions]] to undefined.
    promise.reactions_or_result = reason;

    // 6. Set promise.[[PromiseState]] to "rejected".
    promise.SetStatus(PromiseState::kRejected);

    // 8. Return TriggerPromiseReactions(reactions, reason).
    TriggerPromiseReactions(reactions, reason, kPromiseReactionReject);
    return Undefined;
  }

  const kPromiseCapabilitySize:
      constexpr int31 generates 'PromiseCapability::kSize';
  const kPromiseBuiltinsCapabilitiesContextLength: constexpr int31
  generates 'PromiseBuiltins::kCapabilitiesContextLength';
  const kPromiseBuiltinsCapabilitySlot: constexpr ContextSlot
  generates 'PromiseBuiltins::kCapabilitySlot';
  const kPromiseBuiltinsPromiseSlot: constexpr ContextSlot
  generates 'PromiseBuiltins::kPromiseSlot';
  const kPromiseBuiltinsAlreadyResolvedSlot: constexpr ContextSlot
  generates 'PromiseBuiltins::kAlreadyResolvedSlot';
  const kPromiseBuiltinsDebugEventSlot: constexpr ContextSlot
  generates 'PromiseBuiltins::kDebugEventSlot';

  @export
  macro CreatePromiseCapabilitiesExecutorContext(
      nativeContext: NativeContext, capability: PromiseCapability): Context {
    const executorContext = AllocateSyntheticFunctionContext(
        nativeContext, kPromiseBuiltinsCapabilitiesContextLength);

    executorContext[kPromiseBuiltinsCapabilitySlot] = capability;
    return executorContext;
  }

  @export
  macro CreatePromiseCapability(
      promise: JSReceiver|Undefined, resolve: JSFunction|Undefined,
      reject: JSFunction|Undefined): PromiseCapability {
    return new PromiseCapability{
      map: kPromiseCapabilityMap,
      promise: promise,
      resolve: resolve,
      reject: reject
    };
  }

  @export
  struct PromiseResolvingFunctions {
    resolve: JSFunction;
    reject: JSFunction;
  }

  @export
  macro CreatePromiseResolvingFunctions(implicit context: Context)(
      promise: JSPromise, debugEvent: Object, nativeContext: NativeContext):
      PromiseResolvingFunctions {
    const promiseContext = CreatePromiseResolvingFunctionsContext(
        promise, debugEvent, nativeContext);
    const map = UnsafeCast<Map>(
        nativeContext
            [NativeContextSlot::STRICT_FUNCTION_WITHOUT_PROTOTYPE_MAP_INDEX]);
    const resolveInfo = UnsafeCast<SharedFunctionInfo>(
        nativeContext[NativeContextSlot::
                          PROMISE_CAPABILITY_DEFAULT_RESOLVE_SHARED_FUN_INDEX]);
    const resolve: JSFunction =
        AllocateFunctionWithMapAndContext(map, resolveInfo, promiseContext);
    const rejectInfo = UnsafeCast<SharedFunctionInfo>(
        nativeContext[NativeContextSlot::
                          PROMISE_CAPABILITY_DEFAULT_REJECT_SHARED_FUN_INDEX]);
    const reject: JSFunction =
        AllocateFunctionWithMapAndContext(map, rejectInfo, promiseContext);
    return PromiseResolvingFunctions{resolve: resolve, reject: reject};
  }

  transitioning macro
  InnerNewPromiseCapability(implicit context: Context)(
      constructor: HeapObject, debugEvent: Object): PromiseCapability {
    const nativeContext = LoadNativeContext(context);
    if (TaggedEqual(
            constructor,
            nativeContext[NativeContextSlot::PROMISE_FUNCTION_INDEX])) {
      const promise = NewJSPromise();

      const pair =
          CreatePromiseResolvingFunctions(promise, debugEvent, nativeContext);

      return CreatePromiseCapability(promise, pair.resolve, pair.reject);
    } else {
      // We have to create the capability before the associated promise
      // because the builtin PromiseConstructor uses the executor.
      const capability =
          CreatePromiseCapability(Undefined, Undefined, Undefined);
      const executorContext =
          CreatePromiseCapabilitiesExecutorContext(nativeContext, capability);

      const executorInfo = UnsafeCast<SharedFunctionInfo>(
          nativeContext[NativeContextSlot::
                            PROMISE_GET_CAPABILITIES_EXECUTOR_SHARED_FUN]);
      const functionMap = UnsafeCast<Map>(
          nativeContext
              [NativeContextSlot::STRICT_FUNCTION_WITHOUT_PROTOTYPE_MAP_INDEX]);
      const executor = AllocateFunctionWithMapAndContext(
          functionMap, executorInfo, executorContext);

      const promiseConstructor = UnsafeCast<Constructor>(constructor);
      const promise = Construct(promiseConstructor, executor);
      capability.promise = promise;

      if (!TaggedIsCallable(capability.resolve) ||
          !TaggedIsCallable(capability.reject)) {
        ThrowTypeError(MessageTemplate::kPromiseNonCallable);
      }
      return capability;
    }
  }

  // https://tc39.es/ecma262/#sec-newpromisecapability
  transitioning builtin
  NewPromiseCapability(implicit context: Context)(
      maybeConstructor: Object, debugEvent: Object): PromiseCapability {
    typeswitch (maybeConstructor) {
      case (Smi): {
        ThrowTypeError(MessageTemplate::kNotConstructor, maybeConstructor);
      }
      case (constructor: HeapObject): {
        if (!IsConstructor(constructor)) {
          ThrowTypeError(MessageTemplate::kNotConstructor, maybeConstructor);
        }
        return InnerNewPromiseCapability(constructor, debugEvent);
      }
    }
  }

  // https://tc39.es/ecma262/#sec-promise-reject-functions
  transitioning javascript builtin
  PromiseCapabilityDefaultReject(
      js-implicit context: NativeContext,
      receiver: JSAny)(reason: JSAny): JSAny {
    // 2. Let promise be F.[[Promise]].
    const promise = UnsafeCast<JSPromise>(context[kPromiseBuiltinsPromiseSlot]);

    // 3. Let alreadyResolved be F.[[AlreadyResolved]].
    const alreadyResolved =
        UnsafeCast<Boolean>(context[kPromiseBuiltinsAlreadyResolvedSlot]);

    // 4. If alreadyResolved.[[Value]] is true, return undefined.
    if (alreadyResolved == True) {
      return runtime::PromiseRejectAfterResolved(promise, reason);
    }

    // 5. Set alreadyResolved.[[Value]] to true.
    context[kPromiseBuiltinsAlreadyResolvedSlot] = True;

    // 6. Return RejectPromise(promise, reason).
    const debugEvent =
        UnsafeCast<Boolean>(context[kPromiseBuiltinsDebugEventSlot]);
    return RejectPromise(promise, reason, debugEvent);
  }

  // https://tc39.es/ecma262/#sec-promise-resolve-functions
  transitioning javascript builtin
  PromiseCapabilityDefaultResolve(
      js-implicit context: NativeContext,
      receiver: JSAny)(resolution: JSAny): JSAny {
    // 2. Let promise be F.[[Promise]].
    const promise = UnsafeCast<JSPromise>(context[kPromiseBuiltinsPromiseSlot]);

    // 3. Let alreadyResolved be F.[[AlreadyResolved]].
    const alreadyResolved =
        UnsafeCast<Boolean>(context[kPromiseBuiltinsAlreadyResolvedSlot]);

    // 4. If alreadyResolved.[[Value]] is true, return undefined.
    if (alreadyResolved == True) {
      return runtime::PromiseResolveAfterResolved(promise, resolution);
    }

    // 5. Set alreadyResolved.[[Value]] to true.
    context[kPromiseBuiltinsAlreadyResolvedSlot] = True;

    // The rest of the logic (and the catch prediction) is
    // encapsulated in the dedicated ResolvePromise builtin.
    return ResolvePromise(context, promise, resolution);
  }

  @export
  transitioning macro PerformPromiseThenImpl(implicit context: Context)(
      promise: JSPromise, onFulfilled: Callable|Undefined,
      onRejected: Callable|Undefined,
      resultPromiseOrCapability: JSPromise|PromiseCapability|Undefined): void {
    if (promise.Status() == PromiseState::kPending) {
      // The {promise} is still in "Pending" state, so we just record a new
      // PromiseReaction holding both the onFulfilled and onRejected callbacks.
      // Once the {promise} is resolved we decide on the concrete handler to
      // push onto the microtask queue.
      const promiseReactions =
          UnsafeCast<(Zero | PromiseReaction)>(promise.reactions_or_result);
      const reaction = NewPromiseReaction(
          promiseReactions, resultPromiseOrCapability, onFulfilled, onRejected);
      promise.reactions_or_result = reaction;
    } else {
      let map: Map;
      let handler: Callable|Undefined = Undefined;
      let handlerContext: Context;
      if (promise.Status() == PromiseState::kFulfilled) {
        map = PromiseFulfillReactionJobTaskMapConstant();
        handler = onFulfilled;
        handlerContext = ExtractHandlerContext(onFulfilled, onRejected);
      } else
        deferred {
          assert(promise.Status() == PromiseState::kRejected);
          map = PromiseRejectReactionJobTaskMapConstant();
          handler = onRejected;
          handlerContext = ExtractHandlerContext(onRejected, onFulfilled);
          if (!promise.HasHandler()) {
            runtime::PromiseRevokeReject(promise);
          }
        }

      const reactionsOrResult = promise.reactions_or_result;
      const microtask = NewPromiseReactionJobTask(
          map, handlerContext, reactionsOrResult, handler,
          resultPromiseOrCapability);
      EnqueueMicrotask(handlerContext, microtask);
    }
    promise.SetHasHandler();
  }

  // https://tc39.es/ecma262/#sec-performpromisethen
  transitioning builtin
  PerformPromiseThen(implicit context: Context)(
      promise: JSPromise, onFulfilled: Callable|Undefined,
      onRejected: Callable|Undefined,
      resultPromise: JSPromise|Undefined): JSAny {
    PerformPromiseThenImpl(promise, onFulfilled, onRejected, resultPromise);
    return resultPromise;
  }

  // https://tc39.es/ecma262/#sec-promise-reject-functions
  transitioning javascript builtin
  PromiseReject(js-implicit context: NativeContext, receiver: JSAny)(
      reason: JSAny): JSAny {
    // 1. Let C be the this value.
    // 2. If Type(C) is not Object, throw a TypeError exception.
    const receiver = Cast<JSReceiver>(receiver) otherwise
    ThrowTypeError(MessageTemplate::kCalledOnNonObject, 'PromiseReject');

    const promiseFun = context[NativeContextSlot::PROMISE_FUNCTION_INDEX];
    if (promiseFun == receiver) {
      const promise = NewJSPromise(PromiseState::kRejected, reason);
      runtime::PromiseRejectEventFromStack(promise, reason);
      return promise;
    } else {
      // 3. Let promiseCapability be ? NewPromiseCapability(C).
      const capability = NewPromiseCapability(receiver, True);

      // 4. Perform ? Call(promiseCapability.[[Reject]], undefined, « r »).
      const reject = UnsafeCast<Callable>(capability.reject);
      Call(context, reject, Undefined, reason);

      // 5. Return promiseCapability.[[Promise]].
      return capability.promise;
    }
  }

  const kPromiseExecutorAlreadyInvoked: constexpr MessageTemplate
  generates 'MessageTemplate::kPromiseExecutorAlreadyInvoked';

  // https://tc39.es/ecma262/#sec-getcapabilitiesexecutor-functions
  transitioning javascript builtin
  PromiseGetCapabilitiesExecutor(
      js-implicit context: NativeContext,
      receiver: JSAny)(resolve: JSAny, reject: JSAny): JSAny {
    const capability =
        UnsafeCast<PromiseCapability>(context[kPromiseBuiltinsCapabilitySlot]);
    if (capability.resolve != Undefined || capability.reject != Undefined)
      deferred {
        ThrowTypeError(kPromiseExecutorAlreadyInvoked);
      }

    capability.resolve = resolve;
    capability.reject = reject;
    return Undefined;
  }

  transitioning macro CallResolve(implicit context: Context)(
      constructor: Constructor, resolve: JSAny, value: JSAny): JSAny {
    // Undefined can never be a valid value for the resolve function,
    // instead it is used as a special marker for the fast path.
    if (resolve == Undefined) {
      return PromiseResolve(constructor, value);
    } else
      deferred {
        return Call(context, UnsafeCast<Callable>(resolve), constructor, value);
      }
  }

  transitioning javascript builtin
  PromiseConstructorLazyDeoptContinuation(
      js-implicit context: NativeContext, receiver: JSAny)(
      promise: JSAny, reject: JSAny, exception: JSAny|TheHole,
      _result: JSAny): JSAny {
    typeswitch (exception) {
      case (TheHole): {
      }
      case (e: JSAny): {
        Call(context, reject, Undefined, e);
      }
    }
    return promise;
  }
}